I'll start by reading the knowledge graph and page manifest, then explore the class-generator source code in detail.

Now let me check the entry point configuration and any additional schema-related functions:

Now let me check the test files for CLI tests and the entry point:

Now let me check the parsers and any additional CLI-relevant components:

Now I have all the information I need. Let me compile the comprehensive CLI reference page.

class-generator CLI Reference

The class-generator command generates Python wrapper classes for Kubernetes and OpenShift resources. It is installed as a console script entry point from the openshift-python-wrapper package.

class-generator = "class_generator.cli:main"

pip install openshift-python-wrapper
# or
uv tool install openshift-python-wrapper

Tip: Enable shell completion by adding to ~/.bashrc or ~/.zshrc: bash if type class-generator > /dev/null; then eval "$(_CLASS_GENERATOR_COMPLETE=zsh_source class-generator)"; fi

Synopsis

class-generator [OPTIONS]

At least one action option must be specified: --kind, --update-schema, --update-schema-for, --discover-missing, --coverage-report, --generate-missing, or --regenerate-all.

Options Reference

Kind Generation

-k, --kind

Generate Python wrapper classes for the specified Kubernetes resource Kind(s). Multiple kinds can be comma-separated (no spaces).

When a kind is not found in the local schema mapping file, the CLI interactively prompts to run --update-schema (only in interactive CLI mode).

# Single kind
class-generator -k Pod

# Multiple kinds (processed in parallel)
class-generator -k Deployment,Pod,ConfigMap

When multiple kinds share the same Kind name but belong to different API groups (e.g., DNS from config.openshift.io and operator.openshift.io), separate files are generated with API group suffixes:

dns_config_openshift_io.py
dns_operator_openshift_io.py

-o, --output-file

Override the output file path for the generated Python module. If not provided, the filename is derived from the Kind using convert_camel_case_to_snake_case.

class-generator -k Pod -o my_custom_pod.py

Note: When generating multiple comma-separated kinds, the --output-file value applies to all kinds. For independent output paths, run separate commands.

--overwrite

Overwrite an existing output file. Without this flag, if the target file already exists, a _TEMP.py suffixed file is created instead.

