select-ai 1.0.0b1__py3-none-any.whl

select_ai/provider.py

@@ -0,0 +1,288 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2025, Oracle and/or its affiliates.
+#
+# Licensed under the Universal Permissive License v 1.0 as shown at
+# http://oss.oracle.com/licenses/upl.
+# -----------------------------------------------------------------------------
+
+from dataclasses import dataclass
+from typing import List, Optional, Union
+
+from select_ai._abc import SelectAIDataClass
+
+from .db import async_cursor, cursor
+from .sql import (
+    DISABLE_AI_PROFILE_DOMAIN_FOR_USER,
+    ENABLE_AI_PROFILE_DOMAIN_FOR_USER,
+    GRANT_PRIVILEGES_TO_USER,
+    REVOKE_PRIVILEGES_FROM_USER,
+)
+
+OPENAI = "openai"
+COHERE = "cohere"
+AZURE = "azure"
+OCI = "oci"
+GOOGLE = "google"
+ANTHROPIC = "anthropic"
+HUGGINGFACE = "huggingface"
+AWS = "aws"
+
+
+@dataclass
+class Provider(SelectAIDataClass):
+    """
+    Base class for AI Provider
+
+    To create an object of Provider class, use any one of the concrete AI
+    provider implementations
+
+    :param str embedding_model: The embedding model, also known as a
+     transformer. Depending on the AI provider, the supported embedding models
+     vary
+    :param str model: The name of the LLM being used to generate
+     responses
+    :param str provider_name: The name of the provider being used
+    :param str provider_endpoint: Endpoint URL of the AI provider being used
+    :param str region: The cloud region of the Gen AI cluster
+
+    """
+
+    embedding_model: Optional[str] = None
+    model: Optional[str] = None
+    provider_name: Optional[str] = None
+    provider_endpoint: Optional[str] = None
+    region: Optional[str] = None
+
+    @classmethod
+    def create(cls, *, provider_name: Optional[str] = None, **kwargs):
+        for subclass in cls.__subclasses__():
+            if subclass.provider_name == provider_name:
+                return subclass(**kwargs)
+        return cls(**kwargs)
+
+    @classmethod
+    def key_alias(cls, k):
+        return {"provider": "provider_name", "provider_name": "provider"}.get(
+            k, k
+        )
+
+    @classmethod
+    def keys(cls):
+        return {
+            "provider",
+            "provider_name",
+            "embedding_model",
+            "model",
+            "region",
+            "provider_endpoint",
+            "azure_deployment_name",
+            "azure_embedding_deployment_name",
+            "azure_resource_name",
+            "oci_apiformat",
+            "oci_compartment_id",
+            "oci_endpoint_id",
+            "oci_runtimetype",
+            "aws_apiformat",
+        }
+
+
+@dataclass
+class AzureProvider(Provider):
+    """
+    Azure specific attributes
+
+    :param str azure_deployment_name: Name of the Azure OpenAI Service
+     deployed model.
+    :param str azure_embedding_deployment_name: Name of the Azure OpenAI
+     deployed embedding model.
+    :param str azure_resource_name: Name of the Azure OpenAI Service resource
+    """
+
+    provider_name: str = AZURE
+    azure_deployment_name: Optional[str] = None
+    azure_embedding_deployment_name: Optional[str] = None
+    azure_resource_name: Optional[str] = None
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.provider_endpoint = f"{self.azure_resource_name}.openai.azure.com"
+
+
+@dataclass
+class OpenAIProvider(Provider):
+    """
+    OpenAI specific attributes
+    """
+
+    provider_name: str = OPENAI
+    provider_endpoint: Optional[str] = "api.openai.com"
+
+
+@dataclass
+class OCIGenAIProvider(Provider):
+    """
+    OCI Gen AI specific attributes
+
+    :param str oci_apiformat: Specifies the format in which the API expects
+     data to be sent and received. Supported values are 'COHERE' and 'GENERIC'
+    :param str oci_compartment_id: Specifies the OCID of the compartment you
+     are permitted to access when calling the OCI Generative AI service
+    :param str oci_endpoint_id: This attributes indicates the endpoint OCID
+     of the Oracle dedicated AI hosting cluster
+    :param str oci_runtimetype: This attribute indicates the runtime type of
+     the provided model. The supported values are 'COHERE' and 'LLAMA'
+    """
+
+    provider_name: str = OCI
+    oci_apiformat: Optional[str] = None
+    oci_compartment_id: Optional[str] = None
+    oci_endpoint_id: Optional[str] = None
+    oci_runtimetype: Optional[str] = None
+
+
+@dataclass
+class CohereProvider(Provider):
+    """
+    Cohere AI specific attributes
+    """
+
+    provider_name: str = COHERE
+    provider_endpoint = "api.cohere.ai"
+
+
+@dataclass
+class GoogleProvider(Provider):
+    """
+    Google AI specific attributes
+    """
+
+    provider_name: str = GOOGLE
+    provider_endpoint = "generativelanguage.googleapis.com"
+
+
+@dataclass
+class HuggingFaceProvider(Provider):
+    """
+    HuggingFace specific attributes
+    """
+
+    provider_name: str = HUGGINGFACE
+    provider_endpoint = "api-inference.huggingface.co"
+
+
+@dataclass
+class AWSProvider(Provider):
+    """
+    AWS specific attributes
+    """
+
+    provider_name: str = AWS
+    aws_apiformat: Optional[str] = None
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.provider_endpoint = f"bedrock-runtime.{self.region}.amazonaws.com"
+
+
+@dataclass
+class AnthropicProvider(Provider):
+    """
+    Anthropic specific attributes
+    """
+
+    provider_name: str = ANTHROPIC
+    provider_endpoint = "api.anthropic.com"
+
+
+async def async_enable_provider(
+    users: Union[str, List[str]], provider_endpoint: str = None
+):
+    """
+    Async API to enable AI profile for database users.
+
+    This method grants execute privilege on the packages DBMS_CLOUD,
+    DBMS_CLOUD_AI and DBMS_CLOUD_PIPELINE. It  also enables the database
+    user to invoke the AI Provider (LLM) endpoint
+
+    """
+    if isinstance(users, str):
+        users = [users]
+
+    async with async_cursor() as cr:
+        for user in users:
+            await cr.execute(GRANT_PRIVILEGES_TO_USER.format(user))
+            if provider_endpoint:
+                await cr.execute(
+                    ENABLE_AI_PROFILE_DOMAIN_FOR_USER,
+                    user=user,
+                    host=provider_endpoint,
+                )
+
+
+async def async_disable_provider(
+    users: Union[str, List[str]], provider_endpoint: str = None
+):
+    """
+    Async API to disable  AI profile for database users
+
+    Disables AI provider for the user. This method revokes execute privilege
+    on the packages DBMS_CLOUD, DBMS_CLOUD_AI and DBMS_CLOUD_PIPELINE. It
+    also disables the user to invoke the AI Provider (LLM) endpoint
+    """
+    if isinstance(users, str):
+        users = [users]
+
+    async with async_cursor() as cr:
+        for user in users:
+            await cr.execute(REVOKE_PRIVILEGES_FROM_USER.format(user))
+            if provider_endpoint:
+                await cr.execute(
+                    DISABLE_AI_PROFILE_DOMAIN_FOR_USER,
+                    user=user,
+                    host=provider_endpoint,
+                )
+
+
+def enable_provider(
+    users: Union[str, List[str]], provider_endpoint: str = None
+):
+    """
+    Enables AI profile for the user. This method grants execute privilege
+    on the packages DBMS_CLOUD, DBMS_CLOUD_AI and DBMS_CLOUD_PIPELINE. It
+    also enables the user to invoke the AI Provider (LLM) endpoint
+    """
+    if isinstance(users, str):
+        users = [users]
+
+    with cursor() as cr:
+        for user in users:
+            cr.execute(GRANT_PRIVILEGES_TO_USER.format(user))
+            if provider_endpoint:
+                cr.execute(
+                    ENABLE_AI_PROFILE_DOMAIN_FOR_USER,
+                    user=user,
+                    host=provider_endpoint,
+                )
+
+
+def disable_provider(
+    users: Union[str, List[str]], provider_endpoint: str = None
+):
+    """
+    Disables AI provider for the user. This method revokes execute privilege
+    on the packages DBMS_CLOUD, DBMS_CLOUD_AI and DBMS_CLOUD_PIPELINE. It
+    also disables the user to invoke the AI(LLM) endpoint
+
+    """
+    if isinstance(users, str):
+        users = [users]
+
+    with cursor() as cr:
+        for user in users:
+            cr.execute(REVOKE_PRIVILEGES_FROM_USER.format(user))
+            if provider_endpoint:
+                cr.execute(
+                    DISABLE_AI_PROFILE_DOMAIN_FOR_USER,
+                    user=user,
+                    host=provider_endpoint,
+                )

