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

ads/feature_store/mixin/oci_feature_store.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+from types import MethodType
+
+from ads.common.decorator.utils import class_or_instance_method
+from oci.signer import AbstractBaseSigner
+
+# 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/
+
+import logging
+import email.utils
+import os
+import oci
+import feature_store_client.feature_store as fs
+
+logger = logging.getLogger(__name__)
+from ads.common.oci_mixin import OCIModelMixin
+import yaml
+
+
+try:
+    from yaml import CDumper as dumper
+    from yaml import CLoader as loader
+except:
+    from yaml import Dumper as dumper
+    from yaml import Loader as loader
+
+try:
+    from odsc_cli.utils import user_fs_config_loc, FsTemplate
+except ImportError:
+    pass
+
+
+class OCIFeatureStoreMixin(OCIModelMixin):
+    __mod_time = 0
+    __template: "FsTemplate" = None
+    FS_SERVICE_ENDPOINT = "fs_service_endpoint"
+    SERVICE_ENDPOINT = "service_endpoint"
+
+    @classmethod
+    def init_client(cls, **kwargs) -> fs.feature_store_client.FeatureStoreClient:
+        default_kwargs: dict = cls._get_auth().get("client_kwargs", {})
+
+        fs_service_endpoint = (
+            kwargs.get(cls.FS_SERVICE_ENDPOINT, None)
+            or kwargs.get(cls.SERVICE_ENDPOINT, None)
+            or default_kwargs.get(cls.FS_SERVICE_ENDPOINT, None)
+        )
+
+        if not fs_service_endpoint:
+            try:
+                mod_time = os.stat(user_fs_config_loc()).st_mtime
+                if mod_time > cls.__mod_time:
+                    with open(user_fs_config_loc()) as ccf:
+                        cls.__template = FsTemplate(yaml.load(ccf, Loader=loader))
+                    cls.__mod_time = mod_time
+            except NameError:
+                logger.info(
+                    "%s",
+                    "Feature store configuration helpers are missing. "
+                    "Support for reading service endpoint from config file is disabled",
+                )
+            except FileNotFoundError:
+                logger.info(
+                    "%s",
+                    "ODSC cli config for feature store was not found",
+                )
+                pass
+            if cls.__template:
+                fs_service_endpoint = cls.__template.service_endpoint
+
+        if fs_service_endpoint:
+            kwargs[cls.SERVICE_ENDPOINT] = fs_service_endpoint
+
+        client: fs.FeatureStoreClient = cls._init_client(
+            client=fs.FeatureStoreClient, **kwargs
+        )
+        signer: oci.Signer = client.base_client.signer
+        signer.do_request_sign = MethodType(fs_do_request_sign, signer)
+        return client
+
+    @property
+    def client(self) -> fs.feature_store_client.FeatureStoreClient:
+        return super().client
+
+    @class_or_instance_method
+    def list_resource(
+        cls, compartment_id: str = None, limit: int = 0, **kwargs
+    ) -> list:
+        """Generic method to list OCI resources
+
+        Parameters
+        ----------
+        compartment_id : str
+            Compartment ID of the OCI resources. Defaults to None.
+            If compartment_id is not specified,
+            the value of NB_SESSION_COMPARTMENT_OCID in environment variable will be used.
+        limit : int
+            The maximum number of items to return. Defaults to 0, All items will be returned
+        **kwargs :
+            Additional keyword arguments to filter the resource.
+            The kwargs are passed into OCI API.
+
+        Returns
+        -------
+        list
+            A list of OCI resources
+
+        Raises
+        ------
+        NotImplementedError
+            List method is not supported or implemented.
+
+        """
+        if limit:
+            items = cls._find_oci_method("list")(
+                cls.check_compartment_id(compartment_id), limit=limit, **kwargs
+            ).data.items
+        else:
+            items = oci.pagination.list_call_get_all_results(
+                cls._find_oci_method("list"),
+                cls.check_compartment_id(compartment_id),
+                **kwargs,
+            ).data
+        return [cls.from_oci_model(item) for item in items]
+
+
+def inject_missing_headers(request):
+    # Inject date, host, and content-type if missing
+    date = email.utils.formatdate(usegmt=True)
+    if request.path_url.startswith("/20230101"):
+        request.headers.setdefault("x-date", date)
+        request.headers.setdefault(
+            "path", request.method.lower() + " " + request.path_url
+        )
+    request.headers.setdefault("date", date)
+
+
+def fs_do_request_sign(self, request, enforce_content_headers=True):
+    inject_missing_headers(request)
+    do_request_sign = MethodType(AbstractBaseSigner.do_request_sign, self)
+    return do_request_sign(request, enforce_content_headers)
+
+    # inject_missing_headers_og(request, sign_body, enforce_content_headers)

