openshift-python-wrapper 11.0.120__tar.gz → 11.0.122__tar.gz

openshift_python_wrapper-11.0.122/.git

@@ -0,0 +1 @@
+gitdir: /tmp/github-webhook-openshift-python-wrapper-lyx3bnyt/.git/worktrees/github-webhook-openshift-python-wrapper-lyx3bnyt-worktree-255b73b2-f8f5-4262-a1ec-a9fadab9de0d

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/.pre-commit-config.yaml

@@ -45,7 +45,7 @@ repos:
           ]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.5
+    rev: v0.15.8
     hooks:
       - id: ruff
       - id: ruff-format

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openshift-python-wrapper
-Version: 11.0.120
+Version: 11.0.122
 Summary: Wrapper around https://github.com/kubernetes-client/python
 Project-URL: homepage, https://github.com/RedHatQE/openshift-python-wrapper
 Project-URL: documentation, https://openshift-python-wrapper.readthedocs.io/en/latest/

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/class_generator/parsers/explain_parser.py

@@ -89,7 +89,7 @@ def parse_explain(kind: str) -> list[dict[str, Any]]:
 
         resource_dict: dict[str, Any] = {
             "base_class": "NamespacedResource" if namespaced else "Resource",
-            "description": _kind_schema.get("description", MISSING_DESCRIPTION_STR),
+            "description": _kind_schema.get("description") or MISSING_DESCRIPTION_STR,
             "fields": [],
             "spec": [],
         }

openshift_python_wrapper-11.0.122/ocp_resources/evalhub.py

@@ -0,0 +1,85 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+
+from typing import Any
+
+from ocp_resources.resource import NamespacedResource
+
+
+class EvalHub(NamespacedResource):
+    """
+    EvalHub is the Schema for the evalhubs API
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.TRUSTYAI_OPENDATAHUB_IO
+
+    def __init__(
+        self,
+        collections: list[Any] | None = None,
+        database: dict[str, Any] | None = None,
+        env: list[Any] | None = None,
+        otel: dict[str, Any] | None = None,
+        providers: list[Any] | None = None,
+        replicas: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        r"""
+        Args:
+            collections (list[Any]): Collections is the list of OOTB collection names to mount into the
+              deployment. Each name must match a collection-name label on a
+              ConfigMap in the operator namespace.
+
+            database (dict[str, Any]): Database configuration for persistent storage. This field is required:
+              the operator will not start the service without an explicit
+              database configuration. Set type to "postgresql" with a secret
+              reference, or "sqlite" for lightweight/development deployments.
+
+            env (list[Any]): Environment variables for the eval-hub container
+
+            otel (dict[str, Any]): OpenTelemetry configuration for observability. When set, the operator
+              includes OTEL settings in the generated config. When omitted, the
+              service uses its defaults (OTEL disabled).
+
+            providers (list[Any]): Providers is the list of OOTB provider names to mount into the
+              deployment. Each name must match a provider-name label on a
+              ConfigMap in the operator namespace.
+
+            replicas (int): Number of replicas for the eval-hub deployment
+
+        """
+        super().__init__(**kwargs)
+
+        self.collections = collections
+        self.database = database
+        self.env = env
+        self.otel = otel
+        self.providers = providers
+        self.replicas = replicas
+
+    def to_dict(self) -> None:
+
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.collections is not None:
+                _spec["collections"] = self.collections
+
+            if self.database is not None:
+                _spec["database"] = self.database
+
+            if self.env is not None:
+                _spec["env"] = self.env
+
+            if self.otel is not None:
+                _spec["otel"] = self.otel
+
+            if self.providers is not None:
+                _spec["providers"] = self.providers
+
+            if self.replicas is not None:
+                _spec["replicas"] = self.replicas
+
+    # End of generated code

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/ocp_resources/guardrails_orchestrator.py

@@ -1,5 +1,6 @@
 # Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
 
+
 from typing import Any
 
 from ocp_resources.exceptions import MissingRequiredArgumentError
@@ -16,13 +17,17 @@ class GuardrailsOrchestrator(NamespacedResource):
     def __init__(
         self,
         auto_config: dict[str, Any] | None = None,
+        custom_detectors_config: str | None = None,
+        disable_orchestrator: bool | None = None,
         enable_built_in_detectors: bool | None = None,
         enable_guardrails_gateway: bool | None = None,
+        env: list[Any] | None = None,
         guardrails_gateway_config: str | None = None,
         log_level: str | None = None,
         orchestrator_config: str | None = None,
         otel_exporter: dict[str, Any] | None = None,
         replicas: int | None = None,
+        tls_secrets: list[Any] | None = None,
         **kwargs: Any,
     ) -> None:
         r"""
