oracle-ads 2.13.7__py3-none-any.whl → 2.13.9rc0__py3-none-any.whl

ads/opctl/operator/common/operator_schema.yaml

@@ -1,130 +0,0 @@
-type:
-  required: false
-  type: string
-  meta:
-    description: "The type of the operator."
-name:
-  required: true
-  type: string
-  meta:
-    description: "The name of the operator."
-version:
-  required: true
-  type: string
-  default: v1
-  meta:
-    description: "The version of the operator."
-description:
-  required: false
-  type: string
-  meta:
-    description: "The short description of the operator."
-gpu:
-  required: false
-  type: string
-  default: no
-  allowed:
-    - yes
-    - no
-  meta:
-    description: "If the operator requires GPU cluster."
-keywords:
-  required: false
-  type: list
-  schema:
-    type: string
-  meta:
-    description: "The operator's keywords."
-backends:
-  required: false
-  type: list
-  schema:
-    type: string
-  meta:
-    description: "The operator's supported backends. Can be [job, dataflow]"
-conda_type:
-  required: false
-  type: string
-  default: custom
-  allowed:
-    - service
-    - published
-  meta:
-    description: "The operator's conda environment type. Can be either service or custom type."
-conda:
-  required: false
-  type: string
-  meta:
-    description: "The operator's conda environment name. Will be auto-generated if not provided."
-jobs_default_params:
-  required: false
-  type: dict
-  meta:
-    description: "The default parameters for the Data Science Job."
-  schema:
-    shape_name:
-      required: false
-      type: string
-      meta:
-        description: "The name of the shape."
-    ocpus:
-      required: false
-      type: integer
-      meta:
-        description: "The OCPUs count."
-    memory_in_gbs:
-      required: false
-      type: integer
-      meta:
-        description: "The size of the memory in GBs."
-    block_storage_size_in_GBs:
-      required: false
-      type: integer
-      meta:
-        description: "Size of the block storage drive."
-dataflow_default_params:
-  required: false
-  type: dict
-  meta:
-    description: "The default params for the DataFlow service."
-  schema:
-    spark_version:
-      required: false
-      type: string
-      meta:
-        description: "The version of the SPARK."
-    driver_shape:
-      required: false
-      type: string
-      meta:
-        description: "The name of the driver shape."
-    driver_shape_ocpus:
-      required: false
-      type: integer
-      meta:
-        description: "The OCPUs count for the driver shape."
-    driver_shape_memory_in_gbs:
-      required: false
-      type: integer
-      meta:
-        description: "The size of the memory in GBs for the driver shape."
-    executor_shape:
-      required: false
-      type: string
-      meta:
-        description: "The name of the executor shape."
-    executor_shape_ocpus:
-      required: false
-      type: integer
-      meta:
-        description: "The OCPUs count for the executor shape."
-    executor_shape_memory_in_gbs:
-      required: false
-      type: integer
-      meta:
-        description: "The size of the memory in GBs for the executor shape."
-    num_executors:
-      required: false
-      type: integer
-      meta:
-        description: "The number of executors."

