### Clone and Setup CueWeb

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

Clones the OpenCue repository, navigates to the cueweb directory, installs project dependencies using npm, and copies the example environment file to be configured for development.

```bash
# Clone OpenCue repository
git clone https://github.com/AcademySoftwareFoundation/OpenCue.git
cd OpenCue/cueweb

# Install dependencies
npm install

# Create development environment file
cp .env.example .env
```

--------------------------------

### Install and Verify cuecmd

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Installs cuecmd using pip or from source and verifies the installation by checking the help command. Ensure Python 3.7+ is installed.

```bash
# Verify installation
cuecmd --help
```

```bash
pip install opencue-cuecmd
```

```bash
cd OpenCue/cuecmd
pip install .
```

--------------------------------

### Example: Batch Image Conversion with cuecmd

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

An example demonstrating the conversion of multiple image files using bash loops to generate commands, then submitting them to OpenCue with specified chunking and resource requirements.

```bash
# Generate conversion commands
for i in {1..100};
  do
    echo "convert input_${i}.jpg -resize 50% output_${i}.jpg"
  done > convert_images.txt

# Submit with 10 commands per frame (100 commands = 10 frames)
cuecmd convert_images.txt --chunk 10 --cores 2 --memory 2
```

--------------------------------

### Install CueWeb Node.js Dependencies

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cueweb.md

Installs all the necessary Node.js packages required for CueWeb to run, as defined in the package.json file. This command should be run from within the CueWeb directory.

```bash
npm install

```

--------------------------------

### Install Python Dependencies for OpenCue

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-windows.md

Installs the 'pycue' and 'cuegui' Python packages required for interacting with OpenCue services and launching the graphical user interface. Uses pip for installation.

```bash
pip install pycue cuegui
```

--------------------------------

### Full OpenCue NIMBY Configuration Example

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/user-guides/cuenimby-user-guide.md

This comprehensive JSON configuration demonstrates all available options for CueNIMBY, including connection settings, notification preferences, and a basic scheduler setup.

```json
{
  "cuebot_host": "cuebot.example.com",
  "cuebot_port": 8443,
  "hostname": null,
  "poll_interval": 5,
  "show_notifications": true,
  "notification_duration": 5,
  "scheduler_enabled": true,
  "schedule": {
    "monday": {
      "start": "09:00",
      "end": "18:00",
      "state": "disabled"
    }
  }
}
```

--------------------------------

### Clone OpenCue Repository

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuenimby.md

Clones the OpenCue repository from GitHub to your local machine. This is the first step to installing CueNIMBY from source. Ensure you replace '<username>' with your GitHub username.

```bash
git clone https://github.com/<username>/OpenCue.git
cd OpenCue
```

--------------------------------

### Setup Development Environment for cuecmd

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/cuecmd/README.md

Guides users through setting up a local development environment for 'cuecmd'. It includes cloning the repository, navigating to the directory, and installing development dependencies using pip. This is the first step for developers wanting to contribute to the project.

```bash
# Clone and setup
git clone https://github.com/<username>/OpenCue.git
cd OpenCue/cuecmd

# Install with development dependencies
pip install -e ".[dev]"
```

--------------------------------

### List Installed Python Packages

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuenimby.md

Lists all installed Python packages and filters for 'pycue'. This helps verify that the OpenCue client libraries are installed.

```bash
pip list | grep pycue
```

--------------------------------

### Install OpenCue Client Tools from Source

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-linux.md

This script installs all OpenCue Python client libraries directly from the source code within the activated virtual environment. This includes protocol buffers, PyCue, PyOutline, and various command-line tools.

```bash
sandbox/install-client-sources.sh
```

--------------------------------

### Set up Cuecmd Development Environment

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cuecmd-development.md

This section outlines the steps to set up a development environment for cuecmd. It includes cloning the repository, creating and activating a virtual environment, installing necessary dependencies for protocol buffers, PyCue, and PyOutline, and finally installing cuecmd in editable mode with development dependencies.

```bash
# 1. Clone repository
git clone https://github.com/<username>/OpenCue.git
cd OpenCue

# 2. Create virtual environment
python3 -m venv venv
source venv/bin/activate

# 3. Install dependencies
pip install ./proto
pip install ./pycue
pip install ./pyoutline

# 4. Install cuecmd in editable mode with dev dependencies
pip install -e ./cuecmd[dev]
```

--------------------------------

### Development Environment Setup

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/rest-gateway-development.md

Instructions and commands to set up the development environment, including cloning the repository, starting services with Docker, and installing dependencies.

```APIDOC
## Development Environment Setup

### Prerequisites

- Go 1.19 or later
- Protocol Buffers compiler (`protoc`)
- Docker and Docker Compose
- Git
- Make (optional, for automation)

### Initial Setup

- **Clone the repository:**

```bash
git clone https://github.com/AcademySoftwareFoundation/OpenCue.git
cd OpenCue
```

- **Quick Development Start with Docker:**

**Note:** The REST Gateway is not included in OpenCue's main docker-compose.yml and must be deployed separately.

```bash
# Start the OpenCue stack first
docker compose up -d