@@ -30,15 +35,25 @@ class GuardrailsOrchestrator(NamespacedResource):
             auto_config (dict[str, Any]): Settings governing the automatic configuration of the orchestrator.
               Replaces `OrchestratorConfig`.
 
+            custom_detectors_config (str): Name of configmap containing user-defined Python detectors. This is
+              only used if EnableBuiltInDetectors is true
+
+            disable_orchestrator (bool):  Boolean flag to disable the orchestrator container, if running the
+              built-in detectors in standalone mode
+
             enable_built_in_detectors (bool): Boolean flag to enable/disable built-in detectors
 
             enable_guardrails_gateway (bool): Boolean flag to enable/disable the guardrails sidecar gateway
 
+            env (list[Any]): Define environment variables. These will be added to the orchestrator,
+              gateway, and built-in detector pods.
+
             guardrails_gateway_config (str):  Name of the configmap containing guadrails sidecar gateway arguments
 
             log_level (str): Set log level in the orchestrator deployment
 
-            orchestrator_config (str): Name of configmap containing generator,detector,and chunker arguments
+            orchestrator_config (str): Name of configmap containing generator, detector, and chunker
+              arguments
 
             otel_exporter (dict[str, Any]): List of orchestrator enviroment variables for configuring the OTLP
               exporter
@@ -47,19 +62,27 @@ class GuardrailsOrchestrator(NamespacedResource):
               Run "make" to regenerate code after modifying this file Number of
               replicas
 
+            tls_secrets (list[Any]): Define TLS secrets to be mounted to the orchestrator. Secrets will be
+              mounted at /etc/tls/$SECRET_NAME
+
         """
         super().__init__(**kwargs)
 
         self.auto_config = auto_config
+        self.custom_detectors_config = custom_detectors_config
+        self.disable_orchestrator = disable_orchestrator
         self.enable_built_in_detectors = enable_built_in_detectors
         self.enable_guardrails_gateway = enable_guardrails_gateway
+        self.env = env
         self.guardrails_gateway_config = guardrails_gateway_config
         self.log_level = log_level
         self.orchestrator_config = orchestrator_config
         self.otel_exporter = otel_exporter
         self.replicas = replicas
+        self.tls_secrets = tls_secrets
 
     def to_dict(self) -> None:
+
         super().to_dict()
 
         if not self.kind_dict and not self.yaml_file:
@@ -74,12 +97,21 @@ class GuardrailsOrchestrator(NamespacedResource):
             if self.auto_config is not None:
                 _spec["autoConfig"] = self.auto_config
 
+            if self.custom_detectors_config is not None:
+                _spec["customDetectorsConfig"] = self.custom_detectors_config
+
+            if self.disable_orchestrator is not None:
+                _spec["disableOrchestrator"] = self.disable_orchestrator
+
             if self.enable_built_in_detectors is not None:
                 _spec["enableBuiltInDetectors"] = self.enable_built_in_detectors
 
             if self.enable_guardrails_gateway is not None:
                 _spec["enableGuardrailsGateway"] = self.enable_guardrails_gateway
 
+            if self.env is not None:
+                _spec["env"] = self.env
+
             if self.guardrails_gateway_config is not None:
                 _spec["guardrailsGatewayConfig"] = self.guardrails_gateway_config
 
@@ -92,4 +124,7 @@ class GuardrailsOrchestrator(NamespacedResource):
             if self.otel_exporter is not None:
                 _spec["otelExporter"] = self.otel_exporter
 
+            if self.tls_secrets is not None:
+                _spec["tlsSecrets"] = self.tls_secrets
+
     # End of generated code

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/ocp_resources/llama_stack_distribution.py

@@ -16,12 +16,15 @@ class LlamaStackDistribution(NamespacedResource):
 
     def __init__(
         self,
+        network: dict[str, Any] | None = None,
         replicas: int | None = None,
         server: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         r"""
         Args:
+            network (dict[str, Any]): Network defines network access controls for the LlamaStack service
+
             replicas (int): No field description from API
 
             server (dict[str, Any]): ServerSpec defines the desired state of llama server.
