arcadedb-python 0.2.0__py3-none-any.whl

arcadedb_python/__init__.py

@@ -0,0 +1,40 @@
+"""ArcadeDB Python Driver.
+
+A Python driver for ArcadeDB - Multi-Model Database with Graph, Document, 
+Key-Value, Vector, and Time-Series support.
+
+This package provides a comprehensive Python interface to ArcadeDB, enabling
+developers to work with all of ArcadeDB's data models through a unified API.
+
+Example:
+    Basic usage:
+    
+    >>> from arcadedb_python import DatabaseDao
+    >>> db = DatabaseDao("localhost", 2480, "mydb", "root", "password")
+    >>> result = db.query("sql", "SELECT FROM V LIMIT 10")
+    >>> print(result)
+
+Classes:
+    DatabaseDao: Main database access object for executing queries
+    ArcadeDBConfig: Configuration class for connection settings
+    
+For more information, visit: https://docs.arcadedb.com/
+"""
+
+__version__ = "0.2.0"
+__author__ = "Adams Rosales, ExtReMLapin, Steve Reiner"
+__email__ = ""
+__license__ = "Apache-2.0"
+
+# Import main classes for easy access
+from arcadedb_python.dao.database import DatabaseDao
+from arcadedb_python.api.sync import SyncClient
+from arcadedb_python.api.client import Client, LoginFailedException
+
+__all__ = [
+    "DatabaseDao",
+    "SyncClient", 
+    "Client",
+    "LoginFailedException",
+    "__version__",
+]

arcadedb_python/api/client.py

@@ -0,0 +1,103 @@
+from . import config
+from abc import ABC, abstractmethod
+
+import logging
+import requests
+
+from retry import retry
+
+class LoginFailedException(Exception):
+    
+    def __init__(self, javaErrorCode, message):
+        self.javaErrorCode = javaErrorCode
+        self.message = message
+        super().__init__(self.message)
+
+
+class Client(ABC):
+    def __init__(self, host: str, port: str, protocol: str = "http", **kwargs):
+        self.host = host
+        self.port = int(port)
+        self.kwargs = kwargs
+        self.protocol = protocol
+        self._validate()
+
+    def _validate(self):
+        if not self.host:
+            raise ValueError("Host is required")
+        if not self.port:
+            raise ValueError("Port is required")
+        endpoint_test = config.ARCADE_BASE_SERVER_ENDPOINT
+        try:
+            self.post(endpoint_test,  { "command": "list databases" })
+            
+        except LoginFailedException as e:
+
+            if e.javaErrorCode == "com.arcadedb.server.security.ServerSecurityException":
+                raise ValueError("Invalid credentials")
+            else:
+                raise ValueError("Unable to connect to server : ", e)
+        except Exception as e:
+            raise ValueError("Unable to connect to server : ", e)
+        
+        
+
+
+    def _get_endpoint(self, endpoint: str) -> str:
+        if endpoint.startswith("/"):
+            endpoint = endpoint[1:]
+        if self.url.endswith("/"):
+            return f"{self.url}{endpoint}"
+        else:
+            return f"{self.url}/{endpoint}"
+
+    @property
+    def headers(self):
+        default = "application/json"
+        key = "content_type"
+        if key not in self.kwargs:
+            logging.warning(f"No content type, defaulting to {default}")
+        content_type = self.kwargs.get(key, default)
+        return {"Content-Type": content_type}
+
+    @property
+    def url(self) -> str:
+        return f"{self.protocol}://{self.host}:{self.port}"
+
+    @property
+    def username(self) -> str:
+        return self.kwargs.get("username") or self.kwargs.get("user")
+
+    @property
+    def password(self) -> str:
+        return self.kwargs.get("password") or self.kwargs.get("pw")
+
+    def __repr__(self) -> str:
+        return f"<host={self.host} port={self.port} user={self.username}>"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+    
+   
+        
+
+
+    @abstractmethod
+    @retry(
+        tries=config.API_RETRY_MAX,
+        delay=config.API_RETRY_DELAY,
+        backoff=config.API_RETRY_BACKOFF,
+    )
+    def post(self, endpoint: str, payload: dict, return_headers: bool=False, extra_headers: dict = {}) -> requests.Response:
+        pass
+
+    @abstractmethod
+    @retry(
+        tries=config.API_RETRY_MAX,
+        delay=config.API_RETRY_DELAY,
+        backoff=config.API_RETRY_BACKOFF,
+    )
+    def get(self, endpoint: str, return_headers: bool=False, extra_headers: dict = {}) -> requests.Response:
+        pass
+
+    