select_ai/sql.py

@@ -0,0 +1,105 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2025, Oracle and/or its affiliates.
+#
+# Licensed under the Universal Permissive License v 1.0 as shown at
+# http://oss.oracle.com/licenses/upl.
+# -----------------------------------------------------------------------------
+
+GRANT_PRIVILEGES_TO_USER = """
+DECLARE
+    TYPE array_t IS VARRAY(3) OF VARCHAR2(60);
+    v_packages array_t;
+BEGIN
+    v_packages := array_t(
+        'DBMS_CLOUD', 'DBMS_CLOUD_AI', 'DBMS_CLOUD_PIPELINE'
+    );
+    FOR i in 1..v_packages.count LOOP
+        EXECUTE IMMEDIATE
+            'GRANT EXECUTE ON ' || v_packages(i) || ' TO {0}';
+    END LOOP;
+END;
+"""
+
+REVOKE_PRIVILEGES_FROM_USER = """
+DECLARE
+    TYPE array_t IS VARRAY(3) OF VARCHAR2(60);
+    v_packages array_t;
+BEGIN
+    v_packages := array_t(
+        'DBMS_CLOUD', 'DBMS_CLOUD_AI', 'DBMS_CLOUD_PIPELINE'
+    );
+    FOR i in 1..v_packages.count LOOP
+        EXECUTE IMMEDIATE
+            'REVOKE EXECUTE ON ' || v_packages(i) || ' FROM {0}';
+    END LOOP;
+END;
+"""
+
+ENABLE_AI_PROFILE_DOMAIN_FOR_USER = """
+BEGIN
+    DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
+         host => :host,
+         ace  => xs$ace_type(privilege_list => xs$name_list('http'),
+                             principal_name => :user,
+                             principal_type => xs_acl.ptype_db)
+   );
+END;
+"""
+
+DISABLE_AI_PROFILE_DOMAIN_FOR_USER = """
+BEGIN
+    DBMS_NETWORK_ACL_ADMIN.REMOVE_HOST_ACE(
+         host => :host,
+         ace  => xs$ace_type(privilege_list => xs$name_list('http'),
+                             principal_name => :user,
+                             principal_type => xs_acl.ptype_db)
+   );
+END;
+"""
+
+GET_USER_AI_PROFILE_ATTRIBUTES = """
+SELECT attribute_name, attribute_value
+FROM USER_CLOUD_AI_PROFILE_ATTRIBUTES
+WHERE profile_name = :profile_name
+"""
+
+GET_USER_AI_PROFILE = """
+SELECT profile_name, description
+FROM  USER_CLOUD_AI_PROFILES
+WHERE profile_name = :profile_name
+"""
+
+
+LIST_USER_AI_PROFILES = """
+SELECT profile_name, description
+FROM USER_CLOUD_AI_PROFILES
+WHERE REGEXP_LIKE(profile_name, :profile_name_pattern, 'i')
+"""
+
+LIST_USER_VECTOR_INDEXES = """
+SELECT v.index_name, v.description
+FROM USER_CLOUD_VECTOR_INDEXES v
+WHERE REGEXP_LIKE(v.index_name, :index_name_pattern, 'i')
+"""
+
+GET_USER_VECTOR_INDEX_ATTRIBUTES = """
+SELECT attribute_name, attribute_value
+FROM USER_CLOUD_VECTOR_INDEX_ATTRIBUTES
+WHERE INDEX_NAME = :index_name
+"""
+
+LIST_USER_CONVERSATIONS = """
+SELECT conversation_id,
+       conversation_title,
+       description,
+       retention_days
+from USER_CLOUD_AI_CONVERSATIONS
+"""
+
+GET_USER_CONVERSATION_ATTRIBUTES = """
+SELECT conversation_title,
+       description,
+       retention_days
+from USER_CLOUD_AI_CONVERSATIONS
+WHERE conversation_id = :conversation_id
+"""

