opencue-cuecmd 1.13.6__py3-none-any.whl

cuecmd/__init__.py

@@ -0,0 +1,33 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+"""OpenCue Cuecmd command execution tool."""
+
+try:
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        __version__ = version("opencue_cuecmd")
+    except PackageNotFoundError:
+        # Package is not installed
+        __version__ = "1.0.0"
+except ImportError:
+    # Python < 3.8
+    try:
+        import pkg_resources
+
+        __version__ = pkg_resources.get_distribution("opencue_cuecmd").version
+    except Exception:
+        __version__ = "1.0.0"

cuecmd/__main__.py

@@ -0,0 +1,41 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+"""Entrypoint for Cuecmd tool."""
+
+
+from __future__ import absolute_import, division, print_function
+
+import logging
+import sys
+import warnings
+
+from cuecmd import main as opencuecmd
+
+# Suppress protobuf version warnings
+warnings.filterwarnings(
+    "ignore", category=UserWarning, module="google.protobuf.runtime_version"
+)
+
+logger = logging.getLogger("opencue.tools.cuecmd")
+
+
+def main():
+    """Main entry point for cuecmd."""
+    opencuecmd.main(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

cuecmd/execute_commands.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Helper script to execute commands from a file based on frame number and chunk size."""
+
+import argparse
+import subprocess
+import sys
+
+
+def main():
+    """Execute commands from a file based on frame number and chunk size."""
+    parser = argparse.ArgumentParser(
+        description="Execute commands from a file based on frame number and chunk size."
+    )
+    parser.add_argument("command_file", help="Path to the file containing commands")
+    parser.add_argument(
+        "chunk_size", type=int, help="Number of commands to execute per frame"
+    )
+    parser.add_argument(
+        "--frame", type=int, required=True, help="Frame number to execute"
+    )
+
+    args = parser.parse_args()
+
+    # Read all commands from the file
+    with open(args.command_file, "r", encoding="utf-8") as f:
+        commands = [line.strip() for line in f if line.strip()]
+
+    # Calculate which commands to run for this frame
+    start_idx = (args.frame - 1) * args.chunk_size
+    end_idx = min(start_idx + args.chunk_size, len(commands))
+
+    if start_idx >= len(commands):
+        print(f"Frame {args.frame} is beyond the available commands")
+        return 0
+
+    # Execute each command in the chunk
+    for idx in range(start_idx, end_idx):
+        cmd = commands[idx]
+        print(f"Executing command {idx + 1}: {cmd}")
+
+        # Execute the command
+        result = subprocess.run(cmd, shell=True, check=False)
+
+        if result.returncode != 0:
+            print(f"Command failed with return code {result.returncode}: {cmd}")
+            sys.exit(result.returncode)
+
+    return 0
+
+
+if __name__ == "__main__":
+    main()

cuecmd/main.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Cuecmd - Execute a list of commands on the OpenCue render farm.
+
+This tool reads a file containing a list of commands and submits them as
+frames to be executed on the render farm. Commands can be chunked together
+to run multiple commands per frame.
+"""
+
+import argparse
+import math
+import os
+import shutil
+import sys
+import tempfile
+import traceback
+from pathlib import Path
+
+import outline
+from outline.modules.shell import Shell
+
+
+def parse_arguments(argv):
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Execute a list of commands on the OpenCue render farm.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s commands.txt
+  %(prog)s commands.txt --chunk 5 --cores 2 --memory 4
+  %(prog)s commands.txt --pause --pretend
+        """,
+    )
+
+    parser.add_argument(
+        "command_file", help="A file with a list of commands to run (one per line)"
+    )
+
+    parser.add_argument(
+        "-c",
+        "--chunk",
+        type=int,
+        default=1,
+        help="Number of commands to chunk per frame (Default: 1)",
+    )
+
+    parser.add_argument(
+        "--cores",
+        type=float,
+        default=1.0,
+        help="Number of cores required per frame (Default: 1.0)",
+    )
+
+    parser.add_argument(
+        "--memory",
+        type=float,
+        default=1.0,
+        help="Amount of RAM in GB required per frame (Default: 1.0)",
+    )
+
+    parser.add_argument(
+        "-p", "--pause", action="store_true", help="Launch the job in the paused state"
+    )
+
+    parser.add_argument(
+        "--pretend",
+        action="store_true",
+        help="Generate the outline and print the launch info without submitting",
+    )
+
+    parser.add_argument(
+        "-s",
+        "--shot",
+        default=os.environ.get("SHOT", "default"),
+        help='Shot name for the job (Default: from $SHOT or "default")',
+    )
+
+    parser.add_argument(
+        "--show",
+        default=os.environ.get("SHOW", "default"),
+        help='Show name for the job (Default: from $SHOW or "default")',
+    )
+
+    parser.add_argument(
+        "--user",
+        default=os.environ.get("USER", "unknown"),
+        help='User name for the job (Default: from $USER or "unknown")',
+    )
+
+    parser.add_argument(
+        "--job-name", help="Custom job name (Default: auto-generated from file name)"
+    )
+
+    return parser.parse_args(argv[1:])
+
+
+def count_commands(command_file):
+    """Count the number of non-empty commands in the file."""
+    count = 0
+    with open(command_file, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip():
+                count += 1
+    return count
+
+
+def get_frame_range(command_count, chunk_size):
+    """Calculate the frame range based on command count and chunk size."""
+    num_frames = math.ceil(command_count / chunk_size)
+    return f"1-{num_frames}"
+
+
+def copy_to_temp(command_file):
+    """Copy the command file to a temporary location that will be accessible during execution."""
+    # Create a temporary directory
+    temp_dir = tempfile.mkdtemp(prefix="cuecmd_")
+    basename = Path(command_file).stem
+    temp_file = os.path.join(temp_dir, f"{basename}.cmds")
+    shutil.copyfile(command_file, temp_file)
+    return temp_file
+
+
+def create_outline(args, command_file, frame_range):
+    """Create an outline for executing the commands."""
+    # Get the path to the execute_commands.py script
+    execute_script = os.path.join(os.path.dirname(__file__), "execute_commands.py")
+
+    # Create the job name
+    if args.job_name:
+        job_name = args.job_name
+    else:
+        basename = Path(args.command_file).stem
+        job_name = f"{args.show}_{args.shot}_{args.user}_{basename}"
+
+    # Create the outline
+    ol = outline.Outline(job_name, shot=args.shot, show=args.show, user=args.user)
+
+    # Create the shell command that will execute the commands
+    # Use python3 explicitly
+    cmd = f"python3 {execute_script} {command_file} {args.chunk} --frame #IFRAME#"
+
+    # Create the layer
+    layer = Shell(
+        "cuecmd",
+        command=cmd,
+        chunk=1,
+        threads=args.cores,
+        threadable=1,
+        range=frame_range,
+        memory=f"{int(args.memory * 1024)}MB",
+    )
+
+    ol.add_layer(layer)
+    return ol
+
+
+def main(argv=None):
+    """Main entry point for cuecmd."""
+    if argv is None:
+        argv = sys.argv
+
+    args = parse_arguments(argv)
+
+    # Validate the command file exists
+    if not os.path.isfile(args.command_file):
+        print(f"Error: Command file not found: {args.command_file}", file=sys.stderr)
+        sys.exit(1)
+
+    # Get absolute path to the command file
+    command_file = os.path.abspath(args.command_file)
+
+    # Count commands and calculate range
+    command_count = count_commands(command_file)
+    if command_count == 0:
+        print("Error: No commands found in the command file", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Found {command_count} commands in {command_file}")
+
+    frame_range = get_frame_range(command_count, args.chunk)
+    print(f"Frame range with chunking of {args.chunk}: {frame_range}")
+
+    # Copy command file to a temporary location
+    temp_command_file = copy_to_temp(command_file)
+    print(f"Copied commands to: {temp_command_file}")
+
+    # Create the outline
+    ol = create_outline(args, temp_command_file, frame_range)
+
+    if args.pretend:
+        print("\n=== Pretend Mode ===")
+        print(f"Job name: {ol.get_name()}")
+        print(f"Shot: {ol.get_shot()}")
+        print(f"Show: {ol.get_show()}")
+        print(f"User: {ol.get_user()}")
+        print(f"Frame range: {frame_range}")
+        print(f"Chunk size: {args.chunk}")
+        print(f"Cores per frame: {args.cores}")
+        print(f"Memory per frame: {args.memory}GB")
+        print(f"Command file: {temp_command_file}")
+        print("\nWould launch the job with the above settings.")
+        return 0
+
+    # Launch the job
+    try:
+        jobs = outline.cuerun.launch(ol, pause=args.pause, use_pycuerun=True)
+        if jobs:
+            print(f"\nSuccessfully launched job: {ol.get_name()}")
+            if args.pause:
+                print("Job is paused. Use cueadmin to unpause it.")
+        else:
+            print("Failed to launch job", file=sys.stderr)
+            sys.exit(1)
+    except Exception as e:
+        print(f"Error launching job: {e}", file=sys.stderr)
+        traceback.print_exc()
+        sys.exit(1)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

opencue_cuecmd-1.13.6.dist-info/METADATA

@@ -0,0 +1,403 @@
+Metadata-Version: 2.1
+Name: opencue_cuecmd
+Version: 1.13.6
+Summary: Cuecmd is a command-line tool for OpenCue that executes a list of commands as frames on the render farm. It enables batch processing by chunking commands and submitting them as OpenCue jobs.
+Requires-Python: >3.7
+Requires-Dist: opencue-pycue
+Requires-Dist: opencue-pyoutline
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mock==2.0.0; extra == 'dev'
+Requires-Dist: pyfakefs==5.2.3; extra == 'dev'
+Requires-Dist: pylint; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: mock==2.0.0; extra == 'test'
+Requires-Dist: pyfakefs==5.2.3; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Description-Content-Type: text/markdown
+
+# OpenCue Cuecmd
+
+Cuecmd is a command-line tool for OpenCue that executes a list of commands as frames on the render farm. It enables batch processing by chunking commands and submitting them as OpenCue jobs.
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Features](#features)
+3. [Installation](#installation)
+4. [Quick Start](#quick-start)
+5. [Usage](#usage)
+6. [Options](#options)
+7. [Examples](#examples)
+8. [Environment Variables](#environment-variables)
+9. [How It Works](#how-it-works)
+10. [Running Tests](#running-tests)
+11. [Docker Support](#docker-support)
+12. [Contributing](#contributing)
+
+## Overview
+
+`cuecmd` is a tool for executing arbitrary shell commands on the OpenCue render farm. It takes a text file containing a list of commands (one per line) and distributes them across multiple frames for parallel execution.
+
+### About Cuecmd
+
+The name "cuecmd" combines:
+- **"Cue"** - From OpenCue, the render farm management system
+- **"cmd"** - Short for command, representing its purpose of executing commands
+
+The `cuecmd` provides a simple way to parallelize any batch of shell commands using the OpenCue infrastructure.
+
+## Features
+
+- **Command batching**: Execute any list of shell commands on the render farm
+- **Chunking**: Group multiple commands per frame for efficient resource usage
+- **Resource control**: Specify cores and memory requirements per frame
+- **Job management**: Launch jobs paused or test with pretend mode
+- **Flexible configuration**: Override show, shot, and user from command line
+- **Simple input format**: Plain text file with one command per line
+
+## Installation
+
+### Prerequisites
+- OpenCue server running and accessible
+- Python 3.7 or higher
+- OpenCue Python packages installed
+
+### Install Methods
+
+Install as part of the OpenCue Python packages:
+
+```bash
+pip install opencue-cuecmd
+```
+
+Or install from source:
+
+```bash
+cd OpenCue/cuecmd
+pip install .
+```
+
+### Configuration
+Set up your environment variables:
+```bash
+export OPENCUE_HOSTS="your-cuebot-server:8443"
+export OPENCUE_FACILITY="your-facility-code"
+```
+
+## Quick Start
+
+1. **Create a command file:**
+   ```bash
+   cat > commands.txt << EOF
+   echo "Processing file 1"
+   echo "Processing file 2"
+   echo "Processing file 3"
+   EOF
+   ```
+
+2. **Submit to OpenCue:**
+   ```bash
+   cuecmd commands.txt
+   ```
+
+3. **Monitor the job:**
+   ```bash
+   cueadmin -lj  # List jobs
+   cueman -lf <job_name>  # List frames
+   ```
+
+## Usage
+
+```bash
+cuecmd [options] <command_file>
+```
+
+### Basic Usage
+
+```bash
+# Submit a simple command list
+cuecmd commands.txt
+
+# Chunk 5 commands per frame
+cuecmd commands.txt --chunk 5
+
+# Specify resources
+cuecmd commands.txt --cores 4 --memory 8
+
+# Launch paused for review
+cuecmd commands.txt --pause
+
+# Test without submitting
+cuecmd commands.txt --pretend
+```
+
+## Options
+
+### Required Arguments
+- `command_file` - A text file with a list of commands to run (one per line)
+
+### Optional Arguments
+
+#### Execution Options
+- `-c, --chunk <N>` - Number of commands to chunk per frame (Default: 1)
+- `--cores <N>` - Number of cores required per frame (Default: 1.0)
+- `--memory <N>` - Amount of RAM in GB required per frame (Default: 1.0)
+
+#### Job Control
+- `-p, --pause` - Launch the job in the paused state
+- `--pretend` - Generate the outline and print info without submitting
+
+#### Job Metadata
+- `--show <name>` - Show name for the job (Default: from $SHOW or "default")
+- `-s, --shot <name>` - Shot name for the job (Default: from $SHOT or "default")
+- `--user <name>` - User name for the job (Default: from $USER or "unknown")
+- `--job-name <name>` - Custom job name (Default: auto-generated)
+
+## Examples
+
+### Example 1: Simple Command Execution
+```bash
+# Create command file
+cat > render_frames.txt << EOF
+blender -b scene.blend -o /tmp/frame_#### -f 1
+blender -b scene.blend -o /tmp/frame_#### -f 2
+blender -b scene.blend -o /tmp/frame_#### -f 3
+EOF
+
+# Submit to OpenCue
+cuecmd render_frames.txt
+```
+
+### Example 2: Chunked Execution
+```bash
+# Process 1000 images, 10 per frame
+for i in {1..1000}; do
+  echo "convert input_$i.jpg -resize 50% output_$i.jpg"
+done > convert_images.txt
+
+cuecmd convert_images.txt --chunk 10
+# This creates 100 frames, each processing 10 images
+```
+
+### Example 3: Resource-Intensive Jobs
+```bash
+# Heavy computation requiring more resources
+cat > simulations.txt << EOF
+python simulate.py --scene 1
+python simulate.py --scene 2
+python simulate.py --scene 3
+EOF
+
+cuecmd simulations.txt --cores 8 --memory 32
+```
+
+### Example 4: Testing Before Launch
+```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
+```
+
+### Example 5: Custom Job Configuration
+```bash
+cuecmd commands.txt \
+  --show "my_project" \
+  --shot "sequence_010" \
+  --user "artist" \
+  --job-name "batch_processing" \
+  --chunk 10 \
+  --cores 4 \
+  --memory 8 \
+  --pause
+```
+
+### Example 6: Data Processing Pipeline
+```bash
+# Generate processing commands
+cat > data_pipeline.txt << EOF
+python extract.py data1.csv
+python extract.py data2.csv
+python extract.py data3.csv
+python transform.py data1.json
+python transform.py data2.json
+python transform.py data3.json
+EOF
+
+cuecmd data_pipeline.txt --chunk 2 --cores 2 --memory 4
+```
+
+## Environment Variables
+
+Cuecmd respects the following environment variables:
+
+- `OPENCUE_HOSTS` - Comma-separated list of OpenCue servers
+- `OPENCUE_FACILITY` - Default facility code
+- `SHOW` - Default show name
+- `SHOT` - Default shot name
+- `USER` - Default user name
+
+These can be overridden using command-line arguments.
+
+## How It Works
+
+1. **Command File Reading**: Cuecmd reads your text file containing commands
+2. **Chunking**: Commands are divided into chunks based on the `--chunk` parameter
+3. **Frame Range Calculation**: A frame range is calculated (1 to ceil(commands/chunk))
+4. **Outline Creation**: An OpenCue outline is created with a Shell layer
+5. **Job Submission**: The job is submitted to OpenCue for execution
+6. **Frame Execution**: Each frame executes its assigned chunk of commands
+
+### Technical Details
+
+- Commands are copied to a temporary location for access during execution
+- Each frame executes a helper script (`execute_commands.py`) that:
+  - Reads the command file
+  - Calculates which commands to run based on frame number and chunk size
+  - Executes each command in sequence
+  - Reports success/failure
+
+## Running Tests
+
+The `cuecmd` includes a comprehensive test suite.
+
+### Quick Start
+
+```bash
+# Install with test dependencies
+pip install -e ".[test]"
+
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=cuecmd --cov-report=term-missing
+```
+
+### Test Types
+
+- **Unit tests** - Test individual functions (`tests/test_main.py`, `tests/test_execute_commands.py`)
+- **Integration tests** - Test complete workflows (`tests/integration_tests.py`, `tests/test_integration_workflows.py`)
+
+### Running Tests
+
+```bash
+# Basic test run
+pytest tests/
+
+# Verbose output
+pytest -v
+
+# Run specific test file
+pytest tests/test_main.py
+
+# Run with coverage and HTML report
+pytest --cov=cuecmd --cov-report=html --cov-report=term-missing
+```
+
+### CI/CD Integration
+
+Cuecmd is integrated into OpenCue's CI/CD pipeline:
+
+```bash
+# In OpenCue root directory
+./ci/run_python_tests.sh     # Includes cuecmd tests
+./ci/run_python_lint.sh      # Includes cuecmd linting
+```
+
+## Docker Support
+
+### Building the Docker Image
+
+From the OpenCue root directory:
+```bash
+docker build -f cuecmd/Dockerfile -t cuecmd .
+```
+
+### Running the Docker Container
+
+**Show help:**
+```bash
+docker run --rm cuecmd cuecmd --help
+```
+
+**Test with commands:**
+```bash
+# Create test commands
+echo "echo 'test 1'" > /tmp/commands.txt
+echo "echo 'test 2'" >> /tmp/commands.txt
+
+# Run in pretend mode
+docker run --rm -v /tmp:/data cuecmd cuecmd /data/commands.txt --pretend
+```
+
+## Contributing
+
+### Development Setup
+
+```bash
+# Clone and setup
+git clone https://github.com/<username>/OpenCue.git
+cd OpenCue/cuecmd
+
+# Install with development dependencies
+pip install -e ".[dev]"
+```
+
+### Testing and Quality
+
+```bash
+# Run tests
+pytest --cov=cuecmd --cov-report=term-missing
+
+# Code formatting and linting
+black cuecmd tests
+isort cuecmd tests
+pylint cuecmd tests
+```
+
+### Guidelines
+
+- Add tests for new features
+- Update documentation for API changes
+- Ensure all tests pass before submitting PRs
+
+## Troubleshooting
+
+### Common Issues
+
+**Command file not found:**
+```bash
+# Make sure file exists and path is correct
+ls -l commands.txt
+cuecmd $(pwd)/commands.txt  # Use absolute path
+```
+
+**No commands found:**
+```bash
+# Check file has content and is not all blank lines
+cat commands.txt
+```
+
+**Job fails to launch:**
+```bash
+# Check OpenCue connection
+echo $OPENCUE_HOSTS
+cueadmin -lj  # Test connection
+```
+
+**Commands fail during execution:**
+- Check command syntax is correct
+- Verify commands have access to required files/paths
+- Ensure sufficient resources (cores/memory) are allocated

opencue_cuecmd-1.13.6.dist-info/RECORD

@@ -0,0 +1,8 @@
+cuecmd/__init__.py,sha256=Am7VgCcHrbnaZcPLWkkrjEUq3yPCCHhReTf0vCtGPns,1085
+cuecmd/__main__.py,sha256=8Xqzz6hfotBFgEROLZKCmkmV43zoPiUkAuiBrOuu1eQ,1104
+cuecmd/execute_commands.py,sha256=1PCNeSY13nnCbdb1IBN0z2SpPTjLExBMyOKhWqCXDA0,2243
+cuecmd/main.py,sha256=Hs37g4YgKHgHq8ISP_p9ZA7goPQbHpCP4v6SNNV0DPY,7148
+opencue_cuecmd-1.13.6.dist-info/METADATA,sha256=CbdDjU82UgVzVTuj9I1lAczTWeICE1Fjih4ONKjyTmU,10006
+opencue_cuecmd-1.13.6.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+opencue_cuecmd-1.13.6.dist-info/entry_points.txt,sha256=-iHfU6EuZIXryO6cp0IqDWbBul8PJkB_Ohzg58CAjOw,48
+opencue_cuecmd-1.13.6.dist-info/RECORD,,

opencue_cuecmd-1.13.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.17.1
+Root-Is-Purelib: true
+Tag: py3-none-any

opencue_cuecmd-1.13.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cuecmd = cuecmd.__main__:main