ads/feature_store/model_details.py

@@ -0,0 +1,73 @@
+#!/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/
+
+from copy import deepcopy
+from typing import Dict, List
+
+from ads.jobs.builders.base import Builder
+
+
+class ModelDetails(Builder):
+    """Sets the model Details.
+    Methods
+    -------
+        with_items(self, items: List[str]) -> "ModelDetails"
+        Set the model ids associated with a dataset
+    """
+
+    CONST_ITEMS = "items"
+
+    attribute_map = {
+        CONST_ITEMS: "items",
+    }
+
+    def __init__(self, items: List[str] = None) -> None:
+        super().__init__()
+
+        if items is None:
+            items = []
+        if items:
+            self.with_items(items)
+
+    @property
+    def items(self) -> List[str]:
+        return self.get_spec(self.CONST_ITEMS)
+
+    @items.setter
+    def items(self, items: List[str]):
+        self.with_items(items)
+
+    def with_items(self, items: List[str]) -> "ModelDetails":
+        """Sets the model ids associated with dataset.
+
+        Parameters
+        ----------
+        items: List[str]
+            items array of model ids
+
+        Returns
+        -------
+        ModelDetails
+            The ModelDetails instance (self)
+        """
+        return self.set_spec(self.CONST_ITEMS, items)
+
+    @property
+    def kind(self) -> str:
+        """The kind of the object as showing in a YAML."""
+        return "model_details"
+
+    def to_dict(self) -> Dict:
+        """Serializes rule to a dictionary.
+
+        Returns
+        -------
+        dict
+            The rule resource serialized as a dictionary.
+        """
+
+        spec = deepcopy(self._spec)
+        return spec

ads/feature_store/query/filter.py

