select-ai 1.2.0rc3__py3-none-any.whl

select_ai/__init__.py

@@ -0,0 +1,66 @@
+# -----------------------------------------------------------------------------
+# 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 .action import Action
+from .async_profile import AsyncProfile
+from .base_profile import BaseProfile, ProfileAttributes
+from .conversation import (
+    AsyncConversation,
+    Conversation,
+    ConversationAttributes,
+)
+from .credential import (
+    async_create_credential,
+    async_delete_credential,
+    create_credential,
+    delete_credential,
+)
+from .db import (
+    async_connect,
+    async_cursor,
+    async_disconnect,
+    async_is_connected,
+    connect,
+    cursor,
+    disconnect,
+    is_connected,
+)
+from .errors import *
+from .privilege import (
+    async_grant_http_access,
+    async_grant_privileges,
+    async_revoke_http_access,
+    async_revoke_privileges,
+    grant_http_access,
+    grant_privileges,
+    revoke_http_access,
+    revoke_privileges,
+)
+from .profile import Profile
+from .provider import (
+    AnthropicProvider,
+    AWSProvider,
+    AzureProvider,
+    CohereProvider,
+    GoogleProvider,
+    HuggingFaceProvider,
+    OCIGenAIProvider,
+    OpenAIProvider,
+    Provider,
+)
+from .synthetic_data import (
+    SyntheticDataAttributes,
+    SyntheticDataParams,
+)
+from .vector_index import (
+    AsyncVectorIndex,
+    OracleVectorIndexAttributes,
+    VectorDistanceMetric,
+    VectorIndex,
+    VectorIndexAttributes,
+)
+from .version import __version__ as __version__

select_ai/_abc.py

@@ -0,0 +1,82 @@
+# -----------------------------------------------------------------------------
+# 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
+import typing
+from abc import ABC
+from dataclasses import dataclass, fields
+from typing import Any, List, Mapping
+
+__all__ = ["SelectAIDataClass"]
+
+
+def _bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int):
+        return bool(value)
+    if value.lower() in ("yes", "true", "t", "y", "1"):
+        return True
+    elif value.lower() in ("no", "false", "f", "n", "0"):
+        return False
+    else:
+        raise ValueError(f"Invalid boolean value: {value}")
+
+
+def _is_json(field, value) -> bool:
+    if field.type in (
+        typing.List[Mapping],
+        typing.Optional[Mapping],
+        typing.Optional[List[str]],
+        typing.Optional[List[typing.Mapping]],
+    ) and isinstance(value, (str, bytes, bytearray)):
+        return True
+    return False
+
+
+@dataclass
+class SelectAIDataClass(ABC):
+    """SelectAIDataClass is an abstract container for all data
+    models defined in the select_ai Python module
+    """
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    @classmethod
+    def keys(cls):
+        return set([field.name for field in fields(cls)])
+
+    def dict(self, exclude_null=True):
+        attributes = {}
+        for k, v in self.__dict__.items():
+            if v is not None or not exclude_null:
+                attributes[k] = v
+        return attributes
+
+    def json(self, exclude_null=True):
+        return json.dumps(self.dict(exclude_null=exclude_null))
+
+    def __post_init__(self):
+        for field in fields(self):
+            value = getattr(self, field.name)
+            if value is not None:
+                if field.type is typing.Optional[int]:
+                    setattr(self, field.name, int(value))
+                elif field.type is typing.Optional[str]:
+                    setattr(self, field.name, str(value))
+                elif field.type is typing.Optional[bool]:
+                    setattr(self, field.name, _bool(value))
+                elif field.type is typing.Optional[float]:
+                    setattr(self, field.name, float(value))
+                elif _is_json(field, value):
+                    setattr(self, field.name, json.loads(value))
+                else:
+                    setattr(self, field.name, value)

select_ai/_enums.py

@@ -0,0 +1,14 @@
+# -----------------------------------------------------------------------------
+# 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 enum
+
+
+class StrEnum(str, enum.Enum):
+
+    def __str__(self):
+        return self.value

select_ai/_validations.py