ads/opctl/operator/common/operator_yaml_generator.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8; -*-
-
-# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
-# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-
-from ads.opctl.operator.common.utils import remove_prefix
-from dataclasses import dataclass
-from typing import Any, Dict, Optional, List
-
-import yaml
-
-
-@dataclass
-class YamlGenerator:
-    """
-    Class for generating the YAML config based on the given YAML schema.
-
-    Attributes
-    ----------
-    schema: Dict
-        The schema of the template.
-    """
-
-    schema: Dict[str, Any] = None
-
-    def generate_example_dict(
-        self,
-        values: Optional[Dict[str, Any]] = (),
-        required_keys: Optional[List[str]] = (),
-    ) -> Dict:
-        """
-        Generate the YAML config based on the YAML schema.
-
-        Properties
-        ----------
-        values: Optional dictionary containing specific values for the attributes.
-
-        Returns
-        -------
-        Dict
-            The generated dictionary config.
-        """
-        return self._generate_example(self.schema, values, required_keys)
-
-    def generate_example(self, values: Optional[Dict[str, Any]] = None) -> str:
-        """
-        Generate the YAML config based on the YAML schema.
-
-        Properties
-        ----------
-        values: Optional dictionary containing specific values for the attributes.
-
-        Returns
-        -------
-        str
-            The generated YAML config.
-        """
-        return yaml.dump(self._generate_example(self.schema, values))
-
-    def _check_condition(
-        self, condition: Dict[str, Any], example: Dict[str, Any]
-    ) -> bool:
-        """
-        Checks if the YAML schema condition fulfils.
-        This method is used to include conditional fields into the final config.
-
-        Properties
-        ----------
-        condition: Dict[str, Any]
-            The schema condition.
-            Example:
-            In the example below the `owner_name` field has dependency on the `model` field.
-            The `owner_name` will be included to the final config if only `model` is `prophet`.
-                owner_name:
-                    type: string
-                    dependencies: {"model":"prophet"}
-        example: Dict[str, Any]
-            The config to check if the dependable value presented there.
-        Returns
-        -------
-        bool
-            True if the condition fulfills, false otherwise.
-        """
-        for key, value in condition.items():
-            if key not in example or example[key] != value:
-                return False
-        return True
-
-    def _generate_example(
-        self,
-        schema: Dict[str, Any],
-        values: Optional[Dict[str, Any]] = (),
-        required_keys: Optional[List[str]] = (),
-    ) -> Dict[str, Any]:
-        """
-        Generates the final YAML config.
-        This is a recursive method, which iterates through the entire schema.
-
-        Properties
-        ----------
-        schema: Dict[str, Any]
-            The schema to generate the config.
-        values: Optional[Dict[str, Any]]
-            The optional values that would be used instead of default values provided in the schema.
-
-        Returns
-        -------
-        Dict
-            The result config.
-        """
-        example = {}
-
-        for key, value in schema.items():
-            # only generate values for required fields
-            if (
-                value.get("required", False)
-                or value.get("dependencies", False)
-                or key in values
-                or (required_keys and key in required_keys)
-            ):
-                if not "dependencies" in value or self._check_condition(
-                    value["dependencies"], example
-                ):
-                    data_type = value.get("type")
-                    if key in values:
-                        example[key] = values[key]
-                    elif "default" in value:
-                        example[key] = value["default"]
-                    elif data_type == "string":
-                        example[key] = "value"
-                    elif data_type == "number":
-                        example[key] = 1
-                    elif data_type == "boolean":
-                        example[key] = True
-                    elif data_type == "list":
-                        # TODO: Handle list of dict
-                        example[key] = ["item1", "item2"]
-                    elif data_type == "dict":
-                        example[key] = self._generate_example(
-                            schema=value.get("schema", {}),
-                            values={
-                                remove_prefix(local_key, f"{key}."): value
-                                for local_key, value in values.items()
-                            },
-                            required_keys=[
-                                remove_prefix(required_key, f"{key}.")
-                                for required_key in required_keys
-                            ],
-                        )
-
-        return example

