sinapsis-aperturedb 0.1.0__py3-none-any.whl

sinapsis_aperturedb/templates/aperturedb_client_base.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from typing import Any, Tuple
+
+from aperturedb import Connector
+from pydantic import Field
+from sinapsis_core.data_containers.data_packet import DataContainer
+from sinapsis_core.template_base import Template
+from sinapsis_core.template_base.base_models import (
+    OutputTypes,
+    TemplateAttributes,
+    TemplateAttributeType,
+    UIPropertiesMetadata,
+)
+
+from sinapsis_aperturedb.helpers.aperturedb_env_var_keys import (
+    APERTUREDB_API_KEY,
+    APERTUREDB_HOST,
+    APERTUREDB_PASSWORD,
+    APERTUREDB_PORT,
+    APERTUREDB_USER,
+)
+from sinapsis_aperturedb.helpers.query_base_models.base import (
+    ConnectionParams,
+    Query,
+    QueryParameters,
+    Response,
+)
+from sinapsis_aperturedb.helpers.tags import Tags
+
+
+class ApertureDBClientQueryAttributes(TemplateAttributes):
+    """Attributes for ApertureDBCommandBase template.
+
+    connect_with_key: Controls whether to connect with APERTUREDB_KEY or with host, user and password
+    input_keys: Instance names from command templates
+    use_ssl: Set to false only to use Community Edition local docker for experiments.
+    """
+
+    connect_with_key: bool = False
+    connection_params: ConnectionParams = Field(default_factory=dict)
+
+
+class ApertureDBClientQuery(Template):
+    """Base Template to connect to an ApertureDB server and run queries.
+
+    Generate a client connection to an ApertureDB server and run queries set through
+    previous ApertureDB command templates.
+    """
+
+    AttributesBaseModel = ApertureDBClientQueryAttributes
+    UIProperties = UIPropertiesMetadata(
+        category="ApertureDB",
+        output_type=OutputTypes.TEXT,
+        tags=[Tags.JSON, Tags.DATABASE],
+    )
+    COMMAND: str
+
+    def __init__(self, attributes: TemplateAttributeType) -> None:
+        super().__init__(attributes)
+        self.connect_to_host()
+
+    def connect_to_host(self) -> None:
+        """Connect to an ApertureDB server with a key or with user and password."""
+        if isinstance(self.attributes.connection_params, dict) and not self.attributes.connection_params:
+            self.attributes.connection_params = ConnectionParams()
+
+        conn_params = self.attributes.connection_params.get_connection_params()
+        if isinstance(conn_params, dict) and not conn_params:
+            self.attributes.connection_params = ConnectionParams(
+                host=APERTUREDB_HOST,
+                user=APERTUREDB_USER,
+                port=APERTUREDB_PORT,
+                password=APERTUREDB_PASSWORD,
+                key=APERTUREDB_API_KEY,
+                use_ssl=False,
+            )
+
+        if self.attributes.connect_with_key:
+            self.client = Connector.Connector(key=self.attributes.connection_params.key)
+        else:
+            self.client = Connector.Connector(
+                host=self.attributes.connection_params.host,
+                user=self.attributes.connection_params.user,
+                port=self.attributes.connection_params.port,
+                password=self.attributes.connection_params.password,
+                use_ssl=self.attributes.connection_params.use_ssl,
+            )
+
+    def get_query_response(
+        self, query: Tuple[list[dict[str, Any]], list[bytes]] | list[dict[str, Any]]
+    ) -> dict[str, Any]:
+        """Execute a query against the ApertureDB server.
+
+        Args:
+            query (Tuple[list[dict[str, Any]], list[bytes]] | list[dict[str, Any]]):
+                Query to execute, either as a list of query dicts or a tuple of query dicts and blobs.
+
+        Returns:
+            dict[str, Any]: Response from the ApertureDB server.
+        """
+        response = self.client.query(query)
+        return response
+
+    def add_query_response_to_data_container(
+        self, responses: list[Response], blobs: list[bytes], container: DataContainer
+    ) -> DataContainer:
+        """Format the received response from ApertureDB server as generic data.
+
+        Args:
+            responses (list[Response]): list of response base models
+            blobs (list[bytes]): list of output blobs as bytes objects
+            container (DataContainer): data container
+
+        Returns:
+            DataContainer: data container with response data
+        """
+        _ = blobs
+        responses_output = []
+        for response in responses:
+            response_dict = response.format_response_dict()
+            if response.status == -1:
+                self.logger.error(response_dict)
+            responses_output.append(response_dict)
+        self._set_generic_data(container, responses_output)
+        return container
+
+    @staticmethod
+    def format_response(response_dict: dict[str, Any]) -> Response:
+        """Format the received response dictionary as base model.
+
+        Possible response formats are:
+        {"status": ...}
+        {"<Command (AddEntity, UpdateEntity,...)>": {"status": ....}}
+
+        Args:
+            response_dict (dict[str, Any]): received response dict
+
+        Returns:
+            Response: response base model
+        """
+        if "status" in response_dict:
+            return Response(**response_dict)
+        command_key, command_dict = response_dict.popitem()
+        return Response(command=command_key, **command_dict)
+
+    def preprocess_response(self, response_output: Any, blob_output: Any) -> Tuple[list[Response], list[bytes]]:
+        """Process the received response and format it as Response base models.
+
+        Responses can vary, depending on results from queries, so processing is
+        required before adding to container.
+
+        Args:
+            response_output (Any): Responses received from server
+            blob_output (Any): Blobs received from server
+
+        Returns:
+            Tuple[list[Response], list[bytes]]: Formatted responses and blobs
+        """
+        responses: list[Response] = []
+        blobs: list[bytes] = []
+
+        if isinstance(response_output, list):
+            responses = [self.format_response(r) for r in response_output if isinstance(r, dict)]
+        elif isinstance(response_output, dict):
+            responses = [self.format_response(response_output)]
+
+        if isinstance(blob_output, list):
+            blobs = [blob for blob in blob_output if isinstance(blob, bytes)]
+        elif isinstance(blob_output, bytes):
+            blobs = [blob_output]
+
+        return responses, blobs
+
+    def get_command_parameters(self) -> QueryParameters:
+        """Get query parameters for the command.
+
+        Returns:
+            QueryParameters: Query parameters object.
+        """
+        _ = self
+        parameters = QueryParameters()
+        return parameters
+
+    def get_query_from_attrs(self) -> list[dict[str, Any]]:
+        """Get query from template attributes.
+
+        Returns:
+            list[dict[str, Any]]: List containing the formatted query.
+        """
+        parameters = self.get_command_parameters()
+
+        query_base_model = Query(command=self.COMMAND, parameters=parameters)
+
+        query, _ = query_base_model.prepare_query()
+        return [query]
+
+    def process_query_list(self, query: list[dict[str, Any]], container: DataContainer) -> None:
+        """Process a list of queries and add responses to data container.
+
+        Args:
+            query (list[dict[str, Any]]): List of query dictionaries.
+            container (DataContainer): Data container to store responses.
+        """
+        response_output, blob_output = self.get_query_response(query)
+        responses, response_blobs = self.preprocess_response(response_output, blob_output)
+
+        self.add_query_response_to_data_container(responses, response_blobs, container)
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        """Execute the query and return the updated data container.
+
+        Args:
+            container (DataContainer): Input data container.
+
+        Returns:
+            DataContainer: Data container with query results.
+        """
+        query = self.get_query_from_attrs()
+        self.process_query_list(query, container)
+        return container
+
+
+class ApertureDBGetStatus(ApertureDBClientQuery):
+    """This template adds a query to obtain the server status.
+
+    When invoked without parameters, it returns general status information:
+
+    system: "ApertureDB",
+    status: 0(ok), -1(not ready),
+    info: general information "OK",
+    version: "0.15.1",
+    """
+
+    COMMAND = "GetStatus"