@@ -0,0 +1,266 @@
+#!/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/
+
+from ads.jobs.builders.base import Builder
+
+
+class Filter(Builder):
+    """
+    Represents a filter for a query.
+    """
+
+    CONST_FEATURE = "feature"
+    CONST_CONDITION = "condition"
+    CONST_VALUE = "value"
+
+    def __init__(self, feature, condition, value, **kwargs):
+        super().__init__(**kwargs)
+
+        self.with_feature(feature)
+        self.with_condition(condition)
+        self.with_value(value)
+
+    def with_feature(self, feature):
+        """
+        Sets the feature to filter on.
+
+        Args:
+            feature (str): The feature to filter on.
+        """
+        self.set_spec(self.CONST_FEATURE, feature)
+
+    @property
+    def feature(self):
+        return self.get_spec(self.CONST_FEATURE)
+
+    def with_condition(self, condition):
+        """
+        Sets the condition to apply to the feature.
+
+        Args:
+            condition (str): The condition to apply to the feature.
+        """
+        self.set_spec(self.CONST_CONDITION, condition)
+
+    @property
+    def condition(self):
+        return self.get_spec(self.CONST_CONDITION)
+
+    def with_value(self, value):
+        """
+        Sets the value to filter for.
+
+        Args:
+            value (str): The value to filter for.
+        """
+        self.set_spec(self.CONST_VALUE, value)
+
+    @property
+    def value(self):
+        return self.get_spec(self.CONST_VALUE)
+
+    def to_dict(self):
+        return {
+            "feature": self.feature,
+            "condition": self.condition,
+            "value": str(self.value),
+        }
+
+    def __and__(self, other):
+        """
+        Overloads the & operator to create a new Logic object.
+
+        Args:
+            other (Union[Filter, Logic]): The other object to combine with.
+
+        Returns:
+            Logic: The new Logic object.
+        """
+        if isinstance(other, Filter):
+            return Logic.And(left_f=self, right_f=other)
+        elif isinstance(other, Logic):
+            return Logic.And(left_f=self, right_l=other)
+        else:
+            raise TypeError(
+                "Operator `&` expected type `Filter` or `Logic`, got `{}`".format(
+                    type(other)
+                )
+            )
+
+    def __or__(self, other):
+        """
+        Overloads the | operator to create a new Logic object.
+
+        Args:
+            other (Union[Filter, Logic]): The other object to combine with.
+
+        Returns:
+            Logic: The new Logic object.
+        """
+        if isinstance(other, Filter):
+            return Logic.Or(left_f=self, right_f=other)
+        elif isinstance(other, Logic):
+            return Logic.Or(left_f=self, right_l=other)
+        else:
+            raise TypeError(
+                "Operator `|` expected type `Filter` or `Logic`, got `{}`".format(
+                    type(other)
+                )
+            )
+
+    def __repr__(self):
+        return f"Filter({self.feature!r}, {self.condition!r}, {self.value!r})"
+
+
+class Logic(Builder):
+    """
+    A class representing a logical operation on filters.
+    """
+
+    AND = "AND"
+    OR = "OR"
+    SINGLE = "SINGLE"
+
+    CONST_TYPE = "type"
+    CONST_LEFT_FILTER = "leftFilter"
+    CONST_RIGHT_FILTER = "rightFilter"
+    CONST_LEFT_LOGIC = "leftLogic"
+    CONST_RIGHT_LOGIC = "rightLogic"
+
+    def __init__(
+        self, type, left_f=None, right_f=None, left_l=None, right_l=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        self.with_type(type)
+        self.with_left_filter(left_f)
+        self.with_right_filter(right_f)
+        self.with_left_logic(left_l)
+        self.with_right_logic(right_l)
+
+    def with_type(self, type):
+        """
+        Sets the type of the logic.
+
+        Parameters:
+        -----------
+        type: str
+            A string representing the type of the logic to be performed.
+        """
+        self.set_spec(self.CONST_TYPE, type)
+
+    @property
+    def type(self):
+        return self.get_spec(self.CONST_TYPE)
+
+    def with_left_filter(self, left_filter):
+        """
+        Sets the left filter of the logic.
+
+        Parameters:
+        -----------
+        left_filter: Filter or None
+            The left filter of the logic.
+        """
+        self.set_spec(self.CONST_LEFT_FILTER, left_filter)
+
+    @property
+    def left_filter(self):
+        return self.get_spec(self.CONST_LEFT_FILTER)
+
+    def with_right_filter(self, right_filter):
+        """
+        Sets the right filter of the logic.
+
+        Parameters:
+        -----------
+        right_filter: Filter or None
+            The right filter of the logic.
+        """
+        self.set_spec(self.CONST_RIGHT_FILTER, right_filter)
+
+    @property
+    def right_filter(self):
+        return self.get_spec(self.CONST_RIGHT_FILTER)
+
+    def with_left_logic(self, left_logic):
+        """
+        Sets the left logic of the operation.
+
+        Parameters:
+        -----------
+        left_logic: Logic or None
+            The left logic of the operation.
+        """
+        self.set_spec(self.CONST_LEFT_LOGIC, left_logic)
+
+    @property
+    def left_logic(self):
+        return self.get_spec(self.CONST_LEFT_LOGIC)
+
+    def with_right_logic(self, right_logic):
+        """
+        Sets the right logic of the operation.
+
+        Parameters:
+        -----------
+        right_logic: Logic or None
+            The right logic of the operation.
+        """
+
+        self.set_spec(self.CONST_RIGHT_LOGIC, right_logic)
+
+    @property
+    def right_logic(self):
+        return self.get_spec(self.CONST_RIGHT_LOGIC)
+
+    def to_dict(self):
+        return {
+            "type": self.type,
+            "leftFilter": self.left_filter,
+            "rightFilter": self.right_filter,
+            "leftLogic": self.left_logic,
+            "rightLogic": self.right_logic,
+        }
+
+    @classmethod
+    def And(cls, left_f=None, right_f=None, left_l=None, right_l=None):
+        return cls(cls.AND, left_f, right_f, left_l, right_l)
+
+    @classmethod
+    def Or(cls, left_f=None, right_f=None, left_l=None, right_l=None):
+        return cls(cls.OR, left_f, right_f, left_l, right_l)
+
+    @classmethod
+    def Single(cls, left_f):
+        return cls(cls.SINGLE, left_f)
+
+    def __and__(self, other):
+        if isinstance(other, Filter):
+            return Logic.And(left_l=self, right_f=other)
+        elif isinstance(other, Logic):
+            return Logic.And(left_l=self, right_l=other)
+        else:
+            raise TypeError(
+                "Operator `&` expected type `Filter` or `Logic`, got `{}`".format(
+                    type(other)
+                )
+            )
+
+    def __or__(self, other):
+        if isinstance(other, Filter):
+            return Logic.Or(left_l=self, right_f=other)
+        elif isinstance(other, Logic):
+            return Logic.Or(left_l=self, right_l=other)
+        else:
+            raise TypeError(
+                "Operator `|` expected type `Filter` or `Logic`, got `{}`".format(
+                    type(other)
+                )
+            )
+
+    def __repr__(self):
+        return f"Logic({self.type!r}, {self.left_filter!r}, {self.right_filter!r}, {self.left_logic!r}, {self.right_logic!r}) "