ads/opctl/operator/common/utils.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
-# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-
-import argparse
-import logging
-import os
-import sys
-import time
-import traceback
-import uuid
-from string import Template
-from typing import Any, Dict, List, Tuple
-
-import fsspec
-import yaml
-from cerberus import Validator
-
-from ads.opctl import logger, utils
-from ads.common.oci_logging import OCILog
-
-CONTAINER_NETWORK = "CONTAINER_NETWORK"
-
-
-class OperatorValidator(Validator):
-    """The custom validator class."""
-
-    def validate(self, obj_dict, **kwargs):
-        # Model should be case insensitive
-        if "model" in obj_dict["spec"]:
-            obj_dict["spec"]["model"] = str(obj_dict["spec"]["model"]).lower()
-        return super().validate(obj_dict, **kwargs)
-
-
-def create_output_folder(name):
-    output_folder = name
-    protocol = fsspec.utils.get_protocol(output_folder)
-    storage_options = {}
-    if protocol != "file":
-        storage_options = default_signer()
-
-    fs = fsspec.filesystem(protocol, **storage_options)
-    name_suffix = 1
-    while fs.exists(output_folder):
-        name_suffix = name_suffix + 1
-        output_folder = f"{name}_{name_suffix}"
-    fs.mkdirs(output_folder)
-    return output_folder
-
-
-def _build_image(
-    dockerfile: str,
-    image_name: str,
-    tag: str = None,
-    target: str = None,
-    **kwargs: Dict[str, Any],
-) -> str:
-    """
-    Builds the operator image.
-
-    Parameters
-    ----------
-    dockerfile: str
-        Path to the docker file.
-    image_name: str
-        The name of the image.
-    tag: (str, optional)
-        The tag of the image.
-    target: (str, optional)
-        The image target.
-    kwargs: (Dict, optional).
-        Additional key value arguments.
-
-    Returns
-    -------
-    str
-        The final image name.
-
-    Raises
-    ------
-    ValueError
-        When dockerfile or image name not provided.
-    FileNotFoundError
-        When dockerfile doesn't exist.
-    RuntimeError
-        When docker build operation fails.
-    """
-    if not (dockerfile and image_name):
-        raise ValueError("The `dockerfile` and `image_name` needs to be provided.")
-
-    if not os.path.isfile(dockerfile):
-        raise FileNotFoundError(f"The file `{dockerfile}` does not exist")
-
-    image_name = f"{image_name}:{tag or 'latest'}"
-
-    command = [
-        "docker",
-        "build",
-        "-t",
-        image_name,
-        "-f",
-        dockerfile,
-    ]
-
-    if target:
-        command += ["--target", target]
-    if os.environ.get("no_proxy"):
-        command += ["--build-arg", f"no_proxy={os.environ['no_proxy']}"]
-    if os.environ.get("http_proxy"):
-        command += ["--build-arg", f"http_proxy={os.environ['http_proxy']}"]
-    if os.environ.get("https_proxy"):
-        command += ["--build-arg", f"https_proxy={os.environ['https_proxy']}"]
-    command += ["--build-arg", f"RND={time.time()}"]
-    if os.environ.get(CONTAINER_NETWORK):
-        command += ["--network", os.environ[CONTAINER_NETWORK]]
-    command += [os.path.dirname(dockerfile)]
-
-    logger.info(f"Build image: {command}")
-
-    proc = utils.run_command(command)
-    if proc.returncode != 0:
-        raise RuntimeError("Docker build failed.")
-
-    return image_name
-
-
-def _extant_file(x: str):
-    """Checks the extension of the file to yaml."""
-    if not (x.lower().endswith(".yml") or x.lower().endswith(".yaml")):
-        raise argparse.ArgumentTypeError(
-            f"The {x} exists, but must be a yaml file (.yaml/.yml)"
-        )
-    return x
-
-
-def _parse_input_args(raw_args: List) -> Tuple:
-    """Parses operator input arguments."""
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-f",
-        "--file",
-        type=_extant_file,
-        required=False,
-        help="Path to the operator specification YAML file",
-    )
-    parser.add_argument(
-        "-s", "--spec", type=str, required=False, help="Operator Yaml specification"
-    )
-    parser.add_argument(
-        "-v",
-        "--verify",
-        type=bool,
-        default=False,
-        required=False,
-        help="Verify operator schema",
-    )
-    return parser.parse_known_args(raw_args)
-
-
-def _load_yaml_from_string(doc: str, **kwargs) -> Dict:
-    """Loads YAML from string and merge it with env variables and kwargs."""
-    template_dict = {**os.environ, **kwargs}
-    return yaml.safe_load(
-        Template(doc).safe_substitute(
-            **template_dict,
-        )
-    )
-
-
-def _load_yaml_from_uri(uri: str, **kwargs) -> dict:
-    """Loads YAML from the URI path. Can be Object Storage path."""
-    with fsspec.open(uri) as f:
-        return _load_yaml_from_string(str(f.read(), "UTF-8"), **kwargs)
-
-
-def default_signer(**kwargs):
-    os.environ["EXTRA_USER_AGENT_INFO"] = "Operator"
-    from ads.common.auth import default_signer
-
-    return default_signer(**kwargs)
-
-
-def remove_prefix(text: str, prefix: str):
-    if text.startswith(prefix):
-        return text[len(prefix) :]
-    else:
-        return text
-
-
-def print_traceback():
-    if logger.level == logging.DEBUG:
-        ex_type, ex, tb = sys.exc_info()
-        traceback.print_tb(tb)
-
-
-def create_log_in_log_group(compartment_id, log_group_id, auth, log_name=None):
-    """
-    Creates a log within a given log group
-    """
-    if not log_name:
-        log_name = f"log-{int(time.time())}-{uuid.uuid4()}"
-    log = OCILog(display_name=log_name,
-                 log_group_id=log_group_id,
-                 compartment_id=compartment_id,
-                 **auth).create()
-    logger.info(f"Created log with log OCID {log.id}")
-    return log.id

ads/opctl/operator/lowcode/__init__.py

@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# Copyright (c) 2023 Oracle and/or its affiliates.
-# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/

ads/opctl/operator/lowcode/anomaly/MLoperator

@@ -1,16 +0,0 @@
-type: anomaly
-version: v1
-conda_type: service
-name: Anomaly Detection Operator
-conda: anomaly_p310_cpu_x86_64_v1
-gpu: no
-keywords:
-  - Anomaly Detection
-backends:
-  - job
-  - operator.local
-description: |
-  Anomaly Detection is the identification of rare items, events, or observations in data that
-  differ significantly from the expectation. This can be used for several scenarios like asset
-  monitoring, maintenance and prognostic surveillance in industries such as utility,
-  aviation and manufacturing.