sinapsis_aperturedb/templates/aperturedb_database_info.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+from pydantic import Field
+
+from sinapsis_aperturedb.helpers.query_base_models.base import (
+    GetSchemaParameters,
+    QueryParameters,
+)
+from sinapsis_aperturedb.templates.aperturedb_client_base import (
+    ApertureDBClientQuery,
+    ApertureDBClientQueryAttributes,
+)
+
+
+class ApertureDBGetSchemaAttributes(ApertureDBClientQueryAttributes):
+    """Attributes for ApertureDBGetSchema template."""
+
+    parameters: GetSchemaParameters = Field(
+        default_factory=dict,
+        description="Parameters for GetSchema command",
+    )
+
+
+class ApertureDBGetSchema(ApertureDBClientQuery):
+    """This template creates a GetSchema query.
+
+        Retrieve schema information based on current data.
+    Parameters
+
+        [optional] ref: Reference to other entities or connections within the transaction.
+        [optional] type: This can be "entities", "connections", or "both". Default is set to "both" when not specified.
+
+    """
+
+    AttributesBaseModel = ApertureDBGetSchemaAttributes
+    COMMAND = "GetSchema"
+
+    def get_command_parameters(self) -> QueryParameters:
+        """Get the command parameters for the GetSchema query.
+
+        Returns:
+        QueryParameters: The parameters for the GetSchema command.
+        """
+        return self.attributes.parameters