# Build and start REST Gateway separately
cd rest_gateway
docker build -f Dockerfile -t opencue-rest-gateway-dev .
docker run -d --name opencue-gateway-dev \
  --network opencue_default \
  -p 8448:8448 \
  -e CUEBOT_ENDPOINT=cuebot:8443 \
  -e JWT_SECRET=dev-secret-key \
  opencue-rest-gateway-dev

# The REST Gateway will be available at http://localhost:8448
# Cuebot gRPC will be available at localhost:8443
```

- **Install Go dependencies (for local development):**

```bash
cd rest_gateway/opencue_gateway
go mod download
```

- **Install protobuf dependencies:**

```bash
# On Ubuntu/Debian
sudo apt-get install protobuf-compiler

# On macOS with Homebrew
brew install protobuf

# On Rocky Linux/CentOS
sudo dnf install protobuf protobuf-devel protobuf-compiler
```

- **Install Go protobuf plugins:**

```bash
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@latest
```

### Environment Configuration

Create a development environment file:

```bash
# .env.dev
GRPC_ENDPOINT=localhost:8443
HTTP_PORT=8448
JWT_SECRET=dev-secret-key-change-in-production
LOG_LEVEL=debug
CORS_ALLOWED_ORIGINS=*
```
```

--------------------------------

### Setup Python Environment for RQD

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/rqd/README.md

This snippet details the steps to set up a Python virtual environment for building and running RQD from source. It includes creating the environment, activating it, installing necessary proto files, and finally installing RQD itself.

```bash
# Create virtual environment
python3 -m venv OpenCue-venv
# Activate virtual environment
source OpenCue-venv/bin/activate
# Change directory to Opencue source
cd <OpenCueSourceDir>

# Install compiled proto files which is needed by RQD into the virtual environment
pip install ./proto

# Install RQD into the virtual environment
pip install ./rqd
```

--------------------------------

### Install wget using Homebrew

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-mac.md

Installs the `wget` command-line utility on macOS using the Homebrew package manager. This is a prerequisite for downloading files or repositories.

```shell
brew install wget
```

--------------------------------

### Install OpenCue Client Packages from Source

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-mac.md

This snippet provides an alternative method to install OpenCue client packages directly from the source code. This is useful if you are working with the latest development changes, but be aware of potential incompatibilities with prebuilt Docker images. Ensure a virtual environment is activated.

```bash
cd OpenCue
python3 -m venv sandbox-venv
source sandbox-venv/bin/activate
sandbox/install-client-sources.sh
```

--------------------------------

### Install OpenCue Client Packages with Version

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-mac.md

This snippet demonstrates how to install the latest OpenCue client packages. It first sets an environment variable for the version using a script and then executes another script to install the packages within a virtual environment. Ensure you are in the root of the OpenCue source code directory and have activated a virtual environment.

```bash
cd OpenCue
python3 -m venv sandbox-venv
source sandbox-venv/bin/activate
export VERSION=$(sandbox/get-latest-release-tag.sh)
sandbox/install-client-archives.sh
```

--------------------------------

### Essential CueAdmin Commands - Shell

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/installing-cueadmin.md

Provides examples of essential CueAdmin commands for listing key OpenCue resources, including shows, allocations, hosts, and running jobs.

```shell
# List all shows
cueadmin -ls

# List all allocations
cueadmin -la

# List hosts
cueadmin -lh

# List running jobs
cueadmin -lj
```

--------------------------------

### Run CueAdmin Example - Shell

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/installing-cueadmin.md

Executes the CueAdmin command to list all shows from a Cuebot instance running on localhost. This demonstrates a basic interaction with the OpenCue system using CueAdmin.

```shell
cueadmin -server localhost -ls
```

--------------------------------

### Build and Run CueWeb from Source

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/deploying-cueweb.md

Instructions for building and running CueWeb from source without Docker. Includes installing Node.js dependencies, building the production bundle, and starting the server using npm or PM2 for process management.

```bash
# Install Node.js dependencies
npm install

# Build production bundle
npm run build

# Start production server
npm run start

# Or use PM2 for process management
npm install -g pm2
pm2 start npm --name "cueweb" -- start
pm2 save
pm2 startup
```

--------------------------------

### Go Project Build and Setup Commands

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/rest_gateway/README.md

Commands to set up the development environment for OpenCue's REST Gateway. This includes cloning the repository, initializing Go modules, installing protocol buffer compilers and plugins, generating gRPC code, and building the gateway.

