select-ai 1.0.0.dev4__py3-none-any.whl

select_ai/synthetic_data.py

@@ -0,0 +1,84 @@
+# -----------------------------------------------------------------------------
+# 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 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()

select_ai/vector_index.py

@@ -0,0 +1,542 @@
+# -----------------------------------------------------------------------------
+# 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 abc import ABC
+from dataclasses import dataclass
+from typing import AsyncGenerator, Iterator, Optional, Union
+
+import oracledb
+
+from select_ai import BaseProfile
+from select_ai._abc import SelectAIDataClass
+from select_ai._enums import StrEnum
+from select_ai.async_profile import AsyncProfile
+from select_ai.db import async_cursor, cursor
+from select_ai.errors import VectorIndexNotFoundError
+from select_ai.profile import Profile
+from select_ai.sql import (
+    GET_USER_VECTOR_INDEX_ATTRIBUTES,
+    LIST_USER_VECTOR_INDEXES,
+)
+
+
+class VectorDBProvider(StrEnum):
+    ORACLE = "oracle"
+
+
+class VectorDistanceMetric(StrEnum):
+    EUCLIDEAN = "EUCLIDEAN"
+    L2_SQUARED = "L2_SQUARED"
+    COSINE = "COSINE"
+    DOT = "DOT"
+    MANHATTAN = "MANHATTAN"
+    HAMMING = "HAMMING"
+
+
+@dataclass
+class VectorIndexAttributes(SelectAIDataClass):
+    """
+    Attributes of a vector index help to manage and configure the behavior of
+    the vector index.
+
+    :param int chunk_size: Text size of chunking the input data.
+    :param int chunk_overlap: Specifies the amount of overlapping
+     characters between adjacent chunks of text.
+    :param str location: Location of the object store.
+    :param int match_limit: Specifies the maximum number of results to return
+     in a vector search query
+    :param str object_storage_credential_name: Name of the credentials for
+     accessing object storage.
+    :param str profile_name: Name of the AI profile which is used for
+     embedding source data and user prompts.
+    :param int refresh_rate: Interval of updating data in the vector store.
+     The unit is minutes.
+    :param float similarity_threshold: Defines the minimum level of similarity
+     required for two items to be considered a match
+    :param VectorDistanceMetric vector_distance_metric: Specifies the type of
+     distance calculation used to compare vectors in a database
+    :param VectorDBProvider vector_db_provider: Name of the Vector database
+     provider. Default value is "oracle"
+    :param str  vector_db_endpoint: Endpoint to access the Vector database
+    :param str vector_db_credential_name: Name of the credentials for accessing
+     Vector database
+    :param int vector_dimension: Specifies the number of elements in each
+     vector within the vector store
+    :param str vector_table_name: Specifies the name of the table or collection
+     to store vector embeddings and chunked data
+    """
+
+    chunk_size: Optional[int] = 1024
+    chunk_overlap: Optional[int] = 128
+    location: Optional[str] = None
+    match_limit: Optional[int] = 5
+    object_storage_credential_name: Optional[str] = None
+    profile_name: Optional[str] = None
+    refresh_rate: Optional[int] = 1440
+    similarity_threshold: Optional[float] = 0
+    vector_distance_metric: Optional[VectorDistanceMetric] = (
+        VectorDistanceMetric.COSINE
+    )
+    vector_db_endpoint: Optional[str] = None
+    vector_db_credential_name: Optional[str] = None
+    vector_db_provider: Optional[VectorDBProvider] = None
+    vector_dimension: Optional[int] = None
+    vector_table_name: Optional[str] = None
+    pipeline_name: Optional[str] = None
+
+    def json(self, exclude_null=True):
+        attributes = self.dict(exclude_null=exclude_null)
+        attributes.pop("pipeline_name", None)
+        return json.dumps(attributes)
+
+    @classmethod
+    def create(cls, *, vector_db_provider: Optional[str] = None, **kwargs):
+        for subclass in cls.__subclasses__():
+            if subclass.vector_db_provider == vector_db_provider:
+                return subclass(**kwargs)
+        return cls(**kwargs)
+
+
+@dataclass
+class OracleVectorIndexAttributes(VectorIndexAttributes):
+    """Oracle specific vector index attributes"""
+
+    vector_db_provider: Optional[VectorDBProvider] = VectorDBProvider.ORACLE
+
+
+
+class _BaseVectorIndex(ABC):
+
+    def __init__(
+        self,
+        profile: BaseProfile = None,
+        index_name: Optional[str] = None,
+        description: Optional[str] = None,
+        attributes: Optional[VectorIndexAttributes] = None,
+    ):
+        """Initialize a Vector Index"""
+        self.profile = profile
+        self.index_name = index_name
+        self.attributes = attributes
+        self.description = description
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}(profile={self.profile}, "
+            f"index_name={self.index_name}, "
+            f"attributes={self.attributes}, description={self.description})"
+        )
+
+
+class VectorIndex(_BaseVectorIndex):
+    """
+    VectorIndex objects let you manage vector indexes
+
+    :param str index_name: The name of the vector index
+    :param str description: The description of the vector index
+    :param select_ai.VectorIndexAttributes attributes: The attributes of the vector index
+    """
+
+    @staticmethod
+    def _get_attributes(index_name: str) -> VectorIndexAttributes:
+        """Get attributes of a vector index
+
+        :return: select_ai.VectorIndexAttributes
+        :raises: VectorIndexNotFoundError
+        """
+        with cursor() as cr:
+            cr.execute(GET_USER_VECTOR_INDEX_ATTRIBUTES, index_name=index_name)
+            attributes = cr.fetchall()
+            if attributes:
+                post_processed_attributes = {}
+                for k, v in attributes:
+                    if isinstance(v, oracledb.LOB):
+                        post_processed_attributes[k] = v.read()
+                    else:
+                        post_processed_attributes[k] = v
+                return VectorIndexAttributes.create(
+                    **post_processed_attributes
+                )
+            else:
+                raise VectorIndexNotFoundError(index_name=index_name)
+
+    def create(self, replace=False):
+        """Create a vector index in the database and populates the index
+         with data from an object store bucket using an async scheduler job
+
+        :param bool replace: Replace vector index if it exists
+        :return: None
+        """
+
+        if self.attributes.profile_name is None:
+            self.attributes.profile_name = self.profile.profile_name
+
+        parameters = {
+            "index_name": self.index_name,
+            "attributes": self.attributes.json(),
+        }
+
+        if self.description:
+            parameters["description"] = self.description
+
+        with cursor() as cr:
+            try:
+                cr.callproc(
+                    "DBMS_CLOUD_AI.CREATE_VECTOR_INDEX",
+                    keyword_parameters=parameters,
+                )
+            except oracledb.DatabaseError as e:
+                (error,) = e.args
+                # If already exists and replace is True then drop and recreate
+                if "already exists" in error.message.lower() and replace:
+                    self.delete(force=True)
+                    cr.callproc(
+                        "DBMS_CLOUD_AI.CREATE_VECTOR_INDEX",
+                        keyword_parameters=parameters,
+                    )
+                else:
+                    raise
+        self.profile.set_attribute("vector_index_name", self.index_name)
+
+    def delete(
+        self, include_data: Optional[int] = True, force: Optional[int] = False
+    ):
+        """This procedure removes a vector store index
+
+        :param bool include_data: Indicates whether to delete
+         both the customer's vector store and vector index
+         along with the vector index object
+        :param bool force: Indicates whether to ignore errors
+         that occur if the vector index does not exist
+        :return: None
+        :raises: oracledb.DatabaseError
+        """
+        with cursor() as cr:
+            cr.callproc(
+                "DBMS_CLOUD_AI.DROP_VECTOR_INDEX",
+                keyword_parameters={
+                    "index_name": self.index_name,
+                    "include_data": include_data,
+                    "force": force,
+                },
+            )
+
+    def enable(self):
+        """This procedure enables or activates a previously disabled vector
+        index object. Generally, when you create a vector index, by default
+        it is enabled such that the AI profile can use it to perform indexing
+        and searching.
+
+        :return: None
+        :raises: oracledb.DatabaseError
+
+        """
+        with cursor() as cr:
+            cr.callproc(
+                "DBMS_CLOUD_AI.ENABLE_VECTOR_INDEX",
+                keyword_parameters={"index_name": self.index_name},
+            )
+
+    def disable(self):
+        """This procedure disables a vector index object in the current
+        database. When disabled, an AI profile cannot use the vector index,
+        and the system does not load data into the vector store as new data
+        is added to the object store and does not perform indexing, searching
+        or querying based on the index.
+
+        :return: None
+        :raises: oracledb.DatabaseError
+        """
+        with cursor() as cr:
+            cr.callproc(
+                "DBMS_CLOUD_AI.DISABLE_VECTOR_INDEX",
+                keyword_parameters={"index_name": self.index_name},
+            )
+
+    def set_attributes(
+        self,
+        attribute_name: str,
+        attribute_value: Union[str, int, float],
+        attributes: VectorIndexAttributes = None,
+    ):
+        """
+        This procedure updates an existing vector store index with a specified
+        value of the vector index attribute. You can specify a single attribute
+        or multiple attributes by passing an object of type
+        :class `VectorIndexAttributes`
+
+        :param str attribute_name: Custom attribute name
+        :param Union[str, int, float] attribute_value: Attribute Value
+        :param VectorIndexAttributes attributes: Specify multiple attributes
+         to update in a single API invocation
+        :return: None
+        :raises: oracledb.DatabaseError
+        """
+        if attribute_name and attribute_value and attributes:
+            raise ValueError(
+                "Either specify a single attribute using "
+                "attribute_name and attribute_value or "
+                "pass an object of type VectorIndexAttributes"
+            )
+
+        parameters = {"index_name": self.index_name}
+        if attributes:
+            parameters["attributes"] = attributes.json()
+            self.attributes = attributes
+        else:
+            setattr(self.attributes, attribute_name, attribute_value)
+            parameters["attributes_name"] = attribute_name
+            parameters["attributes_value"] = attribute_value
+
+        with cursor() as cr:
+            cr.callproc(
+                "DBMS_CLOUD_AI.UPDATE_VECTOR_INDEX",
+                keyword_parameters=parameters,
+            )
+
+    def get_attributes(self) -> VectorIndexAttributes:
+        """Get attributes of this vector index
+
+        :return: select_ai.VectorIndexAttributes
+        :raises: VectorIndexNotFoundError
+        """
+        return self._get_attributes(self.index_name)
+
+    @classmethod
+    def list(cls, index_name_pattern: str) -> Iterator["VectorIndex"]:
+        """List Vector Indexes
+
+        :param str index_name_pattern: Regular expressions can be used
+         to specify a pattern. Function REGEXP_LIKE is used to perform the
+         match
+
+        :return: Iterator[VectorIndex]
+        """
+        with cursor() as cr:
+            cr.execute(
+                LIST_USER_VECTOR_INDEXES,
+                index_name_pattern=index_name_pattern,
+            )
+            for row in cr.fetchall():
+                index_name = row[0]
+                description = row[1].read()  # Oracle.LOB
+                attributes = cls._get_attributes(index_name=index_name)
+                yield cls(
+                    index_name=index_name,
+                    description=description,
+                    attributes=attributes,
+                    profile=Profile(profile_name=attributes.profile_name),
+                )
+
+
+class AsyncVectorIndex(_BaseVectorIndex):
+    """
+    AsyncVectorIndex objects let you manage vector indexes
+    using async APIs. Use this for non-blocking concurrent
+    requests
+
+    :param str index_name: The name of the vector index
+    :param str description: The description of the vector index
+    :param VectorIndexAttributes attributes: The attributes of the vector index
+    """
+
+    @staticmethod
+    async def _get_attributes(index_name: str) -> VectorIndexAttributes:
+        """Get attributes of a vector index
+
+        :return: select_ai.VectorIndexAttributes
+        :raises: VectorIndexNotFoundError
+        """
+        async with async_cursor() as cr:
+            await cr.execute(
+                GET_USER_VECTOR_INDEX_ATTRIBUTES, index_name=index_name
+            )
+            attributes = await cr.fetchall()
+            if attributes:
+                post_processed_attributes = {}
+                for k, v in attributes:
+                    if isinstance(v, oracledb.AsyncLOB):
+                        post_processed_attributes[k] = await v.read()
+                    else:
+                        post_processed_attributes[k] = v
+                return VectorIndexAttributes.create(
+                    **post_processed_attributes
+                )
+            else:
+                raise VectorIndexNotFoundError(index_name=index_name)
+
+    async def create(self, replace: Optional[int] = False) -> None:
+        """Create a vector index in the database and populates it with data
+        from an object store bucket using an async scheduler job
+
+        :param bool replace: True to replace existing vector index
+
+        """
+
+        if self.attributes.profile_name is None:
+            self.attributes.profile_name = self.profile.profile_name
+        parameters = {
+            "index_name": self.index_name,
+            "attributes": self.attributes.json(),
+        }
+        if self.description:
+            parameters["description"] = self.description
+        async with async_cursor() as cr:
+            try:
+                await cr.callproc(
+                    "DBMS_CLOUD_AI.CREATE_VECTOR_INDEX",
+                    keyword_parameters=parameters,
+                )
+            except oracledb.DatabaseError as e:
+                (error,) = e.args
+                # If already exists and replace is True then drop and recreate
+                if "already exists" in error.message.lower() and replace:
+                    await self.delete(force=True)
+                    await cr.callproc(
+                        "DBMS_CLOUD_AI.CREATE_VECTOR_INDEX",
+                        keyword_parameters=parameters,
+                    )
+                else:
+                    raise
+
+        await self.profile.set_attribute("vector_index_name", self.index_name)
+
+    async def delete(
+        self, include_data: Optional[int] = True, force: Optional[int] = False
+    ) -> None:
+        """This procedure removes a vector store index.
+
+        :param bool include_data: Indicates whether to delete
+         both the customer's vector store and vector index
+         along with the vector index object.
+        :param bool force: Indicates whether to ignore errors
+         that occur if the vector index does not exist.
+        :return: None
+        :raises: oracledb.DatabaseError
+
+        """
+        async with async_cursor() as cr:
+            await cr.callproc(
+                "DBMS_CLOUD_AI.DROP_VECTOR_INDEX",
+                keyword_parameters={
+                    "index_name": self.index_name,
+                    "include_data": include_data,
+                    "force": force,
+                },
+            )
+
+    async def enable(self) -> None:
+        """This procedure enables or activates a previously disabled vector
+        index object. Generally, when you create a vector index, by default
+        it is enabled such that the AI profile can use it to perform indexing
+        and searching.
+
+        :return: None
+        :raises: oracledb.DatabaseError
+
+        """
+        async with async_cursor() as cr:
+            await cr.callproc(
+                "DBMS_CLOUD_AI.ENABLE_VECTOR_INDEX",
+                keyword_parameters={"index_name": self.index_name},
+            )
+
+    async def disable(self) -> None:
+        """This procedure disables a vector index object in the current
+        database. When disabled, an AI profile cannot use the vector index,
+        and the system does not load data into the vector store as new data
+        is added to the object store and does not perform indexing, searching
+        or querying based on the index.
+
+        :return: None
+        :raises: oracledb.DatabaseError
+        """
+        async with async_cursor() as cr:
+            await cr.callproc(
+                "DBMS_CLOUD_AI.DISABLE_VECTOR_INDEX",
+                keyword_parameters={"index_name": self.index_name},
+            )
+
+    async def set_attributes(
+        self,
+        attribute_name: str,
+        attribute_value: Union[str, int],
+        attributes: VectorIndexAttributes = None,
+    ) -> None:
+        """
+        This procedure updates an existing vector store index with a specified
+        value of the vector index attribute. You can specify a single attribute
+        or multiple attributes by passing an object of type
+        :class `VectorIndexAttributes`
+
+        :param str attribute_name: Custom attribute name
+        :param Union[str, int, float] attribute_value: Attribute Value
+        :param VectorIndexAttributes attributes: Specify multiple attributes
+         to update in a single API invocation
+        :return: None
+        :raises: oracledb.DatabaseError
+        """
+        if attribute_name and attribute_value and attributes:
+            raise ValueError(
+                "Either specify a single attribute using "
+                "attribute_name and attribute_value or "
+                "pass an object of type VectorIndexAttributes"
+            )
+        parameters = {"index_name": self.index_name}
+        if attributes:
+            self.attributes = attributes
+            parameters["attributes"] = attributes.json()
+        else:
+            setattr(self.attributes, attribute_name, attribute_value)
+            parameters["attributes_name"] = attribute_name
+            parameters["attributes_value"] = attribute_value
+
+        async with async_cursor() as cr:
+            await cr.callproc(
+                "DBMS_CLOUD_AI.UPDATE_VECTOR_INDEX",
+                keyword_parameters=parameters,
+            )
+
+    async def get_attributes(self) -> VectorIndexAttributes:
+        """Get attributes of a vector index
+
+        :return: select_ai.VectorIndexAttributes
+        :raises: VectorIndexNotFoundError
+        """
+        return await self._get_attributes(index_name=self.index_name)
+
+    @classmethod
+    async def list(
+        cls, index_name_pattern: str
+    ) -> AsyncGenerator[VectorIndex, None]:
+        """List Vector Indexes.
+
+        :param str index_name_pattern: Regular expressions can be used
+         to specify a pattern. Function REGEXP_LIKE is used to perform the
+         match
+        :return: AsyncGenerator[VectorIndex]
+
+        """
+        async with async_cursor() as cr:
+            await cr.execute(
+                LIST_USER_VECTOR_INDEXES,
+                index_name_pattern=index_name_pattern,
+            )
+            rows = await cr.fetchall()
+            for row in rows:
+                index_name = row[0]
+                description = await row[1].read()  # AsyncLOB
+                attributes = await cls._get_attributes(index_name=index_name)
+                yield VectorIndex(
+                    index_name=index_name,
+                    description=description,
+                    attributes=attributes,
+                    profile=await AsyncProfile(
+                        profile_name=attributes.profile_name
+                    ),
+                )