sinapsis_aperturedb/templates/aperturedb_delete_from_table.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+from sinapsis_aperturedb.helpers.query_base_models.delete import (
+    DeleteEntityParameters,
+)
+from sinapsis_aperturedb.templates.aperturedb_client_base import (
+    ApertureDBCommandBase,
+    ApertureDBCommandBaseAttributes,
+)
+
+
+# TO-DO: Rework delete templates to be more dynamic
+class ApertureDBDeleteClassAttributes(ApertureDBCommandBaseAttributes):
+    """Attributes for ApertureDBCommandBase template."""
+
+    class_name: str
+
+
+class ApertureDBDeleteClassEntities(ApertureDBCommandBase):
+    AttributesBaseModel = ApertureDBDeleteClassAttributes
+    COMMAND = "DeleteEntity"
+
+    def get_command_parameters(self) -> DeleteEntityParameters:
+        parameters = DeleteEntityParameters(with_class=self.attributes.class_name)
+        return parameters
+
+

sinapsis_aperturedb/templates/aperturedb_find_in_table.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from pydantic import Field
+
+from sinapsis_aperturedb.helpers.query_base_models.find import (
+    FindEntityParameters,
+)
+from sinapsis_aperturedb.templates.aperturedb_client_base import (
+    ApertureDBClientQuery,
+    ApertureDBClientQueryAttributes,
+)
+
+
+class ApertureDBFindEntities(ApertureDBClientQuery):
+    class ApertureDBFindEntityAttributes(ApertureDBClientQueryAttributes):
+        """Attributes for ApertureDBFindBase template."""
+
+        find_parameters: FindEntityParameters = Field(default_factory=dict)
+
+    AttributesBaseModel = ApertureDBFindEntityAttributes
+    COMMAND = "FindEntity"
+
+    def get_command_parameters(self) -> FindEntityParameters:
+        return self.attributes.find_parameters

sinapsis_aperturedb/templates/aperturedb_update_table.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from pydantic import Field
+
+from sinapsis_aperturedb.helpers.query_base_models.update import (
+    UpdateEntityParameters,
+)
+from sinapsis_aperturedb.templates.aperturedb_client_base import (
+    ApertureDBCommandBase,
+    ApertureDBCommandBaseAttributes,
+)
+
+
+# TO-DO: Rework Update templates to be more dynamic. Make Constraints easier to add
+class ApertureDBUpdateEntityAttributes(ApertureDBCommandBaseAttributes):
+    """Attributes for ApertureDBUpdateEntity template."""
+
+    parameters: UpdateEntityParameters = Field(
+        default_factory=dict,
+        description="Parameters for UpdateEntity/UpdateConnection command",
+    )
+
+
+class ApertureDBUpdateEntity(ApertureDBCommandBase):
+    AttributesBaseModel = ApertureDBUpdateEntityAttributes
+    COMMAND = "UpdateEntity"
+
+
+class ApertureDBUpdateConnection(ApertureDBCommandBase):
+    AttributesBaseModel = ApertureDBUpdateEntityAttributes
+    COMMAND = "UpdateConnection"