```bash
# Prerequisites
go version  # Go 1.21+ required
protoc --version  # Protocol Buffers compiler

# Clone and build
git clone https://github.com/AcademySoftwareFoundation/OpenCue.git
cd OpenCue/rest_gateway/opencue_gateway

# Initialize module and install dependencies
go mod init opencue_gateway
go mod tidy

# Install protoc plugins
go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@latest
go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@latest
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# Generate gRPC code
mkdir -p gen/go
protoc -I ../../proto/src/ \
    --go_out ./gen/go/ \
    --go_opt paths=source_relative \
    --go-grpc_out ./gen/go/ \
    --go-grpc_opt paths=source_relative \
    ../../proto/src/*.proto

# Generate REST gateway handlers
protoc -I ../../proto/src/ \
    --grpc-gateway_out ./gen/go \
    --grpc-gateway_opt paths=source_relative \
    --grpc-gateway_opt generate_unbound_methods=true \
    ../../proto/src/*.proto

# Build
go build -o opencue_gateway main.go

# Run
export CUEBOT_ENDPOINT=localhost:8443
export JWT_SECRET=dev-secret
export REST_PORT=8448
./opencue_gateway
```

--------------------------------

### Install WSL2 on Windows

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-windows.md

Installs the Windows Subsystem for Linux version 2, a prerequisite for running Docker Desktop with WSL2 backend. Requires administrative privileges.

```powershell
wsl --install
```

--------------------------------

### Quick Docker Development Start for REST Gateway

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/rest-gateway-development.md

Instructions for starting the OpenCue stack and then building and running the REST Gateway in a Docker container. It outlines the necessary Docker commands and environment variables for a quick local setup.

```bash
# Start the OpenCue stack first
docker compose up -d

# Build and start REST Gateway separately
cd rest_gateway
docker build -f Dockerfile -t opencue-rest-gateway-dev .
docker run -d --name opencue-gateway-dev \
  --network opencue_default \
  -p 8448:8448 \
  -e CUEBOT_ENDPOINT=cuebot:8443 \
  -e JWT_SECRET=dev-secret-key \
  opencue-rest-gateway-dev

# The REST Gateway will be available at http://localhost:8448
# Cuebot gRPC will be available at localhost:8443
```

--------------------------------

### Submit First Job using PyOutline

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/getting-started-tutorial.md

This Python script demonstrates how to define and submit a simple render job to OpenCue using the PyOutline library. It sets up a job with a single layer that echoes frame numbers and includes a short delay. This is recommended for learning OpenCue's programmatic job submission.

```python
#!/usr/bin/env python3

import outline
import outline.modules.shell

# Create a new job
job = outline.Outline(
    name="my-first-job",
    shot="tutorial", 
    show="learning",
    user="student"
)

# Add a simple layer that prints frame numbers
test_layer = outline.modules.shell.Shell(
    name="test-layer",
    command=["echo", "Processing frame #IFRAME#", "&&", "sleep", "5"],
    range="1-10"
)

# Add the layer to the job
job.add_layer(test_layer)

# Submit the job
print("Submitting job:", job.get_name())
outline.cuerun.launch(job, use_pycuerun=False)
print("Job submitted successfully!")
```

--------------------------------

### Start CueWeb Development Server

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

Starts the CueWeb development server using npm. This command enables hot reloading, allowing for rapid iteration during development. The server typically runs on http://localhost:3000.

```bash
# Start the development server
npm run dev

# Server will start at http://localhost:3000
# Hot reload enabled for development
```

--------------------------------

### Initialize and Start PostgreSQL Service on Linux

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/setting-up-the-database.md

Initializes the PostgreSQL database cluster, enables it to run as a service, and starts the service. This command is essential for getting the PostgreSQL server operational on Linux.

```shell
postgresql-setup initdb
systemctl enable postgresql.service
systemctl start postgresql.service
```

--------------------------------

### Run NPM Scripts: Formatting, Testing, Building, and Serving

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

These commands are used for project maintenance and execution. They cover code formatting checks, running unit tests (including watch mode and coverage), building the production bundle, starting the production server, and analyzing bundle sizes.

```bash
# Check formatting
npm run format:check

# Run all tests
npm test

# Run tests in watch mode
npm run test:watch

# Run tests with coverage
npm run coverage

# Run specific test file
npm test -- JobsTable.test.tsx

# Build production bundle
npm run build

# Start production server
npm run start

# Analyze bundle size
npm run build -- --analyze
```

--------------------------------

### Create Command File for cuecmd

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Creates a text file where each line represents a shell command to be executed on the OpenCue render farm. This allows for easy batch job submission.

```bash
cat > my_commands.txt << 'EOF'
echo "Processing item 1"
echo "Processing item 2"
echo "Processing item 3"
echo "Processing item 4"
echo "Processing item 5"
EOF
```

--------------------------------

### REST API Setup and Authentication

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/rest-api-tutorial.md

Guide on setting up environment variables, generating JWT tokens, and testing the REST Gateway connection.

```APIDOC
## Environment Setup

Set the following environment variables:

```bash
export OPENCUE_REST_GATEWAY_URL="http://localhost:8448"
export JWT_SECRET="your-secret-key"
```

### Generate JWT Token

Use a Python script to generate a JWT token for authentication:

```python
# generate_token.py
import jwt
import datetime
import os