@@ -0,0 +1,123 @@
+# -----------------------------------------------------------------------------
+# 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 inspect
+from collections.abc import Mapping, Sequence, Set
+from functools import wraps
+from typing import Any, get_args, get_origin, get_type_hints
+
+NoneType = type(None)
+
+
+def _match(value, annot) -> bool:
+    """Recursively validate value against a typing annotation."""
+    if annot is Any:
+        return True
+
+    origin = get_origin(annot)
+    args = get_args(annot)
+
+    # Handle Annotated[T, ...] → treat as T
+    if origin is getattr(__import__("typing"), "Annotated", None):
+        annot = args[0]
+        origin = get_origin(annot)
+        args = get_args(annot)
+
+    # Optional[T] is Union[T, NoneType]
+    if origin is getattr(__import__("typing"), "Union", None):
+        return any(_match(value, a) for a in args)
+
+    # Literal[…]
+    if origin is getattr(__import__("typing"), "Literal", None):
+        return any(value == lit for lit in args)
+
+    # Tuple cases
+    if origin is tuple:
+        if not isinstance(value, tuple):
+            return False
+        if len(args) == 2 and args[1] is Ellipsis:
+            # tuple[T, ...]
+            return all(_match(v, args[0]) for v in value)
+        if len(args) != len(value):
+            return False
+        return all(_match(v, a) for v, a in zip(value, args))
+
+    # Mappings (dict-like)
+    if origin in (dict, Mapping):
+        if not isinstance(value, Mapping):
+            return False
+        k_annot, v_annot = args if args else (Any, Any)
+        return all(
+            _match(k, k_annot) and _match(v, v_annot) for k, v in value.items()
+        )
+
+    # Sequences (list, Sequence) – but not str/bytes
+    if origin in (list, Sequence):
+        if isinstance(value, (str, bytes)):
+            return False
+        if not isinstance(value, Sequence):
+            return False
+        elem_annot = args[0] if args else Any
+        return all(_match(v, elem_annot) for v in value)
+
+    # Sets
+    if origin in (set, frozenset, Set):
+        if not isinstance(value, (set, frozenset)):
+            return False
+        elem_annot = args[0] if args else Any
+        return all(_match(v, elem_annot) for v in value)
+
+    # Fall back to normal isinstance for non-typing classes
+    if isinstance(annot, type):
+        return isinstance(value, annot)
+
+    # If annot is a typing alias like 'list' without args
+    if origin is not None:
+        # Treat bare containers as accepting anything inside
+        return isinstance(value, origin)
+
+    # Unknown/unsupported typing form: accept conservatively
+    return True
+
+
+def enforce_types(func):
+    # Resolve ForwardRefs using function globals (handles "User" as a string, etc.)
+    hints = get_type_hints(
+        func, globalns=func.__globals__, include_extras=True
+    )
+    sig = inspect.signature(func)
+
+    def _check(bound):
+        for name, val in bound.arguments.items():
+            if name in hints:
+                annot = hints[name]
+                if not _match(val, annot):
+                    raise TypeError(
+                        f"Argument '{name}' failed type check: expected {annot!r}, "
+                        f"got {type(val).__name__} -> {val!r}"
+                    )
+
+    if inspect.iscoroutinefunction(func):
+
+        @wraps(func)
+        async def aw(*args, **kwargs):
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            _check(bound)
+            return await func(*args, **kwargs)
+
+        return aw
+    else:
+
+        @wraps(func)
+        def w(*args, **kwargs):
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            _check(bound)
+            return func(*args, **kwargs)
+
+        return w

select_ai/action.py

@@ -0,0 +1,23 @@
+# -----------------------------------------------------------------------------
+# 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 select_ai._enums import StrEnum
+
+__all__ = ["Action"]
+
+
+class Action(StrEnum):
+    """Supported Select AI actions"""
+
+    RUNSQL = "runsql"
+    SHOWSQL = "showsql"
+    EXPLAINSQL = "explainsql"
+    NARRATE = "narrate"
+    CHAT = "chat"
+    SHOWPROMPT = "showprompt"
+    FEEDBACK = "feedback"
+    SUMMARIZE = "summarize"

select_ai/agent/__init__.py

@@ -0,0 +1,25 @@
+# -----------------------------------------------------------------------------
+# 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 .core import Agent, AgentAttributes, AsyncAgent
+from .task import AsyncTask, Task, TaskAttributes
+from .team import AsyncTeam, Team, TeamAttributes
+from .tool import (
+    AsyncTool,
+    EmailNotificationToolParams,
+    HTTPToolParams,
+    HumanToolParams,
+    RAGToolParams,
+    SlackNotificationToolParams,
+    SQLToolParams,
+    Tool,
+    ToolAttributes,
+    ToolParams,
+    ToolType,
+    WebSearchToolParams,
+)