arcadedb_python/api/config.py

@@ -0,0 +1,23 @@
+import os
+
+
+def _get_env_variable(key: str, default: str = None) -> str:
+    return os.environ.get(key, os.getenv(key, default))
+
+
+ARCADE_BASE_ENDPOINT = _get_env_variable("ARCADE_API_ENDPOINT", "/api/v1")
+ARCADE_BASE_SERVER_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/server"
+ARCADE_BASE_EXISTS_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/exists"
+ARCADE_BASE_COMMAND_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/command"
+ARCADE_BASE_LIST_DB_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/databases"
+ARCADE_BASE_QUERY_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/query"
+
+ARCADE_BASE_TRANSACTION_BEGIN_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/begin"
+ARCADE_BASE_TRANSACTION_COMMIT_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/commit"
+ARCADE_BASE_TRANSACTION_ROLLBACK_ENDPOINT = f"{ARCADE_BASE_ENDPOINT}/rollback"
+
+AVAILABLE_LANGUAGES = {"sql", "sqlscript", "graphql", "cypher", "gremlin", "mongo"}
+
+API_RETRY_MAX = int(_get_env_variable("ARCADE_API_RETRY_MAX", "3"))
+API_RETRY_DELAY = int(_get_env_variable("ARCADE_API_RETRY_DELAY", "1"))
+API_RETRY_BACKOFF = int(_get_env_variable("ARCADE_API_RETRY_BACKOFF", "2"))

arcadedb_python/api/sync.py

@@ -0,0 +1,112 @@
+from .client import Client, LoginFailedException
+
+import json
+import logging
+import requests
+import re
+
+
+def _filter_payload_for_log(payload: dict, max_chars: int = 500) -> dict:
+    """Filter payload for logging by truncating embedding data to avoid cluttering logs.
+    
+    Args:
+        payload: The payload dictionary to filter
+        max_chars: Maximum characters to show for the entire payload
+        
+    Returns:
+        Filtered payload dictionary with embedding data truncated
+    """
+    if not isinstance(payload, dict):
+        return payload
+    
+    # Create a copy to avoid modifying the original
+    filtered_payload = payload.copy()
+    
+    # Filter the 'command' field if it contains embedding arrays
+    if 'command' in filtered_payload and isinstance(filtered_payload['command'], str):
+        command = filtered_payload['command']
+        
+        # Pattern to match embedding arrays like [0.123, -0.456, 0.789, ...]
+        embedding_pattern = r'\[[-0-9.,\s]+\]'
+        
+        def replace_embedding(match):
+            full_embedding = match.group(0)
+            if len(full_embedding) > 50:  # If embedding is long, truncate it
+                # Extract first few values to show dimension info
+                values = re.findall(r'[-0-9.]+', full_embedding[:100])
+                total_values = len(re.findall(r'[-0-9.]+', full_embedding))
+                if len(values) >= 2:
+                    return f"[{values[0]}, {values[1]}, ...] (dim:{total_values})"
+                else:
+                    return f"[...] (dim:{total_values})"
+            return full_embedding
+        
+        # Replace embedding arrays with truncated versions
+        filtered_command = re.sub(embedding_pattern, replace_embedding, command)
+        
+        # Limit total command length
+        if len(filtered_command) > max_chars:
+            filtered_command = filtered_command[:max_chars] + "..."
+        
+        filtered_payload['command'] = filtered_command
+    
+    return filtered_payload
+
+
+class SyncClient(Client):
+    def __init__(self, host: str, port: str, protocol: str = "http", **kwargs):
+        super().__init__(host, port, protocol, **kwargs)
+
+    def subhandler(self, response: requests.Response, return_headers: bool=False):
+        if response.status_code >= 400 :
+            json_decoded_data = response.json()
+            print(json_decoded_data)
+            java_error_code = json_decoded_data['exception'] if 'exception' in json_decoded_data else "Unknown error"
+            detail_error_code = None
+            if 'detail' in json_decoded_data:
+                detail_error_code = json_decoded_data['detail']
+            elif 'exception' in json_decoded_data:
+                detail_error_code = json_decoded_data['exception']
+            else:
+                detail_error_code = "Unknown error"
+            
+            if java_error_code == "com.arcadedb.server.security.ServerSecurityException":
+                raise LoginFailedException(java_error_code, detail_error_code)
+            else:
+                raise Exception(java_error_code, detail_error_code)
+        
+        response.raise_for_status()
+        logging.debug(f"response: {response.text}")
+        if return_headers is False:
+            if len(response.text) > 0:
+                try:
+                    return response.json()["result"]
+                except:
+                    return response.text
+            else:
+                return
+        else:
+            return  response.headers
+
+    def post(self, endpoint: str, payload: dict, return_headers: bool=False, extra_headers: dict = {}) -> requests.Response:
+        endpoint = self._get_endpoint(endpoint)
+        filtered_payload = _filter_payload_for_log(payload)
+        logging.info(f"posting to {endpoint} with payload {filtered_payload}")
+        response = requests.post(
+            endpoint,
+            data=json.dumps(payload),
+            headers={**self.headers,**extra_headers},
+            auth=(self.username, self.password),
+        )
+        return self.subhandler(response, return_headers=return_headers)
+
+    def get(self, endpoint: str, return_headers: bool=False, extra_headers: dict = {}) -> requests.Response:
+        endpoint = self._get_endpoint(endpoint)
+        logging.info(f"submitting get request to {endpoint}")
+        response = requests.get(
+            endpoint,
+            auth=(self.username, self.password),
+            headers=extra_headers,
+        )
+        return self.subhandler(response, return_headers=return_headers)
+