secret = os.getenv('JWT_SECRET', 'your-secret-key')
payload = {
    "user": "api-tutorial",
    "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=24)
}

token = jwt.encode(payload, secret, algorithm="HS256")
print(f"export JWT_TOKEN='{token}'")
```

Run the script and export the token:

```bash
python3 generate_token.py
# Copy and paste the export command from output
```

### Test Connection

Verify the REST Gateway is running:

```bash
response=$(curl -s -o /dev/null -w "%{{http_code}}" "$OPENCUE_REST_GATEWAY_URL/")
if [ "$response" = "401" ]; then
    echo "✓ Gateway is running and requiring authentication (as expected)"
else
    echo "✗ Gateway may not be running (got HTTP $response)"
fi
```

**Note:** All endpoints require JWT authentication.
```

--------------------------------

### Troubleshooting cuecmd: Command File Not Found

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Provides a solution for the 'Command file not found' error in cuecmd by suggesting the use of absolute paths, including the current working directory.

```bash
# Use absolute path
cuecmd $(pwd)/my_commands.txt
```

--------------------------------

### Start CueWeb Development Server

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cueweb.md

Starts the CueWeb application in development mode using Next.js. This command compiles the application and makes it accessible at http://localhost:3000.

```bash
npm run dev

```

--------------------------------

### Run RQD Executable (Post-PyPI Install) - Shell

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/deploying-rqd.md

Executes the RQD service after it has been installed via pip. This command starts the RQD daemon, which will automatically pick up the CUEBOT_HOSTNAME environment variable that was previously set.

```shell
rqd
```

--------------------------------

### cuenimby Command-Line Options and Examples

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/user-guides/cuenimby-user-guide.md

Demonstrates various command-line arguments for cuenimby, including connecting to a specific Cuebot, monitoring different hosts, disabling notifications, enabling debug mode, and using custom configuration files.

```bash
cuenimby --cuebot-host cuebot.prod.example.com --cuebot-port 8443
cuenimby --hostname workstation-02
cuenimby --no-notifications
cuenimby --verbose
cuenimby --config /path/to/custom/config.json
```

--------------------------------

### Submit Commands to OpenCue using cuecmd

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Submits a command file to the OpenCue render farm using cuecmd. The output shows the number of commands, frame range, and job submission status.

```bash
cuecmd my_commands.txt
```

--------------------------------

### Check Python Version

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuenimby.md

Verifies the installed Python version on the system. CueNIMBY requires Python 3.7 or greater.

```bash
python --version
```

```bash
python3 --version
```

--------------------------------

### Start CueNIMBY with a custom configuration file

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/reference/tools/cuenimby.md

Launches CueNIMBY and directs it to use a specific JSON configuration file, allowing for customized settings and environment-specific setups.

```bash
cuenimby --config /etc/opencue/cuenimby-prod.json
```

--------------------------------

### Submit a HelloWorld Job using Command Line

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-mac.md

This example shows how to submit a simple 'HelloWorld' job to OpenCue using a bash script. It defines job parameters like name, user, shot, layer, command, and frame specification. The command to run includes replacement tokens for frame, layer, and job details, which are then processed by OpenCue.

```bash
echo "Output from frame: #IFRAME#; layer: #LAYER#; job: #JOB#"
```

--------------------------------

### cuecmd Advanced Features: Chunking and Resources

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Demonstrates advanced cuecmd features including grouping multiple commands per frame using `--chunk` and specifying resource requirements like CPU cores (`--cores`) and memory (`--memory`).

```bash
# 5 commands per frame (5 commands = 1 frame)
cuecmd my_commands.txt --chunk 5
```

```bash
# Request 4 cores and 8GB memory per frame
cuecmd my_commands.txt --cores 4 --memory 8
```

--------------------------------

### Install Cueman Command-Line Tool

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/cueman/cueman_tutorial.md

Installs the Cueman command-line interface using pip. It supports installation from PyPI or directly from source code after cloning the repository.

```bash
# Install from PyPI
pip install opencue-cueman

# Or install from source
cd OpenCue/cueman
pip install .
```

--------------------------------

### Install CueNIMBY

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/cuenimby-tutorial.md

Installs the CueNIMBY application from its source code within the OpenCue repository. This involves navigating to the correct directory and using pip for installation.

```bash
cd OpenCue/cuenimby
pip install .
```

--------------------------------

### Create and Activate Python Virtual Environment

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-linux.md

These commands create a Python virtual environment named 'sandbox-venv' and then activate it. This isolates project dependencies. Ensure Python 3.7 or later is installed.

```bash
python3 -m venv sandbox-venv
```

```bash
source sandbox-venv/bin/activate
```

--------------------------------

### Install CueGUI from Source

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/installing-cuegui.md

Installs the CueGUI package directly from the source code. This method requires you to have already checked out the OpenCue source code. It installs the package using pip, assuming your current directory is the root of the checked-out source.

```shell
pip install cuegui/
```

--------------------------------