When overwriting, any user-added code blocks (code after the # End of generated code marker) and user imports are preserved in the regenerated file.

class-generator -k Pod --overwrite

--dry-run

Preview the generated output without writing any files. The generated Python code is printed to the console with syntax highlighting and line numbers using Rich.

class-generator -k Pod --dry-run

--backup

Create a timestamped backup of existing files before overwriting or regenerating. Backups are stored in .backups/backup-YYYYMMDD-HHMMSS/ preserving the original directory structure.

class-generator -k Pod --overwrite --backup

Note: Using --backup without either --regenerate-all or --overwrite results in a constraint error.

Test Generation

--add-tests

Generate test files for the specified Kind and run them. This performs two actions:

1. Generates a test manifest in class_generator/tests/manifests/<Kind>/ and regenerates class_generator/tests/test_class_generator.py from the Jinja2 template.
2. Runs the generated test file using uv run --group tests pytest class_generator/tests/test_class_generator.py.

class-generator -k Pod --add-tests

Warning: --add-tests cannot be used without -k/--kind. Running class-generator --add-tests alone exits with a non-zero status.

Schema Management

--update-schema

Fetch all resource schemas from the connected cluster's OpenAPI v3 endpoints and update the local schema files:

• class_generator/schema/__resources-mappings.json (compressed as .json.gz)
• class_generator/schema/_definitions.json

The update strategy depends on the cluster version:

When used alone, exits after updating. When combined with --generate-missing, continues to resource generation after the update.

# Update schema only
class-generator --update-schema

# Update schema then generate missing resources
class-generator --update-schema --generate-missing

Note: When --update-schema is used without --generate-missing, it cannot be combined with -k, --discover-missing, --coverage-report, --dry-run, --overwrite, -o, --add-tests, or --regenerate-all.

--update-schema-for

Update the schema for a single resource Kind without affecting other resources. The Kind name is case-sensitive.

This fetches only the API paths relevant to the specified Kind, updates (or adds) its schema in the mapping file, and exits.

class-generator --update-schema-for LlamaStackDistribution

Use cases:

• Connected to an older cluster but need to update a specific CRD
• A new operator was installed and you need its resource schema
• Refreshing just one resource without a full schema update

After updating, regenerate the class:

class-generator --update-schema-for LlamaStackDistribution
class-generator -k LlamaStackDistribution --overwrite

Errors:

Note: Cannot be combined with -k, --discover-missing, --coverage-report, --generate-missing, or --regenerate-all.

Coverage and Discovery

--discover-missing

Analyze resource coverage by comparing schema-mapped resources against implemented wrapper classes in ocp_resources/. Generates a console report showing coverage statistics and missing resources.

class-generator --discover-missing

--coverage-report

Generate a detailed coverage report showing:

# Console output (default)
class-generator --coverage-report

# JSON output
class-generator --coverage-report --json

--json

Output reports in JSON format instead of Rich console tables. Applies to --coverage-report, --discover-missing, and --generate-missing.

The JSON output structure:

{
  "generated_resources": ["ConfigMap", "Deployment", "Pod"],
  "manual_resources": ["VirtualMachine"],
  "missing_resources": [{"kind": "Binding"}, {"kind": "ComponentStatus"}],
  "coverage_stats": {
    "total_in_mapping": 400,
    "total_generated": 197,
    "total_manual": 25,
    "coverage_percentage": 49.25,
    "missing_count": 203
  }
}

class-generator --coverage-report --json

--generate-missing

Generate wrapper classes for all resources found in the schema mapping that do not yet have generated files. Each missing resource Kind is passed to class_generator() individually.

Can be combined with --update-schema to first refresh the schema, then generate all missing classes.

# Generate missing resources
class-generator --generate-missing

# Update schema first, then generate missing
class-generator --update-schema --generate-missing

# Dry run to preview
class-generator --generate-missing --dry-run

Batch Regeneration

--regenerate-all

Regenerate all existing generated resource classes using the latest schemas. Only files containing the # Generated using marker in ocp_resources/ are processed.

Regeneration runs in parallel (up to 10 workers). User-added code (below # End of generated code) is preserved during regeneration.

# Regenerate all resources
class-generator --regenerate-all

# With backup
class-generator --regenerate-all --backup

# Dry run
class-generator --regenerate-all --dry-run

# Filter to specific resources
class-generator --regenerate-all --filter "Pod*"

Output summary:

Regeneration complete: 195 succeeded, 2 failed
Backup files stored in: .backups/backup-20260705-143022

--filter

Filter which resources to regenerate using a glob pattern matched against the resource Kind name. Uses fnmatch semantics.

# Regenerate only Pod-related resources
class-generator --regenerate-all --filter "Pod*"

# Regenerate resources ending in "Service"
class-generator --regenerate-all --filter "*Service"

# Regenerate a specific resource
class-generator --regenerate-all --filter "VirtualMachine"

Logging

-v, --verbose

Enable verbose output with debug-level logs. Sets DEBUG level on the following loggers:

• class_generator.core.schema
• class_generator.core.generator
• class_generator.core.coverage
• class_generator.core.discovery
• class_generator.cli
• class_generator.utils
• ocp_resources

class-generator -k Pod -v

Constraint Rules

The CLI enforces the following option constraints:

Execution Order

When multiple compatible options are specified together, the CLI processes them in this fixed order:

1. --update-schema-for (exits after completion)
2. --update-schema (exits unless --generate-missing is also set)
3. --coverage-report / --discover-missing / --generate-missing (coverage analysis and reporting)
4. --generate-missing (generates classes for missing resources)
5. --regenerate-all (batch regeneration, exits after completion)
6. -k/--kind (normal kind generation)
7. --add-tests (test generation and execution)

Exit Codes

Programmatic API

The generation logic can be invoked directly from Python. See Generating New Resource Classes with class-generator for usage examples.

class_generator.core.generator.class_generator()

from class_generator.core.generator import class_generator

generated_files: list[str] = class_generator(
    kind="Pod",
    overwrite=False,
    dry_run=False,
    output_file="",
    output_dir="",
    add_tests=False,
    called_from_cli=True,
    update_schema_executed=False,
)

Returns: list[str] — List of generated file paths. Empty list if the kind is not found in the schema mapping (when called_from_cli=False).

Raises:

• RuntimeError — Kind not found after schema update, or user declined schema update
• ValueError — Generated filename contains invalid patterns (single-letter segments)

class_generator.core.generator.generate_resource_file_from_dict()

from class_generator.core.generator import generate_resource_file_from_dict

orig_filename, generated_filename = generate_resource_file_from_dict(
    resource_dict={"kind": "Pod", ...},
    overwrite=False,
    dry_run=False,
    output_file="",
    add_tests=False,
    output_file_suffix="",
    output_dir="",
)

Returns: tuple[str, str] — (original_filename, generated_filename). These differ when a _TEMP.py file is created.

class_generator.core.schema.update_kind_schema()

from class_generator.core.schema import update_kind_schema

update_kind_schema(client=None)

Raises:

• ClusterVersionError — Cannot determine cluster version
• RuntimeError — Failed to fetch OpenAPI v3 index
• OSError — Failed to write schema files

class_generator.core.schema.update_single_resource_schema()

from class_generator.core.schema import update_single_resource_schema

update_single_resource_schema(kind="LlamaStackDistribution", client=None)

Raises:

• ResourceNotFoundError — Kind not found on the cluster
• RuntimeError — Schema extraction or save failed

class_generator.core.coverage.analyze_coverage()

from class_generator.core.coverage import analyze_coverage

result: dict[str, Any] = analyze_coverage(resources_dir="ocp_resources")

Returns: dict[str, Any] with keys:

class_generator.core.discovery.discover_generated_resources()

from class_generator.core.discovery import discover_generated_resources

resources: list[dict[str, Any]] = discover_generated_resources()

Returns: list[dict[str, Any]] — Each dict contains:

class_generator.core.discovery.discover_cluster_resources()

from class_generator.core.discovery import discover_cluster_resources

resources: dict[str, list[dict[str, Any]]] = discover_cluster_resources(
    client=None,
    api_group_filter=None,
)

Returns: dict[str, list[dict[str, Any]]] — Mapping of API version to list of resource dicts (name, kind, namespaced).

Raises: ValueError — If client is not a DynamicClient instance.

Exceptions

class_generator.exceptions.ResourceNotFoundError

from class_generator.exceptions import ResourceNotFoundError

Raised when a resource Kind is not found in the schema mapping or on the cluster.

class_generator.core.schema.ClusterVersionError

from class_generator.core.schema import ClusterVersionError

Raised when the cluster version cannot be determined (client binary missing, cluster unreachable, or authentication failure).

Schema Files

The CLI manages two schema files under class_generator/schema/:

See Schema Validation and Code Generation Architecture for details on how these files are structured and consumed.

Common Workflows

Generate a new resource class

class-generator -k MyCustomResource

Update schema and regenerate all classes

class-generator --update-schema
class-generator --regenerate-all --backup

Add a new CRD to an older cluster

class-generator --update-schema-for MyNewCRD
class-generator -k MyNewCRD

CI/CD coverage check

class-generator --coverage-report --json > coverage.json

Preview changes before writing

class-generator -k Pod --dry-run
class-generator --regenerate-all --dry-run

Related Pages

• Generating New Resource Classes with class-generator — Step-by-step guide for scaffolding resource classes
• Resource and NamespacedResource API — API reference for the base classes that generated code extends
• Understanding the Resource Class Hierarchy — How generated subclasses fit into the class hierarchy
• Schema Validation and Code Generation Architecture — Internals of schema fetching, caching, and code generation
• Environment Variables and Configuration — Environment variables that affect runtime behavior

Related Pages

• Generating New Resource Classes with class-generator
• Schema Validation and Code Generation Architecture
• Understanding the Resource Class Hierarchy
• Resource and NamespacedResource API
• Environment Variables and Configuration