arcadedb_python/dao/database.py

@@ -0,0 +1,321 @@
+
+from ..api.client import Client
+from ..api import config
+from typing import Optional, Any, List, Union
+from enum import Enum
+import re
+try:
+    import psycopg
+    PSYCOPG_AVAILABLE = True
+except ImportError:
+    PSYCOPG_AVAILABLE = False
+    psycopg = None
+
+try:
+    from pygments.lexers import get_lexer_by_name
+    from pygments.token import string_to_tokentype
+    try:
+        # Try to get the Cypher lexer - might not be available
+        cypher_lexer = get_lexer_by_name("cypher")
+    except:
+        try:
+            # Fallback to SQL lexer
+            cypher_lexer = get_lexer_by_name("sql")
+        except:
+            cypher_lexer = None
+    
+    if cypher_lexer:
+        punctuation = string_to_tokentype("Token.Punctuation")
+        global_var = string_to_tokentype("Token.Name.Variable.Global")
+        string_liral = string_to_tokentype("Token.Literal.String")
+        PYGMENTS_AVAILABLE = True
+    else:
+        PYGMENTS_AVAILABLE = False
+except ImportError:
+    PYGMENTS_AVAILABLE = False
+    cypher_lexer = None
+
+# Removed - now handled in the import section above
+
+
+class DatabaseDao:
+    """
+    Class to work with ArcadeDB databases
+    """
+
+    class IsolationLevel(Enum):
+        """Isolation levels for transactions"""
+        READ_COMMITTED = "READ_COMMITTED"
+        REPEATABLE_READ = "REPEATABLE_READ"
+        
+    class Driver(Enum):
+        HTTP="HTTP"
+        PSYCOPG="PSYCOPG"
+
+    @staticmethod
+    def exists(client, name: str) -> bool:
+        """
+        Check if a database exists.
+
+        Parameters:
+        - client (Client): The ArcadeDB client.
+        - name (str): The name of the database.
+
+        Returns:
+        bool: True if the database exists, False otherwise.
+        """
+        response = client.get(f"{config.ARCADE_BASE_EXISTS_ENDPOINT}/{name}")
+        return response
+
+    @staticmethod
+    def create(client: Client, name: str) -> 'DatabaseDao':
+        """
+        Create a new database.
+
+        Parameters:
+        - client (Client): The ArcadeDB client.
+        - name (str): The name of the new database.
+
+        Returns:
+        DatabaseDao: An instance of DatabaseDao for the created database.
+
+        Raises:
+        - ValueError: If the database already exists.
+        - ValueError: If the creation of the database fails.
+        """
+        if DatabaseDao.exists(client, name):
+            raise ValueError(f"Database {name} already exists")
+
+        ret = client.post(config.ARCADE_BASE_SERVER_ENDPOINT, {"command": f"create database {name}"})
+        if ret == "ok":
+            return DatabaseDao(client, name)
+        else:
+            raise ValueError(f"Could not create database {name}: {ret}")
+
+    @staticmethod
+    def delete(client: Client, name: str) -> bool:
+        """
+        Delete a database.
+
+        Parameters:
+        - client (Client): The ArcadeDB client.
+        - name (str): The name of the database to be deleted.
+
+        Returns:
+        bool: True if the database is successfully deleted.
+
+        Raises:
+        - ValueError: If the database does not exist.
+        - ValueError: If the deletion of the database fails.
+        """
+        if not DatabaseDao.exists(client, name):
+            raise ValueError(f"Database {name} does not exist")
+        ret = client.post(config.ARCADE_BASE_SERVER_ENDPOINT, {"command": f"drop database {name}"})
+        if ret == "ok":
+            return True
+        else:
+            raise ValueError(f"Could not drop database {name}: {ret}")
+
+    @staticmethod
+    def list_databases(client: Client) -> List:
+        """
+        List all databases.
+
+        Parameters:
+        - client (Client): The ArcadeDB client.
+
+        Returns:
+        str: The list of databases.
+        """
+        return client.get(config.ARCADE_BASE_LIST_DB_ENDPOINT)
+
+    def __init__(
+        self,
+        client: Client,
+        database_name: str,
+        driver:Driver=Driver.HTTP
+        
+    ):
+        """
+        Initialize a DatabaseDao instance.
+
+        Parameters:
+        - client (Client): The ArcadeDB client.
+        - database_name (str): The name of the database.
+
+        Raises:
+        - ValueError: If the database does not exist. Call create() to create a new database.
+        """
+        self.client = client
+        self.database_name = database_name
+        self.driver = driver
+
+            
+        if self.driver == self.Driver.PSYCOPG:
+            if not PSYCOPG_AVAILABLE:
+                raise ImportError("psycopg is required for PSYCOPG driver. Install with: pip install psycopg")
+            port = self.client.port
+            if client.port == 2480:
+                print("Auto switching port to 5432 as we're using PSYCOPG driver")
+                port = 5432
+            self.connection = psycopg.connect(user=self.client.username, password=self.client.password,
+                    host=self.client.host,
+                    port=port,
+                    dbname=self.database_name,
+                    sslmode='disable'
+                )
+        else:
+            self.connection = None
+        if not DatabaseDao.exists(client, database_name):
+            raise ValueError(f"Database {database_name} does not exist, call create()")
+        
+        
+    cypher_var_regex = re.compile(r'\$([a-zA-Z_][a-zA-Z0-9_]*)')
+    
+
+    @staticmethod
+    def cypher_formater(query: str, params: dict) -> str:
+        if not PYGMENTS_AVAILABLE:
+            # Fallback to simple parameter substitution if pygments not available
+            import re
+            def replace_param(match):
+                param_name = match.group(1)
+                if param_name in params:
+                    value = params[param_name]
+                    if isinstance(value, str):
+                        return f"'{value.replace('\\', '\\\\').replace('\'', '\\\'')}'"
+                    return str(value)
+                return match.group(0)
+            
+            result = re.sub(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', replace_param, query)
+            return result, {}
+
+        skipped_params = {}
+        tokens = list(cypher_lexer.get_tokens(query))
+        i = 0
+        len_tokens = len(tokens)
+        while i < len_tokens-1:
+            if tokens[i][0] == punctuation and tokens[i+1][0] == global_var:
+                var_name = tokens[i+1][1]
+                assert var_name in params, f"Variable {var_name} not found in the parameters"
+                if isinstance(params[var_name], str) and '$' in params[var_name]:
+                    skipped_params[var_name] = params[var_name]
+                    i += 2
+                    continue
+                if isinstance(params[var_name], list):
+                    skipped_params[var_name] = params[var_name]
+                    i += 2
+                    continue
+                
+                
+                escaped_string = str(params[var_name]).replace('\\', '\\\\').replace('\'', '\\\'')
+                tokens[i] = (string_liral, f"'{escaped_string}'")
+                tokens.pop(i+1)
+                len_tokens -= 1
+    
+            i += 1
+        return "".join([x[1] for x in tokens]), skipped_params
+    
+        
+
+    def query(
+        self,
+        language: str,
+        command: str,
+        limit: Optional[int] = None,
+        params: Optional[Any] = None,
+        serializer: Optional[str] = None,
+        session_id: Optional[str] = None,
+        is_command: Optional[bool] = False
+    ) -> Union[str, List, dict]:
+        """
+        Execute a query on the database.
+
+        Parameters:
+        - language (str): The query language.
+        - command (str): The query command.
+        - limit (int): The limit on the number of results (optional).
+        - params: The parameters for the query (optional).
+        - serializer (str): The serializer for the query results (optional).
+        - session_id: The session ID for the query (optional).
+        - is_command: If the query is a command (optional), you need this to run non-idempotent commands.
+
+        Returns:
+        str: The result of the query.
+        """
+        language = language.lower()
+        if language not in config.AVAILABLE_LANGUAGES:
+            raise ValueError(f"Language {language} not supported")
+        if limit is not None:
+            assert isinstance(limit, int), "Limit must be an integer"
+        serializer = serializer.lower() if serializer else serializer
+        assert serializer in {None, "graph", "record"}, "Serializer must be None, 'graph' or 'record'"
+        
+        if language == "cypher" and params:
+            command, new_params = self.cypher_formater(command, params)
+            params = new_params if len(new_params) > 0 else None
+        payload = {
+            "command": command,
+            "language": language,
+        }
+        if limit is not None:
+            payload["limit"] = limit
+        if params is not None:
+            payload["params"] = params
+        if serializer is not None:
+            assert self.driver == self.Driver.HTTP, "Serializer is only support with HTTP driver"
+            payload["serializer"] = serializer
+        extra_headers = {}
+        if session_id is not None:
+            assert self.driver == self.Driver.HTTP, "Session ID is only support with HTTP driver"
+            extra_headers["arcadedb-session-id"] = session_id
+        if self.driver == self.Driver.HTTP:
+            req = self.client.post(f"{config.ARCADE_BASE_QUERY_ENDPOINT if is_command is False else config.ARCADE_BASE_COMMAND_ENDPOINT}/{self.database_name}", payload, extra_headers=extra_headers)
+        else:
+            with self.connection.cursor(row_factory=psycopg.rows.dict_row) as cursor:
+                prefix = "" if language == "sql" else f"{{{language}}}"
+                cursor.execute(query=prefix+command, params=params)
+                return cursor.fetchall()
+            
+        return req
+
+    def begin_transaction(self, isolation_level: IsolationLevel = IsolationLevel.READ_COMMITTED) -> str:
+
+        """
+        Begin a new transaction.
+
+        Parameters:
+        - isolation_level (IsolationLevel): The isolation level for the transaction (default: READ_COMMITTED).
+
+        Returns:
+        str: The session ID for the new transaction.
+        """
+        headers = self.client.post(f"{config.ARCADE_BASE_TRANSACTION_BEGIN_ENDPOINT}/{self.database_name}", {"isolationLevel": isolation_level.value}, return_headers=True)
+        return headers["arcadedb-session-id"]
+
+    def commit_transaction(self, session_id) -> None:
+        """
+        Commit a transaction.
+
+        Parameters:
+        - session_id: The session ID of the transaction to be committed.
+        """
+        self.client.post(f"{config.ARCADE_BASE_TRANSACTION_COMMIT_ENDPOINT}/{self.database_name}", {}, extra_headers={"arcadedb-session-id": session_id})
+
+    def rollback_transaction(self, session_id) -> None:
+        """
+        Rollback a transaction.
+
+        Parameters:
+        - session_id: The session ID of the transaction to be rolled back.
+        """
+        self.client.post(f"{config.ARCADE_BASE_TRANSACTION_ROLLBACK_ENDPOINT}/{self.database_name}", {}, extra_headers={"arcadedb-session-id": session_id})
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the DatabaseDao instance.
+
+        Returns:
+        str: A string representation of the form "<DatabaseDao database_name={self.database_name}> @ {self.client}".
+        """
+        return f"<DatabaseDao database_name={self.database_name}> @ {self.client}"

arcadedb_python/model/database.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Database:
+    name: str
+    exists: bool

arcadedb_python/model/request.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+from typing import Union
+
+
+@dataclass
+class RequestData:
+    endpoint: str
+    command: Union[str, None] = None
+    language: Union[str, None] = "sql"
+
+    def payload(self) -> dict:
+        if not self.language:
+            return {"command": self.command}
+        else:
+            return {"command": self.command, "language": self.language}

arcadedb_python-0.2.0.dist-info/METADATA

@@ -0,0 +1,344 @@
+Metadata-Version: 2.4
+Name: arcadedb-python
+Version: 0.2.0
+Summary: Python driver for ArcadeDB - Multi-Model Database with Graph, Document, Key-Value, Vector, and Time-Series support
+Project-URL: Homepage, https://github.com/stevereiner/arcadedb-python
+Project-URL: Documentation, https://docs.arcadedb.com/
+Project-URL: Repository, https://github.com/stevereiner/arcadedb-python
+Project-URL: Bug Tracker, https://github.com/stevereiner/arcadedb-python/issues
+Project-URL: Changelog, https://github.com/stevereiner/arcadedb-python/blob/main/CHANGELOG.md
+Author: Adams Rosales, ExtReMLapin, Steve Reiner
+Maintainer: Steve Reiner
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: arcadedb,database,document,graph,key-value,multi-model,nosql,python-driver,time-series,vector
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.25.0
+Requires-Dist: retry>=0.9.2
+Provides-Extra: cypher
+Requires-Dist: pygments>=2.0.0; extra == 'cypher'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: flake8>=6.0.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: tox>=4.0.0; extra == 'dev'
+Provides-Extra: full
+Requires-Dist: psycopg>=3.0.0; extra == 'full'
+Requires-Dist: pygments>=2.0.0; extra == 'full'
+Provides-Extra: postgresql
+Requires-Dist: psycopg>=3.0.0; extra == 'postgresql'
+Description-Content-Type: text/markdown
+
+# ArcadeDB Python Driver
+
+[![PyPI version](https://badge.fury.io/py/arcadedb-python.svg)](https://badge.fury.io/py/arcadedb-python)
+[![Python versions](https://img.shields.io/pypi/pyversions/arcadedb-python.svg)](https://pypi.org/project/arcadedb-python/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+A comprehensive Python driver for [ArcadeDB](https://arcadedb.com) - the Multi-Model Database that supports Graph, Document, Key-Value, Vector, and Time-Series models in a single engine.
+
+## Credits & Attribution
+
+This driver builds upon the excellent work of the original ArcadeDB Python driver contributors:
+
+- **Adams Rosales** ([@adaros92](https://github.com/adaros92)) - Original [arcadedb-python-driver](https://github.com/adaros92/arcadedb-python-driver)
+- **ExtReMLapin** ([@ExtReMLapin](https://github.com/ExtReMLapin)) - Core contributor and enhancements
+- **ArcadeDB Team** - The amazing [ArcadeDB](https://github.com/ArcadeData/arcadedb) database engine
+
+This modernized version enhances the original work with updated packaging, comprehensive documentation, and production-ready features while maintaining full compatibility with the [ArcadeDB](https://arcadedb.com/) database.
+
+## Features
+
+- **Multi-Model Support**: Work with Graph, Document, Key-Value, Vector, and Time-Series data models
+- **High Performance**: Optimized for speed with native ArcadeDB protocols
+- **Full API Coverage**: Complete access to ArcadeDB's REST API and SQL capabilities
+- **Type Safety**: Comprehensive type hints for better development experience
+- **Async Support**: Both synchronous and asynchronous operation modes
+- **Connection Pooling**: Efficient connection management for production use
+- **Comprehensive Testing**: Extensive test suite ensuring reliability
+
+## Installation
+
+### Using UV (Recommended)
+
+```bash
+# Install uv if not already installed
+pip install uv
+
+# Create virtual environment and install
+uv venv
+uv pip install arcadedb-python
+```
+
+### Using Pip
+
+```bash
+pip install arcadedb-python
+```
+
+### Optional Dependencies
+
+```bash
+# PostgreSQL driver support
+uv pip install arcadedb-python[postgresql]
+# or: pip install arcadedb-python[postgresql]
+
+# Cypher syntax highlighting
+uv pip install arcadedb-python[cypher]
+# or: pip install arcadedb-python[cypher]
+
+# All optional features
+uv pip install arcadedb-python[full]
+# or: pip install arcadedb-python[full]
+
+# Development dependencies
+uv pip install arcadedb-python[dev]
+# or: pip install arcadedb-python[dev]
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from arcadedb_python import DatabaseDao
+
+# Connect to ArcadeDB
+db = DatabaseDao(
+    host="localhost",
+    port=2480,
+    database="mydb",
+    username="root",
+    password="playwithdata"
+)
+
+# Execute SQL queries
+result = db.query("sql", "SELECT FROM V LIMIT 10")
+print(result)
+
+# Create vertices and edges
+db.command("sql", "CREATE VERTEX TYPE Person")
+db.command("sql", "INSERT INTO Person SET name = 'John', age = 30")
+
+# Graph traversal
+result = db.query("sql", """
+    MATCH {type: Person, as: person} 
+    RETURN person.name, person.age
+""")
+```
+
+### Configuration
+
+```python
+from arcadedb_python import ArcadeDBConfig, DatabaseDao
+
+# Using configuration object
+config = ArcadeDBConfig(
+    host="localhost",
+    port=2480,
+    username="root",
+    password="playwithdata"
+)
+
+db = DatabaseDao.from_config(config, "mydb")
+```
+
+### Async Operations
+
+```python
+import asyncio
+from arcadedb_python import DatabaseDao
+
+async def main():
+    db = DatabaseDao("localhost", 2480, "mydb", "root", "playwithdata")
+    
+    # Async query execution
+    result = await db.query_async("sql", "SELECT FROM V LIMIT 10")
+    print(result)
+
+asyncio.run(main())
+```
+
+## Advanced Usage
+
+### Working with Different Data Models
+
+```python
+# Document operations
+db.command("sql", "CREATE DOCUMENT TYPE Product")
+db.command("sql", """
+    INSERT INTO Product CONTENT {
+        "name": "Laptop",
+        "price": 999.99,
+        "specs": {
+            "cpu": "Intel i7",
+            "ram": "16GB"
+        }
+    }
+""")
+
+# Graph operations
+db.command("sql", "CREATE VERTEX TYPE Customer")
+db.command("sql", "CREATE EDGE TYPE Purchased")
+db.command("sql", """
+    CREATE EDGE Purchased 
+    FROM (SELECT FROM Customer WHERE name = 'John')
+    TO (SELECT FROM Product WHERE name = 'Laptop')
+    SET date = date(), amount = 999.99
+""")
+
+# Key-Value operations
+db.command("sql", "CREATE DOCUMENT TYPE Settings")
+db.command("sql", "INSERT INTO Settings SET key = 'theme', value = 'dark'")
+
+# Time-Series operations
+db.command("sql", "CREATE VERTEX TYPE Sensor")
+db.command("sql", """
+    INSERT INTO Sensor SET 
+    sensor_id = 'temp_01', 
+    timestamp = sysdate(), 
+    temperature = 23.5
+""")
+```
+
+### Vector Search (for AI/ML applications)
+
+```python
+# Store embeddings
+db.command("sql", """
+    CREATE VERTEX TYPE Document SET 
+    title = 'AI Research Paper',
+    embedding = [0.1, 0.2, 0.3, ...],  # Your vector embeddings
+    content = 'Full document text...'
+""")
+
+# Vector similarity search
+result = db.query("sql", """
+    SELECT title, content, 
+           cosine_similarity(embedding, [0.1, 0.2, 0.3, ...]) as similarity
+    FROM Document 
+    ORDER BY similarity DESC 
+    LIMIT 10
+""")
+```
+
+## Configuration Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `host` | str | "localhost" | ArcadeDB server hostname |
+| `port` | int | 2480 | ArcadeDB server port |
+| `username` | str | "root" | Database username |
+| `password` | str | None | Database password |
+| `database` | str | None | Database name |
+| `use_ssl` | bool | False | Enable SSL connection |
+| `timeout` | int | 30 | Request timeout in seconds |
+| `pool_size` | int | 10 | Connection pool size |
+
+## Requirements
+
+- **Python**: 3.8 or higher
+- **ArcadeDB**: Version 23.10 or higher
+- **Dependencies**: 
+  - `requests` >= 2.25.0
+  - `retry` >= 0.9.2
+
+## Development
+
+### Setting up Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/stevereiner/arcadedb-python.git
+cd arcadedb-python
+
+# Install uv (if not already installed)
+pip install uv
+
+# Create virtual environment and install dependencies
+uv venv
+uv pip install -e .[dev]
+
+# Run tests
+uv run pytest
+
+# Run linting
+uv run black .
+uv run isort .
+uv run flake8
+uv run mypy arcadedb_python
+```
+
+### Building the Package
+
+```bash
+# Build the package
+uv build
+
+# Check the built package
+uv run twine check dist/*
+```
+
+### Running ArcadeDB for Development
+
+```bash
+# Using Docker
+docker run -d --name arcadedb \
+  -p 2480:2480 -p 2424:2424 \
+  -e JAVA_OPTS="-Darcadedb.server.rootPassword=playwithdata" \
+  arcadedata/arcadedb:latest
+
+# Access ArcadeDB Studio at http://localhost:2480
+```
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+
+## Links
+
+### This Project
+- **GitHub**: https://github.com/stevereiner/arcadedb-python
+- **PyPI**: https://pypi.org/project/arcadedb-python/
+- **Issues**: https://github.com/stevereiner/arcadedb-python/issues
+
+### ArcadeDB
+- **Homepage**: https://arcadedb.com
+- **Documentation**: https://docs.arcadedb.com
+- **Main Repository**: https://github.com/ArcadeData/arcadedb
+
+### Original Contributors
+- **Adams Rosales**: https://github.com/adaros92/arcadedb-python-driver
+- **ExtReMLapin**: https://github.com/ExtReMLapin
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a detailed history of changes.

arcadedb_python-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+arcadedb_python/__init__.py,sha256=XyDDwYw1dSEfjoyqrli9bRD8uCnYZIKtGlgvZnwbjJE,1224
+arcadedb_python/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arcadedb_python/api/client.py,sha256=28AWHzrJQBgOsJmhAFnlNa-WkU-mh5Etgq77bEhuOxA,3058
+arcadedb_python/api/config.py,sha256=sjaGuf3xS516e3nTA1oNzJ2ybvJCC0KYyk4q01BSSls,1078
+arcadedb_python/api/sync.py,sha256=w7cwB97CFaFcXDYHTU0NuxibGGOBDGeaCSK8IXS28jY,4656
+arcadedb_python/dao/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arcadedb_python/dao/database.py,sha256=c0Ag8fhIkA9_syUtlmQWm_GXglCoGnJPVV6t7gJETOA,11819
+arcadedb_python/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arcadedb_python/model/database.py,sha256=XI24QKmTlYjd8jLZan-RMeo-KZf86niVCW_lp3L9ZEY,101
+arcadedb_python/model/request.py,sha256=qpnPmx2f3BAro0MMT9MWSvKC1OXnfeG2bbOY78J982Q,395
+arcadedb_python-0.2.0.dist-info/METADATA,sha256=GB7FbKLYDt4uCONvZ1CSLjPh0cbLVigyhfMifLb3izM,10106
+arcadedb_python-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+arcadedb_python-0.2.0.dist-info/licenses/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
+arcadedb_python-0.2.0.dist-info/RECORD,,

arcadedb_python-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

arcadedb_python-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.