### Monitor OpenCue Jobs

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Provides commands to monitor jobs submitted to OpenCue using cueadmin and cueman. This includes listing all jobs, getting job details, and listing frames within a job.

```bash
# List all jobs
cueadmin -lj
```

```bash
# Get job details with cueman
cueman -info <job_name>
```

```bash
# List frames
cueman -lf <job_name>
```

--------------------------------

### cuecmd Pretend Mode for Job Simulation

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuecmd.md

Utilizes cuecmd's `--pretend` mode to simulate job submission without actually launching it. This helps in verifying job settings like chunk size, cores, and memory.

```bash
cuecmd my_commands.txt --chunk 5 --pretend
```

--------------------------------

### Setting Up Production Infrastructure with cueadmin

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/cueadmin-tutorial.md

Workflow for setting up production infrastructure, including creating shows, configuring parameters, setting up allocations, moving hosts, creating subscriptions, enabling shows, and verifying the setup.

```bash
# 1. Create production show
cueadmin -create-show production_2025

# 2. Configure show parameters
cueadmin -default-min-cores production_2025 2
cueadmin -default-max-cores production_2025 200

# 3. Create dedicated allocation
cueadmin -create-alloc main prod2025 "production"

# 4. Move hosts to new allocation
cueadmin -hostmatch prod2025 -move main.prod2025

# 5. Create subscriptions
cueadmin -create-sub production_2025 main.prod2025 500 750
cueadmin -create-sub production_2025 main.render 200 400

# 6. Enable the show
cueadmin -enable-show production_2025

# 7. Verify setup
cueadmin -ls | grep production_2025
cueadmin -lb production_2025
cueadmin -lh -alloc main.prod2025 | tail -n +2 | wc -l
```

--------------------------------

### Install CueGUI from PyPI

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/installing-cuegui.md

Installs the latest published release of the opencue-cuegui package using pip. This method requires the pip and virtualenv tools to be installed and a virtual environment to be active. It's a straightforward way to get the stable release.

```shell
pip install opencue-cuegui
```

--------------------------------

### Dockerfile for OpenCue Web Application

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

A Dockerfile to build a production-ready image for the OpenCue web application. It uses a multi-stage build process, starting from a Node.js Alpine base image, installing production dependencies, building the Next.js application, and finally creating a lean production image with only necessary files.

```dockerfile
# cueweb/Dockerfile
FROM node:18-alpine AS base

# Install dependencies only when needed
FROM base AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --only=production

# Build the app
FROM base AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production image
FROM base AS runner
WORKDIR /app

ENV NODE_ENV=production
ENV NEXT_TELEMETRY_DISABLED=1

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT=3000
ENV HOSTNAME="0.0.0.0"

CMD ["node", "server.js"]

```

--------------------------------

### OpenCue Getting Help Scripts

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/cueadmin-tutorial.md

Bash commands to access built-in help and debugging information for OpenCue's 'cueadmin' tool. Includes examples for general help, checking specific command syntax, and enabling verbose mode. Dependencies: 'cueadmin'.

```bash
# Built-in help
cueadmin -h

# Check command syntax
cueadmin -h | grep -A2 "create-sub"

# Enable verbose for debugging
cueadmin -v -your-command
```

--------------------------------

### Check RQD Status using bash

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/getting-started-tutorial.md

This set of bash commands helps in verifying the status of RQD (render daemons) on the render nodes. `cueadmin -lh` lists available hosts, and `ps aux | grep rqd` checks if the RQD process is actively running on the system, essential for diagnosing job execution problems.

```bash
# List available hosts
cueadmin -lh
```

```bash
# Check if RQD is running
ps aux | grep rqd
```

--------------------------------

### Install and Use Delve Debugger in Go

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/rest-gateway-development.md

Instructions on how to install the Delve debugger for Go applications and start a debugging session. This includes setting breakpoints and continuing execution. Assumes Go is installed and configured.

```bash
go install github.com/go-delve/delve/cmd/dlv@latest

dlv debug main.go

# Set breakpoints and run
(dlv) break main.main
(dlv) continue
```

--------------------------------

### Installing Python Notification Libraries (Linux)

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/user-guides/cuenimby-user-guide.md

Provides commands for installing notification-related Python libraries on Linux using apt and pip.

```bash
sudo apt-get install gir1.2-appindicator3-0.1
pip install notify2
```

--------------------------------

### Installing Python Notification Libraries (macOS)

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/user-guides/cuenimby-user-guide.md

Provides commands for installing notification-related Python libraries on macOS using Homebrew and pip.

```bash
brew install terminal-notifier
pip install pync
```

--------------------------------

### Install CueSubmit from PyPI

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/installing-cuesubmit.md

Installs the CueSubmit Python package from the Python Package Index (PyPI). This command assumes a virtual environment is active and pip is available.

```shell
pip install opencue-cuesubmit
```

--------------------------------

### Install PostgreSQL on Linux (yum/apt)

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/setting-up-the-database.md