select_ai/version.py

@@ -0,0 +1,8 @@
+# -----------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------
+
+__version__ = "1.0.0.dev4"

select_ai-1.0.0.dev4.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: select_ai
+Version: 1.0.0.dev4
+Summary: Python API for Select AI
+Author-email: Abhishek Singh <abhishek.o.singh@oracle.com>
+Maintainer-email: Abhishek Singh <abhishek.o.singh@oracle.com>
+License-Expression: UPL-1.0
+Keywords: oracle,select-ai,adbs,autonomous database serverless
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Database
+Requires-Python: >=3.9
+License-File: LICENSE.txt
+Requires-Dist: oracledb
+Requires-Dist: pandas==2.2.3
+Dynamic: license-file

select_ai-1.0.0.dev4.dist-info/RECORD

@@ -0,0 +1,21 @@
+select_ai/__init__.py,sha256=JPm7f3IjEos8cbYr_hpwQKN6_sxG_gNgZXFqDpqxvrI,1281
+select_ai/_abc.py,sha256=PQZYYz2SKchPujRe7V58rmby6IlZ9bMnNpfOQYQ_EZk,2616
+select_ai/_enums.py,sha256=U0UavuE4pbRY-0-Qb8z-F7KfxU0YUfOgUahaSjDi0dU,416
+select_ai/action.py,sha256=s78uhi5HHCLbTN2S5tLDSswTLUl40FZ3nESLka8CfZk,592
+select_ai/admin.py,sha256=87OQEVmbFs6ftV4phLGHC1NGIWvD6x2Wu4Qic2DisRI,3375
+select_ai/async_profile.py,sha256=STAV1yLxCKJbYjFtW4uViAUa8j20lzQxYoToml435BM,16293
+select_ai/base_profile.py,sha256=YzromcmBdAmO9DX86L8_wwNtHYn8nPrHvUirYoxb5fA,6269
+select_ai/conversation.py,sha256=IulU5BHbBksk1zo4ppaR85-EVd0o7VUptkdHrBjKYeg,8770
+select_ai/db.py,sha256=G7yvE9UtUFpS46yXEv0_56lTqeve5r7mVGW7b8QmbEc,4484
+select_ai/errors.py,sha256=dMWdbsdWCpBPO1OD1zkDGUymJ37iBQDjEo9kb-PwirU,1470
+select_ai/profile.py,sha256=NX5-wP-HXBZJzyX9rlNElo3MZDC3A62r9QnPJge4k34,13705
+select_ai/provider.py,sha256=ycMMGMVix-4Pc54WOJXO6e2NvYZJYrMv7o-3tUKMlEc,5104
+select_ai/sql.py,sha256=_KQeBrHy9IXMI3N7PO064wp72gBzJGPfPMMNRprpxWs,2769
+select_ai/synthetic_data.py,sha256=lnjEIcUzr7lr2dO24OgxRhol-tiVOiKK-kEvFVJoiig,3078
+select_ai/vector_index.py,sha256=WnLP2QaqQUqT8BEs_nEyv02o-JfmuYx4V0pfUlflEz0,20156
+select_ai/version.py,sha256=MtG826c9kTe8me0o5cgLxZWIfgQxkiAmJIa1EyANzEI,348
+select_ai-1.0.0.dev4.dist-info/licenses/LICENSE.txt,sha256=_0VqOxSjO1hu6JexZDVzqUXSmzH1A53EOfyiJzXTBKc,1840
+select_ai-1.0.0.dev4.dist-info/METADATA,sha256=JXkOaJouXVgJT5qqNaBtD7uFQgXNjkINPDAobiiYc3k,1016
+select_ai-1.0.0.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+select_ai-1.0.0.dev4.dist-info/top_level.txt,sha256=u_QUAHDibro58Lvi_MU6a9Wc6VfQT8HEQm0cciMTP-c,10
+select_ai-1.0.0.dev4.dist-info/RECORD,,

select_ai-1.0.0.dev4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+