select_ai/synthetic_data.py

@@ -0,0 +1,90 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2025, Oracle and/or its affiliates.
+#
+# Licensed under the Universal Permissive License v 1.0 as shown at
+# http://oss.oracle.com/licenses/upl.
+# -----------------------------------------------------------------------------
+
+import json
+from dataclasses import dataclass
+from typing import List, Mapping, Optional
+
+from select_ai._abc import SelectAIDataClass
+
+
+@dataclass
+class SyntheticDataParams(SelectAIDataClass):
+    """Optional parameters to control generation of synthetic data
+
+    :param int sample_rows: number of rows from the table to use as a sample
+     to guide the LLM in data generation
+
+    :param bool table_statistics: Enable or disable the use of table
+     statistics information. Default value is False
+
+    :param str priority: Assign a priority value that defines the number of
+     parallel requests sent to the LLM for generating synthetic data.
+     Tasks with a higher priority will consume more database resources and
+     complete faster. Possible values are: HIGH, MEDIUM, LOW
+
+    :param bool comments: Enable or disable sending comments to the LLM to
+     guide data generation. Default value is False
+
+    """
+
+    sample_rows: Optional[int] = None
+    table_statistics: Optional[bool] = False
+    priority: Optional[str] = "HIGH"
+    comments: Optional[bool] = False
+
+
+@dataclass
+class SyntheticDataAttributes(SelectAIDataClass):
+    """Attributes to control generation of synthetic data
+
+    :param str object_name: Table name to populate synthetic data
+    :param List[Mapping] object_list: Use this to generate synthetic data
+     on multiple tables
+    :param str owner_name: Database user who owns the referenced object.
+     Default value is connected user's schema
+    :param int record_count: Number of records to generate
+    :param str user_prompt: User prompt to guide generation of synthetic data
+     For e.g. "the release date for the movies should be in 2019"
+
+    """
+
+    object_name: Optional[str] = None
+    object_list: Optional[List[Mapping]] = None
+    owner_name: Optional[str] = None
+    params: Optional[SyntheticDataParams] = None
+    record_count: Optional[int] = None
+    user_prompt: Optional[str] = None
+
+    def __post_init__(self):
+        if self.params and not isinstance(self.params, SyntheticDataParams):
+            raise TypeError(
+                "'params' must be an object of" " type SyntheticDataParams'"
+            )
+
+    def dict(self, exclude_null=True):
+        attributes = {}
+        for k, v in self.__dict__.items():
+            if v is not None or not exclude_null:
+                if isinstance(v, SyntheticDataParams):
+                    attributes[k] = v.json(exclude_null=exclude_null)
+                elif isinstance(v, List):
+                    attributes[k] = json.dumps(v)
+                else:
+                    attributes[k] = v
+        return attributes
+
+    def prepare(self):
+        if self.object_name and self.object_list:
+            raise ValueError("Both object_name and object_list cannot be set")
+
+        if not self.object_name and not self.object_list:
+            raise ValueError(
+                "One of object_name and object_list should be set"
+            )
+
+        return self.dict()