Installs the PostgreSQL server and contrib packages. This is the first step for Linux installations. It supports both yum and apt package managers.

```shell
yum install postgresql-server postgresql-contrib
```

```shell
apt install postgresql-contrib postgresql
```

--------------------------------

### Install PostgreSQL Client on macOS (Homebrew)

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/setting-up-the-database.md

Installs the PostgreSQL client utilities on macOS using the Homebrew package manager. This simplifies database administration on macOS. It requires Homebrew to be installed.

```shell
brew install postgresql
```

--------------------------------

### Install CueAdmin for Development

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/cueadmin/README.md

Installs CueAdmin from a cloned repository with development dependencies, suitable for contributors. This setup includes tools for testing and linting.

```bash
git clone https://github.com/AcademySoftwareFoundation/OpenCue.git
cd OpenCue/cueadmin
pip install -e ".[dev]"
```

--------------------------------

### Build and Run CueWeb Application with Docker

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/cueweb/README.md

Instructions for building a Docker image of the CueWeb application and running it as a container. Assumes Docker is installed and a Dockerfile is present in the project. The command maps port 3000 from the container to the host and runs the application in interactive mode. It also notes the importance of making frame log directories accessible within the container.

```bash
docker build -f Dockerfile -t cueweb .
docker run -p 3000:3000 -it cueweb
```

--------------------------------

### Run CueSubmit Standalone

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/installing-cuesubmit.md

Launches the CueSubmit GUI application. It requires the CUEBOT_HOSTS environment variable to be set, pointing to the Cuebot instance.

```shell
CUEBOT_HOSTS=$CUEBOT_HOSTNAME_OR_IP cuesubmit
```

--------------------------------

### Get Host Tags Response Example

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/reference/rest-api-reference.md

Example JSON response when retrieving host details, showcasing the 'tags' field which lists all currently applied tags on the host.

```json
{
  "host": {
    "id": "host-id-abc",
    "name": "render-node-01",
    "tags": ["gpu", "high-memory", "linux"],
    "lockState": "OPEN",
    "totalCores": 16,
    "totalMemory": 68719476736,
    "totalGpus": 2
  }
}
```

--------------------------------

### Launching CueGUI Commands

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/using-cuegui.md

Demonstrates various command-line options for launching the CueGUI application, including default launch, custom configuration, and debug logging.

```bash
# Launch CueGUI
cuegui

# Launch with specific configuration
cuegui --config /path/to/custom/cuegui.yaml

# Launch with debug logging
cuegui --debug
```

--------------------------------

### Get Layer Response Example

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/reference/rest-api-reference.md

Example JSON response when retrieving layer details, including its assigned tags. Shows layer ID, name, tags, type, and enabled status.

```json
{
  "layer": {
    "id": "layer-id-789",
    "name": "comp_layer",
    "tags": ["nuke", "comp", "high-priority"],
    "type": "Render",
    "isEnabled": true
  }
}
```

--------------------------------

### Run CueWeb Development Server with Options

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

Provides commands to run the CueWeb development server with additional options. This includes specifying a custom port for the server and enabling debug mode for more verbose logging.

```bash
# Start development server with hot reload
npm run dev

# Run with specific port
npm run dev -- -p 3001

# Run with debug mode
DEBUG=* npm run dev
```

--------------------------------

### Install cuecmd in Editable Mode

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cuecmd-development.md

Resolve 'ModuleNotFoundError: No module named 'cuecmd'' by installing the 'cuecmd' package in editable mode. This command makes the 'cuecmd' module available for import during testing.

```bash
pip install -e ./cuecmd
```

--------------------------------

### Launch OpenCue GUI

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-windows.md

Launches the OpenCue Graphical User Interface (CueGUI), allowing users to interact with the OpenCue system, view hosts, and submit jobs.

```bash
cuegui
```

--------------------------------

### Schedule Example: Night Shift Disablement

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/user-guides/cuenimby-user-guide.md

A JSON example illustrating how to configure a schedule to disable rendering during night hours (10 PM to 6 AM). This ensures the machine is unavailable during nighttime shifts.

```json
"monday": {
  "start": "22:00",
  "end": "06:00",
  "state": "disabled"
}
```

--------------------------------

### Troubleshoot CueWeb Startup Issues

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cueweb.md

Provides commands to troubleshoot common issues when starting CueWeb with 'npm run dev'. It includes checking the Node.js version and clearing the cache followed by a reinstallation of dependencies.

```bash
# Check Node.js version
node --version  # Should be 18+

# Clear cache and reinstall
rm -rf node_modules package-lock.json
npm install

```

--------------------------------

### Get All Hosts Response Example

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/reference/rest-api-reference.md

Example JSON response for the GetHosts API call, detailing multiple hosts with their properties like ID, name, OS, core counts, memory, and GPU availability.