@@ -29,10 +32,12 @@ class LlamaStackDistribution(NamespacedResource):
         """
         super().__init__(**kwargs)
 
+        self.network = network
         self.replicas = replicas
         self.server = server
 
     def to_dict(self) -> None:
+
         super().to_dict()
 
         if not self.kind_dict and not self.yaml_file:
@@ -44,6 +49,9 @@ class LlamaStackDistribution(NamespacedResource):
 
             _spec["server"] = self.server
 
+            if self.network is not None:
+                _spec["network"] = self.network
+
             if self.replicas is not None:
                 _spec["replicas"] = self.replicas
 

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/ocp_resources/lm_eval_job.py

@@ -98,6 +98,7 @@ class LMEvalJob(NamespacedResource):
         self.task_list = task_list
 
     def to_dict(self) -> None:
+
         super().to_dict()
 
         if not self.kind_dict and not self.yaml_file:

{openshift_python_wrapper-11.0.120 → openshift_python_wrapper-11.0.122}/ocp_resources/migration_policy.py

@@ -9,6 +9,7 @@ class MigrationPolicy(Resource):
         name=None,
         allow_auto_converge=None,
         allow_post_copy=None,
+        allow_workload_disruption=None,
         bandwidth_per_migration=None,
         completion_timeout_per_gb=None,
         namespace_selector=None,
@@ -22,6 +23,7 @@ class MigrationPolicy(Resource):
             name (str): Migration Policy name
             allow_auto_converge (bool, optional)
             allow_post_copy (bool, optional)
+            allow_workload_disruption (bool, optional)
             bandwidth_per_migration (str, optional, i.e. "1Gi")
             completion_timeout_per_gb (int, optional)
             namespace_selector (dict, optional): Dict of Namespace labels to match (e.g. {"project-owner": "redhat"})
@@ -33,6 +35,7 @@ class MigrationPolicy(Resource):
         )
         self.allow_auto_converge = allow_auto_converge
         self.allow_post_copy = allow_post_copy
+        self.allow_workload_disruption = allow_workload_disruption
         self.bandwidth_per_migration = bandwidth_per_migration
         self.completion_timeout_per_gb = completion_timeout_per_gb
         self.namespace_selector = namespace_selector or {}
@@ -48,6 +51,8 @@ class MigrationPolicy(Resource):
                 self.res["spec"]["allowAutoConverge"] = self.allow_auto_converge
             if self.allow_post_copy is not None:
                 self.res["spec"]["allowPostCopy"] = self.allow_post_copy
+            if self.allow_workload_disruption is not None:
+                self.res["spec"]["allowWorkloadDisruption"] = self.allow_workload_disruption
             if self.bandwidth_per_migration:
                 self.res["spec"]["bandwidthPerMigration"] = self.bandwidth_per_migration
             if self.completion_timeout_per_gb:

openshift_python_wrapper-11.0.122/ocp_resources/mlflow.py

@@ -0,0 +1,286 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+
+from typing import Any
+
+from ocp_resources.resource import Resource
+
+
+class MLflow(Resource):
+    """
+    MLflow is the Schema for the mlflows API
+    """
+
+    api_group: str = Resource.ApiGroup.MLFLOW_OPENDATAHUB_IO
+
+    def __init__(
+        self,
+        affinity: dict[str, Any] | None = None,
+        artifacts_destination: str | None = None,
+        backend_store_uri: str | None = None,
+        backend_store_uri_from: dict[str, Any] | None = None,
+        ca_bundle_config_map: dict[str, Any] | None = None,
+        default_artifact_root: str | None = None,
+        env: list[Any] | None = None,
+        env_from: list[Any] | None = None,
+        extra_allowed_origins: list[Any] | None = None,
+        image: dict[str, Any] | None = None,
+        network_policy_additional_egress_rules: list[Any] | None = None,
+        node_selector: dict[str, Any] | None = None,
+        pod_annotations: dict[str, Any] | None = None,
+        pod_labels: dict[str, Any] | None = None,
+        pod_security_context: dict[str, Any] | None = None,
+        registry_store_uri: str | None = None,
+        registry_store_uri_from: dict[str, Any] | None = None,
+        replicas: int | None = None,
+        resources: dict[str, Any] | None = None,
+        security_context: dict[str, Any] | None = None,
+        serve_artifacts: bool | None = None,
+        service_account_name: str | None = None,
+        storage: dict[str, Any] | None = None,
+        tolerations: list[Any] | None = None,
+        workers: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        r"""
+        Args:
+            affinity (dict[str, Any]): Affinity specifies the pod's scheduling constraints
+
+            artifacts_destination (str): ArtifactsDestination is the server-side destination for MLflow
+              artifacts (models, plots, files). This setting only applies when
+              ServeArtifacts is enabled. When ServeArtifacts is disabled, this
+              field is ignored and clients access artifact storage directly.
+              Supported schemes: file://, s3://, gs://, wasbs://, hdfs://, etc.
+              Examples:   - "file:///mlflow/artifacts" (requires Storage to be
+              configured)   - "s3://my-bucket/mlflow/artifacts" (no Storage
+              needed)   - "gs://my-bucket/mlflow/artifacts" (no Storage needed)
+              If not specified when ServeArtifacts is enabled, defaults to
+              "file:///mlflow/artifacts"  For cloud storage authentication, use
+              EnvFrom to inject credentials from secrets or configmaps. Example
+              for S3:   envFrom:   - secretRef:       name: aws-credentials  #
+              Contains AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY Example for GCS:
+              envFrom:   - secretRef:       name: gcp-credentials  # Contains
+              GOOGLE_APPLICATION_CREDENTIALS path
+
+            backend_store_uri (str): BackendStoreURI is the URI for the MLflow backend store (metadata).
+              Supported schemes: file://, sqlite://, mysql://, postgresql://,
+              etc. Examples:   - "sqlite:////mlflow/mlflow.db" (requires Storage
+              to be configured) Note: For URIs containing credentials, prefer
+              using BackendStoreURIFrom for security. This must be set
+              explicitly unless BackendStoreURIFrom is provided.
+
+            backend_store_uri_from (dict[str, Any]): BackendStoreURIFrom is a reference to a secret containing the backend
+              store URI. Use this instead of BackendStoreURI when the URI
+              contains credentials. Mutually exclusive with BackendStoreURI -
+              the API rejects specs that set both.
+
+            ca_bundle_config_map (dict[str, Any]): CABundleConfigMap specifies a ConfigMap containing a CA certificate
+              bundle. The bundle will be mounted into the MLflow container and
+              configured for use with TLS connections (e.g. PostgreSQL SSL, S3
+              with custom certificates).
+
+            default_artifact_root (str): DefaultArtifactRoot is the default artifact root path for MLflow runs
+              on the server. This is required when serveArtifacts is false.
+              Supported schemes: file://, s3://, gs://, wasbs://, hdfs://, etc.
+              Examples:   - "s3://my-bucket/mlflow/artifacts"   - "gs://my-
+              bucket/mlflow/artifacts"   - "file:///mlflow/artifacts"
+
+            env (list[Any]): Env is a list of environment variables to set in the MLflow container
+
+            env_from (list[Any]): EnvFrom is a list of sources to populate environment variables in the
+              MLflow container
+
+            extra_allowed_origins (list[Any]): ExtraAllowedOrigins is a list of additional origins to allow for CORS
+              requests. The operator preconfigures safe defaults including
+              Kubernetes service names, the data science gateway domain, and
+              localhost. Use this field to add additional origins beyond the
+              defaults. Each entry should be a full origin
+              (scheme://host[:port]), e.g. "https://my-app.example.com".
+
+            image (dict[str, Any]): Image specifies the MLflow container image. If not specified, use the
+              default image via the MLFLOW_IMAGE environment variable in the
+              operator.
+
+            network_policy_additional_egress_rules (list[Any]): NetworkPolicyAdditionalEgressRules specifies additional egress rules
+              to append to the default NetworkPolicy. The default policy permits
+              DNS (53), HTTPS (443), Kubernetes API (6443), PostgreSQL (5432),
+              MySQL (3306), and S3-compatible storage (MinIO 9000, SeaweedFS
+              8333). Use this field when connecting to services on non-standard
+              ports or when destination restrictions are needed.
+
+            node_selector (dict[str, Any]): NodeSelector is a selector which must be true for the pod to fit on a
+              node
+
+            pod_annotations (dict[str, Any]): PodAnnotations are annotations to add only to the MLflow pod, not to
+              other resources. Use this for pod-specific annotations like
+              Prometheus scraping or sidecar configuration.
+
+            pod_labels (dict[str, Any]): PodLabels are labels to add only to the MLflow pod, not to other
+              resources. Use this for pod-specific labels like version,
+              component-specific metadata, etc. For labels that should be
+              applied to all resources (Service, Deployment, etc.), use
+              commonLabels in values.yaml.
+
+            pod_security_context (dict[str, Any]): PodSecurityContext specifies the security context for the MLflow pod
+
+            registry_store_uri (str): RegistryStoreURI is the URI for the MLflow registry store (model
+              registry metadata). Supported schemes: file://, sqlite://,
+              mysql://, postgresql://, etc. Examples:   -
+              "sqlite:////mlflow/mlflow.db" (requires Storage to be configured)
+              If omitted, defaults to the same value as backendStoreUri. Note:
+              For URIs containing credentials, prefer using RegistryStoreURIFrom
+              for security.
+
+            registry_store_uri_from (dict[str, Any]): RegistryStoreURIFrom is a reference to a secret containing the
+              registry store URI. Use this instead of RegistryStoreURI when the
+              URI contains credentials. Mutually exclusive with RegistryStoreURI
+              - the API rejects specs that set both.
+
+            replicas (int): Replicas is the number of MLflow pods to run
+
+            resources (dict[str, Any]): Resources specifies the compute resources for the MLflow container
+
+            security_context (dict[str, Any]): SecurityContext specifies the security context for the MLflow
+              container
+
+            serve_artifacts (bool): ServeArtifacts determines whether MLflow should serve artifacts. When
+              enabled, adds the --serve-artifacts flag to the MLflow server and
+              uses ArtifactsDestination to configure where artifacts are stored.
+              This allows clients to log and retrieve artifacts through the
+              MLflow server's REST API instead of directly accessing the
+              artifact storage. When disabled, ArtifactsDestination is ignored
+              and clients must have direct access to artifact storage.
+
+            service_account_name (str): ServiceAccountName is the name of the ServiceAccount to use for the
+              MLflow pod. If not specified, a default ServiceAccount will be
+              "mlflow-sa"
+
+            storage (dict[str, Any]): Storage specifies the persistent storage configuration using standard
+              PVC spec. Only required if using SQLite backend/registry stores or
+              file-based artifacts. Not needed when using remote storage (S3,
+              PostgreSQL, etc.). When omitted, no PVC will be created - ensure
+              backendStoreUri, registryStoreUri, and artifactsDestination point
+              to remote storage. Example:   storage:     accessModes:
+              ["ReadWriteOnce"]     resources:       requests:         storage:
+              10Gi     storageClassName: fast-ssd
+
+            tolerations (list[Any]): Tolerations are the pod's tolerations
+
+            workers (int): Workers is the number of uvicorn worker processes for the MLflow
+              server. Note: This is different from pod replicas. Each pod will
+              run this many worker processes. Defaults to 1. For high-traffic
+              deployments, consider increasing pod replicas instead.
+
+        """
+        super().__init__(**kwargs)
+
+        self.affinity = affinity
+        self.artifacts_destination = artifacts_destination
+        self.backend_store_uri = backend_store_uri
+        self.backend_store_uri_from = backend_store_uri_from
+        self.ca_bundle_config_map = ca_bundle_config_map
+        self.default_artifact_root = default_artifact_root
+        self.env = env
+        self.env_from = env_from
+        self.extra_allowed_origins = extra_allowed_origins
+        self.image = image
+        self.network_policy_additional_egress_rules = network_policy_additional_egress_rules
+        self.node_selector = node_selector
+        self.pod_annotations = pod_annotations
+        self.pod_labels = pod_labels
+        self.pod_security_context = pod_security_context
+        self.registry_store_uri = registry_store_uri
+        self.registry_store_uri_from = registry_store_uri_from
+        self.replicas = replicas
+        self.resources = resources
+        self.security_context = security_context
+        self.serve_artifacts = serve_artifacts
+        self.service_account_name = service_account_name
+        self.storage = storage
+        self.tolerations = tolerations
+        self.workers = workers
+
+    def to_dict(self) -> None:
+
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.affinity is not None:
+                _spec["affinity"] = self.affinity
+
+            if self.artifacts_destination is not None:
+                _spec["artifactsDestination"] = self.artifacts_destination
+
+            if self.backend_store_uri is not None:
+                _spec["backendStoreUri"] = self.backend_store_uri
+
+            if self.backend_store_uri_from is not None:
+                _spec["backendStoreUriFrom"] = self.backend_store_uri_from
+
+            if self.ca_bundle_config_map is not None:
+                _spec["caBundleConfigMap"] = self.ca_bundle_config_map
+
+            if self.default_artifact_root is not None:
+                _spec["defaultArtifactRoot"] = self.default_artifact_root
+
+            if self.env is not None:
+                _spec["env"] = self.env
+
+            if self.env_from is not None:
+                _spec["envFrom"] = self.env_from
+
+            if self.extra_allowed_origins is not None:
+                _spec["extraAllowedOrigins"] = self.extra_allowed_origins
+
+            if self.image is not None:
+                _spec["image"] = self.image
+
+            if self.network_policy_additional_egress_rules is not None:
+                _spec["networkPolicyAdditionalEgressRules"] = self.network_policy_additional_egress_rules
+
+            if self.node_selector is not None:
+                _spec["nodeSelector"] = self.node_selector
+
+            if self.pod_annotations is not None:
+                _spec["podAnnotations"] = self.pod_annotations
+
+            if self.pod_labels is not None:
+                _spec["podLabels"] = self.pod_labels
+
+            if self.pod_security_context is not None:
+                _spec["podSecurityContext"] = self.pod_security_context
+
+            if self.registry_store_uri is not None:
+                _spec["registryStoreUri"] = self.registry_store_uri
+
+            if self.registry_store_uri_from is not None:
+                _spec["registryStoreUriFrom"] = self.registry_store_uri_from
+
+            if self.replicas is not None:
+                _spec["replicas"] = self.replicas
+
+            if self.resources is not None:
+                _spec["resources"] = self.resources
+
+            if self.security_context is not None:
+                _spec["securityContext"] = self.security_context
+
+            if self.serve_artifacts is not None:
+                _spec["serveArtifacts"] = self.serve_artifacts
+
+            if self.service_account_name is not None:
+                _spec["serviceAccountName"] = self.service_account_name
+
+            if self.storage is not None:
+                _spec["storage"] = self.storage
+
+            if self.tolerations is not None:
+                _spec["tolerations"] = self.tolerations
+
+            if self.workers is not None:
+                _spec["workers"] = self.workers
+
+    # End of generated code

openshift_python_wrapper-11.0.122/ocp_resources/mlflow_config.py

@@ -0,0 +1,68 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+
+from typing import Any
+
+from ocp_resources.exceptions import MissingRequiredArgumentError
+from ocp_resources.resource import NamespacedResource
+
+
+class MLflowConfig(NamespacedResource):
+    """
+        MLflowConfig is a namespace-scoped configuration resource that allows
+    Kubernetes namespace owners to override the default artifact storage
+    for their namespace.
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.MLFLOW_KUBEFLOW_ORG
+
+    def __init__(
+        self,
+        artifact_root_path: str | None = None,
+        artifact_root_secret: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        r"""
+        Args:
+            artifact_root_path (str): ArtifactRootPath is an optional relative path from the bucket root
+              specified in the ArtifactRootSecret. When provided, this path is
+              appended to the bucket URI from the secret to form the resolved
+              artifact root.  Example:   artifactRootSecret: "mlflow-artifact-
+              connection"  # Contains bucket: ds-team-bucket   artifactRootPath:
+              "experiments"   resolved artifact root: s3://ds-team-
+              bucket/experiments
+
+            artifact_root_secret (str): ArtifactRootSecret is the name of a Secret in this namespace that
+              contains credentials and bucket information for accessing the
+              artifact storage.  The Secret must have the required keys for s3
+              compatible storage: Example Secret:   apiVersion: v1   kind:
+              Secret   metadata:     name: mlflow-artifact-connection
+              namespace: ds-team-namespace   data:     AWS_ACCESS_KEY_ID:
+              <base64-encoded>     AWS_SECRET_ACCESS_KEY: <base64-encoded>
+              AWS_S3_BUCKET: <base64-encoded>     AWS_S3_ENDPOINT:
+              <base64-encoded>     AWS_DEFAULT_REGION: <base64-encoded>  #
+              Optional (default region is not always required, e.g. minio)
+
+        """
+        super().__init__(**kwargs)
+
+        self.artifact_root_path = artifact_root_path
+        self.artifact_root_secret = artifact_root_secret
+
+    def to_dict(self) -> None:
+
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            if self.artifact_root_secret is None:
+                raise MissingRequiredArgumentError(argument="self.artifact_root_secret")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["artifactRootSecret"] = self.artifact_root_secret
+
+            if self.artifact_root_path is not None:
+                _spec["artifactRootPath"] = self.artifact_root_path
+
+    # End of generated code