sinapsis_aperturedb-0.1.0.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: sinapsis-aperturedb
+Version: 0.1.0
+Summary: Templates for multimodal database operations using ApertureDB API.
+Author-email: SinapsisAI <dev@sinapsis.tech>
+Project-URL: Homepage, https://sinapsis.tech
+Project-URL: Documentation, https://docs.sinapsis.tech/docs
+Project-URL: Tutorials, https://docs.sinapsis.tech/tutorials
+Project-URL: Repository, https://github.com/Sinapsis-AI/sinapsis-aperturedb.git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aperturedb>=0.4.53
+Requires-Dist: sinapsis>=0.2.24
+Provides-Extra: all
+Requires-Dist: sinapsis-data-readers>=0.1.24; extra == "all"
+Requires-Dist: sinapsis-data-writers>=0.1.16; extra == "all"
+Dynamic: license-file
+
+<!-- [![sp](https://img.shields.io/badge/lang-sp-red.svg)](https://github.com/Sinapsis-AI/sinapsis-aperturedb/blob/main/README.es.md) -->
+<h1 align="center">
+<br>
+<a href="https://sinapsis.tech/">
+  <img
+    src="https://github.com/Sinapsis-AI/brand-resources/blob/main/sinapsis_logo/4x/logo.png?raw=true"
+    alt="" width="300">
+</a><br>
+Sinapsis ApertureDB
+<br>
+</h1>
+
+<h4 align="center">Modular templates for database entity management with ApertureDB</h4>
+
+<p align="center">
+<a href="#installation">🐍  Installation</a> •
+<a href="#features"> 🚀 Features</a> •
+<a href="#example"> 📚 Usage example</a> •
+<a href="#webapp"> 🌐 Webapp</a> •
+<a href="#documentation">📙 Documentation</a> •
+<a href="#license"> 🔍 License </a>
+</p>
+
+**Sinapsis ApertureDB** provides a robust and flexible integration for the ApertureDB Python SDK. It enables users to execute complex database operations—such as entity management, status monitoring, and schema retrieval—through a modular, template-based system.
+
+
+<h2 id="installation"> 🐍  Installation </h2>
+
+Install using your package manager of choice. We encourage the use of <code>uv</code>
+
+Example with <code>uv</code>:
+
+```bash
+  uv pip install sinapsis-aperturedb --extra-index-url https://pypi.sinapsis.tech
+```
+
+ or with raw <code>pip</code>:
+
+```bash
+  pip install sinapsis-aperturedb --extra-index-url https://pypi.sinapsis.tech
+```
+
+<h2 id="features">🚀 Features</h2>
+
+<h3>Templates Supported</h3>
+
+- **ApertureDBAddEntitiesFromCSV**: Ingests tabular data from a pandas DataFrame stored within a DataContainer, mapping each row to a unique Entity for bulk insertion into the database.
+- **ApertureDBFindEntities**: Executes targeted entity queries within ApertureDB, retrieving records that match a specific set of user-defined constraints and filters.
+- **ApertureDBGetStatus**: Polls the ApertureDB server to retrieve real-time health metrics, connectivity status, and operational readiness.
+- **ApertureDBGetSchema**: Introspects the database to generate a comprehensive overview of the current data model, including entity types, properties, and relationships.
+
+> [!TIP]
+> Use CLI command ```sinapsis info --all-template-names``` to show a list with all the available Template names installed with Sinapsis ApertureDB.
+
+> [!TIP]
+> Use CLI command ```sinapsis info --example-template-config TEMPLATE_NAME``` to produce an example Agent config for the Template specified in ***TEMPLATE_NAME***.
+
+For example, for ***ApertureDBGetStatus*** use ```sinapsis info --example-template-config ApertureDBGetStatus``` to produce an example config like:
+
+```yaml
+agent:
+  name: my_test_agent
+templates:
+- template_name: InputTemplate
+  class_name: InputTemplate
+  attributes: {}
+- template_name: ApertureDBGetStatus
+  class_name: ApertureDBGetStatus
+  template_input: InputTemplate
+  attributes:
+    connect_with_key: false
+    connection_params:
+      host: localhost
+      user: ''
+      port: 55555
+      password: ''
+      key: ''
+      use_ssl: false
+```
+
+<h2 id='example'>📚 Usage example</h2>
+
+You can begin testing ```sinapsis-aperturedb``` by executing the ```ApertureDBGetStatus``` configuration. To utilize the ```ApertureDB``` templates, you must first establish a connection to an ApertureDB instance. You have three primary options:
+
+- Cloud: Connect to a hosted ApertureDB instance using a generated API key.
+- Local: Deploy a local instance using the aperturedb-community Docker image.
+- Docker Compose: Automatically deploy the aperturedb service and execute the getStatus configuration in one workflow.
+
+<details>
+<summary ><strong><span style="font-size: 1.4em;"> ☁️ ApertureDB Cloud </span></strong></summary>
+
+1. **Generate an API key**: Create an ApertureDB Cloud account and generate your API key by following the official [ApertureDB setup guide](https://docs.aperturedata.io/Setup/server/Cloud).
+
+2. **Configure Environment Variables**: Set the ```APERTUREDB_API_KEY``` variable in your terminal. This key is used by the connect_with_key attribute in your configuration.
+
+    ```bash
+    export APERTUREDB_API_KEY="your-api-key-here"
+    ```
+
+3. **Prepare the GetStatus Configuration**: Save the following YAML as ```check_status.yaml```. This configuration tells the agent to authenticate using your stored API key.
+
+    ```yaml
+    agent:
+      name: aperturedb_get_status
+      description: Validates connection and retrieves ApertureDB server health status.
+
+    templates:
+    - template_name: InputTemplate
+      class_name: InputTemplate
+      attributes: {}
+
+    - template_name: GetStatus
+      class_name: ApertureDBGetStatus
+      template_input: InputTemplate
+      attributes:
+        connect_with_key: true
+    ```
+
+4. **Execute via CLI**: Run the configuration using the Sinapsis CLI:
+
+    ```bash
+    sinapsis run check_status.yaml
+    ```
+
+</details>
+
+<details>
+<summary ><strong><span style="font-size: 1.4em;"> 💻 Local ApertureDB instance </span></strong></summary>
+
+For local prototyping and testing of <code>sinapsis-aperturedb</code>, you can deploy a containerized instance of **ApertureDB Community Edition**.
+
+1. **Deploy the container**. Use the following Docker command to run the ApertureDB Community Edition. This setup maps the default port and configures initial credentials.
+
+    ```bash
+    docker run -p 55555:55555 -e ADB_MASTER_KEY=admin -e ADB_FORCE_SSL=false  aperturedata/aperturedb-community
+    ```
+
+2. **Configure Environment Variables**: Set your connection parameters so sinapsis-aperturedb can authenticate with the local instance.
+
+    ```bash
+    export APERTUREDB_HOST="localhost"
+    export APERTUREDB_PORT=55555
+    ```
+
+3. **Prepare the GetStatus Configuration**: Use the following YAML configuration to verify the connection. Save this as ```check_status.yaml```:
+
+    ```yaml
+    agent:
+      name: aperturedb_get_status
+      description: Validates connection and retrieves ApertureDB server health status.
+
+    templates:
+    - template_name: InputTemplate
+      class_name: InputTemplate
+      attributes: {}
+
+    - template_name: GetStatus
+      class_name: ApertureDBGetStatus
+      template_input: InputTemplate
+      attributes:
+        connect_with_key: false
+        connection_params:
+            host: localhost
+            user: admin
+            port: 55555
+            password: admin
+            use_ssl: false
+    ```
+
+4. **Execute via CLI**: Run the configuration using the Sinapsis CLI:
+
+    ```bash
+    sinapsis run check_status.yaml
+    ```
+
+</details>
+
+<details>
+<summary id="docker"><strong><span style="font-size: 1.4em;">🐳 Docker Compose</span></strong></summary>
+
+**IMPORTANT** This docker image depends on the sinapsis:base image. Refer to the official [Sinapsis Docker Instructions](https://github.com/Sinapsis-ai/sinapsis?tab=readme-ov-file#docker) to build the base before proceeding.
+
+1. **Build the sinapsis-aperturedb image**: Compile the local environment using the provided compose file.
+
+    ```bash
+    docker compose -f docker/compose.yaml build
+    ```
+
+2. **Start the app container**: Launch the service in the background or attached mode.
+
+    ```bash
+    docker compose -f docker/compose_app.yaml up -d
+    ```
+
+3. **Monitor logs and status**: Verify the connection to ApertureDB by tailing the container logs.
+
+    ```bash
+    docker logs -f sinapsis-aperturedb-app
+    ```
+
+4. **To stop the app**: Gracefully shut down the services and clean up network resources.
+
+    ```bash
+    docker compose -f docker/compose_app.yaml down
+    ```
+
+</details>
+
+<h2 id="documentation">📙 Documentation</h2>
+
+Documentation for this and other sinapsis packages is available on the [sinapsis website](https://docs.sinapsis.tech/docs)
+
+Tutorials for different projects within sinapsis are available at [sinapsis tutorials page](https://docs.sinapsis.tech/tutorials)
+
+<h2 id="license">🔍 License</h2>
+
+This project is licensed under the AGPLv3 license, which encourages open collaboration and sharing. For more details, please refer to the [LICENSE](LICENSE) file.
+
+For commercial use, please refer to our [official Sinapsis website](https://sinapsis.tech) for information on obtaining a commercial license.

sinapsis_aperturedb-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+sinapsis_aperturedb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sinapsis_aperturedb/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sinapsis_aperturedb/helpers/aperturedb_env_var_keys.py,sha256=FWFQhtYtk48NcClibYTTBroZWjALftHoBmOpYkRlsOI,1730
+sinapsis_aperturedb/helpers/tags.py,sha256=FCOM6zqD0fchIcLiIzMOU7FY4jSasR4I_eoxuiDoewM,110
+sinapsis_aperturedb/helpers/query_base_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sinapsis_aperturedb/helpers/query_base_models/add.py,sha256=hhX7zaaM868GPlzJ3kY4RO22uxBrBjY8baAkEBEGhrk,1191
+sinapsis_aperturedb/helpers/query_base_models/base.py,sha256=hKXQjOB3RdNp2Io3aMMxYBjXzIfUAXkBt0k5aONEbUc,5772
+sinapsis_aperturedb/helpers/query_base_models/delete.py,sha256=DfP6-4X3AcVlJo6Q2DCGsPM61NfLTmjvIOp0sBe8lFQ,909
+sinapsis_aperturedb/helpers/query_base_models/find.py,sha256=ZOpx2nWlDYGwTCort1Sc6xIXLqtNOuNG9l8b7pT4gMA,2273
+sinapsis_aperturedb/helpers/query_base_models/update.py,sha256=sCg6byMWfspJ1hzbL1wQjA_o3AHPM4h1En9KnXH0kVE,1951
+sinapsis_aperturedb/templates/__init__.py,sha256=XQF9ImJB_lEYEw6o0g29fJpMrIt7t4fGXGKVqOMoC_Q,768
+sinapsis_aperturedb/templates/aperturedb_add_to_table.py,sha256=ojXCy78lX4WR-OKG1ucCv9DYgxwDzrLaQkERptMj_dY,2575
+sinapsis_aperturedb/templates/aperturedb_client_base.py,sha256=VjvnsD88QwfAxnkkaJQWxDNRitB3fVQwFsibBRAQsDY,8409
+sinapsis_aperturedb/templates/aperturedb_database_info.py,sha256=sgn2IxOsgpSkJyUCcyYxAFLdHihhs6deudyMc-TmeWE,1302
+sinapsis_aperturedb/templates/aperturedb_delete_from_table.py,sha256=ns3KdAUnGaOzIte27bqA1QJ51KTGTmMfwwIgp9823z8,784
+sinapsis_aperturedb/templates/aperturedb_find_in_table.py,sha256=RdV0zpOBhgSQeXMA83C1Xo1wb5mkWTbT2cG94mWdH6Y,738
+sinapsis_aperturedb/templates/aperturedb_update_table.py,sha256=p1yyuRmDbbrJzRSqPTISY2RUpZbVvnCrMGEIsZxgXUs,954
+sinapsis_aperturedb-0.1.0.dist-info/licenses/LICENSE,sha256=ILBn-G3jdarm2w8oOrLmXeJNU3czuJvVhDLBASWdhM8,34522
+sinapsis_aperturedb-0.1.0.dist-info/METADATA,sha256=p8SMGU5i-wHw-NiVq1IQATj5c8vzIBSokSdt2qt0O0o,8946
+sinapsis_aperturedb-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sinapsis_aperturedb-0.1.0.dist-info/top_level.txt,sha256=dlIQe41I4k09mGdsS5qP-Nd1RjacdTmVFmkHOUv7N5A,20
+sinapsis_aperturedb-0.1.0.dist-info/RECORD,,

sinapsis_aperturedb-0.1.0.dist-info/WHEEL

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