```json
{
  "hosts": {
    "hosts": [
      {
        "id": "host-id-abc",
        "name": "render-node-01",
        "lockState": "OPEN",
        "bootTime": 1694000000,
        "pingTime": 1694001000,
        "os": "linux",
        "totalCores": 16,
        "idleCores": 12,
        "totalMemory": 68719476736,
        "freeMemory": 34359738368,
        "totalGpus": 2,
        "freeGpus": 2,
        "hostStats": {
          "totalFrames": 4,
          "runningFrames": 4
        }
      }
    ]
  }
}
```

--------------------------------

### Connect to Cuebot with Environment Variables

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-cuenimby.md

Sets environment variables for CUEBOT_HOST and CUEBOT_PORT before running CueNIMBY. This method configures the connection details for the application.

```bash
export CUEBOT_HOST=cuebot.example.com
export CUEBOT_PORT=8443
cuenimby
```

--------------------------------

### Component Development: JobCard

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

Example of creating a reusable JobCard component, including its structure and testing.

```APIDOC
## Component: JobCard

### Description
A React component that displays information about a single job and provides actions like pause and kill.

### Props
- **job** (Job) - Required - The job object containing details like id, name, status, and isPaused.
- **onPause** (function) - Required - Callback function to be called when the pause/resume button is clicked. Receives the job ID.
- **onKill** (function) - Required - Callback function to be called when the kill button is clicked. Receives the job ID.
- **className** (string, optional) - Additional CSS class names to apply to the component.

### Example Usage
```typescript
import { JobCard } from '@/components/JobCard';

// Assuming 'job' is an object conforming to the Job interface
<JobCard 
  job={job} 
  onPause={(jobId) => console.log(`Pausing job: ${jobId}`)} 
  onKill={(jobId) => console.log(`Killing job: ${jobId}`)} 
/>
```

### Testing JobCard
- Tests verify that the component renders correctly and that the `onPause` and `onKill` callbacks are invoked with the correct job ID when the respective buttons are clicked.
```

--------------------------------

### Check OpenCue Sandbox Connection

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-linux.md

Verifies the connection to the OpenCue sandbox by listing host information. Requires the `cueadmin` command-line tool. The expected output shows host details, load, memory, and OS information.

```bash
cueadmin -lh
```

--------------------------------

### Create RQD Mount Directories

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-linux.md

These commands create necessary directories for RQD (render host daemon) to store logs and job output. Ensure you have the necessary permissions to create directories in /tmp.

```bash
mkdir -p /tmp/rqd/logs /tmp/rqd/shots
```

--------------------------------

### YAML: CueGUI Configuration Settings

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/using-cuegui.md

This YAML snippet shows example configuration settings for the CueGUI application, typically found in `~/.config/opencue/cuegui.yaml`. It includes parameters for update intervals, display limits, sound notifications, and column widths.

```yaml
# ~/.config/opencue/cuegui.yaml
cuegui:
  update_interval: 10  # Seconds between refreshes
  max_jobs_display: 500  # Limit jobs shown
  enable_sound: false  # Disable notification sounds
  
  # Column widths
  columns:
    job_name: 200
    state: 80
    progress: 120
```

--------------------------------

### Setup Python Virtual Environment for RQD - Shell

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/deploying-rqd.md

Configures a Python virtual environment named 'venv' and activates it. This isolates project dependencies, preventing conflicts with globally installed Python packages. It then installs RQD within this environment.

```shell
virtualenv venv
source venv/bin/activate
pip install rqd/
```

--------------------------------

### Populate OpenCue Database with Seed Data from Source using psql

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/setting-up-the-database.md

Inserts sample data into the OpenCue database using the psql command-line tool, sourcing the seed data from a file within the OpenCue repository. This command requires the database host, database name, and the path to the seed_data.sql file.

```shell
psql -h $DB_HOST -f cuebot/src/main/resources/conf/ddl/postgres/seed_data.sql $DB_NAME
```

--------------------------------

### Install Pycue and Pyoutline Dependencies

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cuecmd-development.md

Resolve 'Pylint fails with unknown module' errors, specifically 'E0401: Unable to import 'outline'', by installing the 'pycue' and 'pyoutline' packages. This ensures that all necessary modules are available for static analysis tools like Pylint.

```bash
pip install ./pycue ./pyoutline
```

--------------------------------

### Install OpenCue Pip Packages

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/news/2025-08-10-opencue-project-review-2025.md

This command installs all official OpenCue Python packages, simplifying the setup for developers and users. It includes packages for proto definitions, the core pycue library, pyoutline, the RQD agent, admin tools, and submission utilities.

```bash
pip install opencue-proto opencue-pycue opencue-pyoutline opencue-rqd opencue-cueadmin opencue-cueman opencue-cuesubmit opencue-cuegui
```

--------------------------------

### Populate OpenCue Database with Seed Data using psql

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/getting-started/setting-up-the-database.md

Inserts sample data into the OpenCue database using the psql command-line tool. This command requires the database host, database name, and the path to the seed_data SQL file. This helps demonstrate various features of the software.

```shell
psql -h $DB_HOST -f <path to seed_data SQL file> $DB_NAME
```

--------------------------------

### Example: Testing Job Configuration with cuecmd

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/cuecmd/README.md

This example shows how to use the `--pretend` flag with cuecmd to test job configuration, resource allocation, and command structure without actually submitting the job to the render farm. It provides a dry run of the job setup.

```bash
# Test the job configuration without submitting
cuecmd commands.txt --chunk 5 --cores 2 --memory 4 --pretend

# Output shows:
# - Job name
# - Frame range
# - Resource requirements
# - Command file location
```

--------------------------------

### Clone OpenCue Repository and Navigate

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/quick-starts/quick-start-windows.md

Clones the OpenCue repository from GitHub and changes the current directory to the cloned repository. This is essential for accessing OpenCue's configuration files.

```bash
git clone https://github.com/AcademySoftwareFoundation/OpenCue.git
cd OpenCue
```

--------------------------------

### Dockerfile: Base RQD Image and Blender Installation

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/other-guides/customizing-rqd.md

A foundational Dockerfile that first pulls the latest `opencue/rqd` base image from Docker Hub. It then proceeds to install Blender, including its dependencies and environment setup, making it ready for rendering jobs within the OpenCue ecosystem.

```Dockerfile
# Builds on the latest base image of RQD from Docker Hub
FROM opencue/rqd

# Install dependencies to run Blender on the opencue/rqd image
RUN yum -y update
RUN yum -y install \
        bzip2 \
        libfreetype6 \
        libgl1-mesa-dev \
        libXi-devel  \
        mesa-libGLU-devel \
        zlib-devel \
        libXinerama-devel \
        libXrandr-devel

# Set Blender install directory
ARG BLENDER_INSTALL_DIR=/usr/local/blender

# Set Blender download source
ARG BLENDER_DOWNLOAD_SRC=https://download.blender.org/release/Blender3.3/blender-3.3.3-linux-x64.tar.xz

# Download and install Blender
RUN mkdir ${BLENDER_INSTALL_DIR}
RUN curl -SL ${BLENDER_DOWNLOAD_SRC} \
        -o blender.tar.xz

RUN tar -xvf blender.tar.xz \
        -C ${BLENDER_INSTALL_DIR} \
        --strip-components=1

RUN rm blender.tar.xz

# Verify Blender installation
RUN ${BLENDER_INSTALL_DIR}/blender --version
```

--------------------------------

### Create and Configure a New Show with CueAdmin

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/tutorials/cueadmin-tutorial.md

Guides through the process of creating a new show and setting its core limits using CueAdmin. This involves creating the show, then setting default minimum and maximum cores.

```bash
# Step 1: Create the show
cueadmin -create-show tutorial_show
# Confirm: Create new show tutorial_show? [y/n] y

# Step 2: Configure core limits
cueadmin -default-min-cores tutorial_show 1
cueadmin -default-max-cores tutorial_show 50

# Step 3: Verify the show was created
cueadmin -ls | grep tutorial_show
```

--------------------------------

### Verify Cueman Installation and Basic Usage

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/cueman/README.md

Checks if Cueman is installed correctly by displaying its help message. It also demonstrates how to list all jobs using 'cueadmin' and then retrieve information and list frames for a specific job using 'cueman'. These commands are fundamental for starting with job management.

```bash
# Verify Installation
cueman -h

# List all jobs to get job names
cueadmin -lj

# Get job information
cueman -info your_job_name

# List frames for a job
cueman -lf your_job_name

# List only running frames for a job
cueman -lf your_job_name -state RUNNING
```

--------------------------------

### OpenCue REST Gateway API Client Setup

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/developer-guide/cueweb-development.md

This section details how to set up the API client for interacting with the OpenCue REST Gateway, including JWT authentication.

```APIDOC
## POST /show.ShowInterface/GetShows

### Description
Fetches a list of shows from the OpenCue system.

### Method
POST

### Endpoint
/show.ShowInterface/GetShows

### Parameters
#### Request Body
- **(object)** - Required - Empty object for this request.

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **(array)** - An array of show objects.

#### Response Example
```json
{
  "shows": [
    {
      "id": "show1",
      "name": "Example Show"
    }
  ]
}
```
```

--------------------------------

### Clone OpenCue Repository

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/sandbox/README.md

Clones the OpenCue source code repository from GitHub. This is a prerequisite for setting up the local sandbox environment. Ensure you have Git installed.

```bash
git clone https://github.com/AcademySoftwareFoundation/OpenCue.git
```

```bash
git clone https://github.com/<username>/OpenCue.git
```

--------------------------------

### OpenCue Development Setup

Source: https://github.com/academysoftwarefoundation/opencue/blob/master/docs/_docs/reference/tools/cueman.md

Commands for setting up the development environment for OpenCue, including installing development dependencies, running tests with linting, and formatting code.

```bash
# Install development dependencies
pip install -e ".[dev]"

# Run tests with linting
pytest && pylint cueman tests

# Format code
black cueman tests && isort cueman tests
```