commitdb 1.2.0__py3-none-any.whl

commitdb/__init__.py

@@ -0,0 +1,36 @@
+"""
+CommitDB Python Driver
+
+A Python client for connecting to CommitDB SQL Server.
+
+Usage:
+    from commitdb import CommitDB
+
+    db = CommitDB('localhost', 3306)
+    db.connect()
+
+    # Create database and table
+    db.execute('CREATE DATABASE mydb')
+    db.execute('CREATE TABLE mydb.users (id INT PRIMARY KEY, name STRING)')
+
+    # Insert data
+    db.execute("INSERT INTO mydb.users (id, name) VALUES (1, 'Alice')")
+
+    # Query data
+    result = db.query('SELECT * FROM mydb.users')
+    for row in result:
+        print(row)
+
+    db.close()
+
+Embedded mode (requires libcommitdb):
+    from commitdb import CommitDBLocal
+
+    with CommitDBLocal('/path/to/data') as db:
+        db.execute('CREATE DATABASE mydb')
+"""
+
+from .client import CommitDB, CommitDBLocal, QueryResult, CommitResult, CommitDBError
+
+__version__ = '0.1.0'
+__all__ = ['CommitDB', 'CommitDBLocal', 'QueryResult', 'CommitResult', 'CommitDBError']

commitdb/binding.py

@@ -0,0 +1,135 @@
+"""
+Python ctypes bindings for libcommitdb shared library.
+"""
+
+import ctypes
+import json
+import os
+import platform
+from pathlib import Path
+from typing import Optional
+
+
+def _find_library() -> Optional[str]:
+    """Find the libcommitdb shared library."""
+    system = platform.system()
+    
+    if system == 'Darwin':
+        lib_names = ['libcommitdb.dylib', 'libcommitdb-darwin-arm64.dylib', 'libcommitdb-darwin-amd64.dylib']
+    elif system == 'Linux':
+        lib_names = ['libcommitdb.so', 'libcommitdb-linux-amd64.so', 'libcommitdb-linux-arm64.so']
+    elif system == 'Windows':
+        lib_names = ['libcommitdb.dll']
+    else:
+        lib_names = ['libcommitdb.so', 'libcommitdb.dylib']
+    
+    # Search paths
+    search_paths = [
+        Path(__file__).parent / 'lib',  # Package lib directory (for pip installed)
+        Path(__file__).parent,  # Same directory as this file
+        Path(__file__).parent.parent / 'lib',  # drivers/python/lib
+        Path(__file__).parent.parent.parent.parent / 'lib',  # CommitDB/lib
+        Path.cwd() / 'lib',  # ./lib
+        Path.cwd(),  # Current directory
+    ]
+    
+    for path in search_paths:
+        for lib_name in lib_names:
+            lib_path = path / lib_name
+            if lib_path.exists():
+                return str(lib_path)
+    
+    return None
+
+
+class CommitDBBinding:
+    """Low-level ctypes bindings for libcommitdb."""
+    
+    _lib: Optional[ctypes.CDLL] = None
+    _lib_path: Optional[str] = None
+    
+    @classmethod
+    def load(cls, lib_path: Optional[str] = None) -> 'CommitDBBinding':
+        """Load the shared library."""
+        if lib_path is None:
+            lib_path = _find_library()
+        
+        if lib_path is None:
+            raise RuntimeError(
+                "Could not find libcommitdb shared library. "
+                "Build it with: make lib"
+            )
+        
+        cls._lib_path = lib_path
+        cls._lib = ctypes.CDLL(lib_path)
+        
+        # Define function signatures
+        cls._lib.commitdb_open_memory.argtypes = []
+        cls._lib.commitdb_open_memory.restype = ctypes.c_int
+        
+        cls._lib.commitdb_open_file.argtypes = [ctypes.c_char_p]
+        cls._lib.commitdb_open_file.restype = ctypes.c_int
+        
+        cls._lib.commitdb_close.argtypes = [ctypes.c_int]
+        cls._lib.commitdb_close.restype = None
+        
+        # Use c_void_p for the result pointer to avoid automatic conversion
+        cls._lib.commitdb_execute.argtypes = [ctypes.c_int, ctypes.c_char_p]
+        cls._lib.commitdb_execute.restype = ctypes.c_void_p
+        
+        cls._lib.commitdb_free.argtypes = [ctypes.c_void_p]
+        cls._lib.commitdb_free.restype = None
+        
+        return cls()
+    
+    @classmethod
+    def is_loaded(cls) -> bool:
+        """Check if the library is loaded."""
+        return cls._lib is not None
+    
+    @classmethod
+    def open_memory(cls) -> int:
+        """Open an in-memory database."""
+        if not cls.is_loaded():
+            cls.load()
+        handle = cls._lib.commitdb_open_memory()
+        if handle < 0:
+            raise RuntimeError("Failed to open in-memory database")
+        return handle
+    
+    @classmethod
+    def open_file(cls, path: str) -> int:
+        """Open a file-based database."""
+        if not cls.is_loaded():
+            cls.load()
+        handle = cls._lib.commitdb_open_file(path.encode('utf-8'))
+        if handle < 0:
+            raise RuntimeError(f"Failed to open database at {path}")
+        return handle
+    
+    @classmethod
+    def close(cls, handle: int) -> None:
+        """Close a database handle."""
+        if cls.is_loaded():
+            cls._lib.commitdb_close(handle)
+    
+    @classmethod
+    def execute(cls, handle: int, query: str) -> dict:
+        """Execute a query and return the JSON response."""
+        if not cls.is_loaded():
+            raise RuntimeError("Library not loaded")
+        
+        result_ptr = cls._lib.commitdb_execute(handle, query.encode('utf-8'))
+        if result_ptr is None or result_ptr == 0:
+            raise RuntimeError("Query execution failed")
+        
+        try:
+            # Cast void pointer to char pointer and read the string
+            result_str = ctypes.cast(result_ptr, ctypes.c_char_p).value
+            if result_str is None:
+                raise RuntimeError("Empty response from query")
+            result_json = result_str.decode('utf-8')
+            return json.loads(result_json)
+        finally:
+            # Free the allocated memory using the void pointer
+            cls._lib.commitdb_free(result_ptr)

commitdb/client.py

@@ -0,0 +1,379 @@
+"""
+CommitDB Client - Python driver for CommitDB SQL Server.
+"""
+
+import json
+import socket
+from dataclasses import dataclass, field
+from typing import Iterator, Optional
+
+
+class CommitDBError(Exception):
+    """Exception raised for CommitDB errors."""
+    pass
+
+
+@dataclass
+class QueryResult:
+    """Result from a SELECT query."""
+    columns: list[str]
+    data: list[list[str]]
+    records_read: int
+    time_ms: float
+
+    def __iter__(self) -> Iterator[dict[str, str]]:
+        """Iterate over rows as dictionaries."""
+        for row in self.data:
+            yield dict(zip(self.columns, row))
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, index: int) -> dict[str, str]:
+        return dict(zip(self.columns, self.data[index]))
+
+
+@dataclass
+class CommitResult:
+    """Result from a mutation operation (INSERT, UPDATE, DELETE, CREATE, DROP)."""
+    databases_created: int = 0
+    databases_deleted: int = 0
+    tables_created: int = 0
+    tables_deleted: int = 0
+    records_written: int = 0
+    records_deleted: int = 0
+    time_ms: float = 0.0
+
+    @property
+    def affected_rows(self) -> int:
+        """Total number of affected rows/objects."""
+        return (self.databases_created + self.databases_deleted +
+                self.tables_created + self.tables_deleted +
+                self.records_written + self.records_deleted)
+
+
+class CommitDB:
+    """
+    CommitDB Python client.
+
+    Example:
+        db = CommitDB('localhost', 3306)
+        db.connect()
+        result = db.query('SELECT * FROM mydb.users')
+        db.close()
+    """
+
+    def __init__(self, host: str = 'localhost', port: int = 3306):
+        """
+        Initialize CommitDB client.
+
+        Args:
+            host: Server hostname
+            port: Server port (default 3306)
+        """
+        self.host = host
+        self.port = port
+        self._socket: Optional[socket.socket] = None
+        self._buffer = b''
+
+    def connect(self, timeout: float = 10.0) -> 'CommitDB':
+        """
+        Connect to the CommitDB server.
+
+        Args:
+            timeout: Connection timeout in seconds
+
+        Returns:
+            self for method chaining
+        """
+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._socket.settimeout(timeout)
+        self._socket.connect((self.host, self.port))
+        return self
+
+    def close(self) -> None:
+        """Close the connection."""
+        if self._socket:
+            try:
+                self._socket.send(b'quit\n')
+            except Exception:
+                pass
+            self._socket.close()
+            self._socket = None
+
+    def __enter__(self) -> 'CommitDB':
+        return self.connect()
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    def _send(self, query: str) -> dict:
+        """Send a query and receive the response."""
+        if not self._socket:
+            raise CommitDBError("Not connected. Call connect() first.")
+
+        # Send query with newline
+        self._socket.send((query + '\n').encode('utf-8'))
+
+        # Read response until newline
+        while b'\n' not in self._buffer:
+            chunk = self._socket.recv(4096)
+            if not chunk:
+                raise CommitDBError("Connection closed by server")
+            self._buffer += chunk
+
+        # Split at first newline
+        line, self._buffer = self._buffer.split(b'\n', 1)
+
+        # Parse JSON response
+        try:
+            return json.loads(line.decode('utf-8'))
+        except json.JSONDecodeError as e:
+            raise CommitDBError(f"Invalid response from server: {e}")
+
+    def execute(self, query: str) -> CommitResult | QueryResult:
+        """
+        Execute a SQL query.
+
+        Args:
+            query: SQL query to execute
+
+        Returns:
+            QueryResult for SELECT queries, CommitResult for mutations
+        """
+        response = self._send(query)
+
+        if not response.get('success'):
+            raise CommitDBError(response.get('error', 'Unknown error'))
+
+        result_type = response.get('type')
+        result_data = response.get('result', {})
+
+        if result_type == 'query':
+            return QueryResult(
+                columns=result_data.get('columns', []),
+                data=result_data.get('data', []),
+                records_read=result_data.get('records_read', 0),
+                time_ms=result_data.get('time_ms', 0.0)
+            )
+        elif result_type == 'commit':
+            return CommitResult(
+                databases_created=result_data.get('databases_created', 0),
+                databases_deleted=result_data.get('databases_deleted', 0),
+                tables_created=result_data.get('tables_created', 0),
+                tables_deleted=result_data.get('tables_deleted', 0),
+                records_written=result_data.get('records_written', 0),
+                records_deleted=result_data.get('records_deleted', 0),
+                time_ms=result_data.get('time_ms', 0.0)
+            )
+        else:
+            # Unknown type, return empty commit result
+            return CommitResult()
+
+    def query(self, sql: str) -> QueryResult:
+        """
+        Execute a SELECT query and return results.
+
+        Args:
+            sql: SELECT query
+
+        Returns:
+            QueryResult with columns and data
+        """
+        result = self.execute(sql)
+        if not isinstance(result, QueryResult):
+            raise CommitDBError("Expected query result, got commit result")
+        return result
+
+    def create_database(self, name: str) -> CommitResult:
+        """Create a database."""
+        result = self.execute(f'CREATE DATABASE {name}')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+
+    def drop_database(self, name: str) -> CommitResult:
+        """Drop a database."""
+        result = self.execute(f'DROP DATABASE {name}')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+
+    def create_table(self, database: str, table: str, columns: str) -> CommitResult:
+        """
+        Create a table.
+
+        Args:
+            database: Database name
+            table: Table name
+            columns: Column definitions, e.g. "id INT PRIMARY KEY, name STRING"
+        """
+        result = self.execute(f'CREATE TABLE {database}.{table} ({columns})')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+
+    def insert(self, database: str, table: str, columns: list[str], values: list) -> CommitResult:
+        """
+        Insert a row.
+
+        Args:
+            database: Database name
+            table: Table name
+            columns: List of column names
+            values: List of values (strings will be quoted)
+        """
+        cols = ', '.join(columns)
+        vals = ', '.join(
+            f"'{v}'" if isinstance(v, str) else str(v)
+            for v in values
+        )
+        result = self.execute(f'INSERT INTO {database}.{table} ({cols}) VALUES ({vals})')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+
+    def show_databases(self) -> list[str]:
+        """List all databases."""
+        result = self.query('SHOW DATABASES')
+        return [row[0] for row in result.data] if result.data else []
+
+    def show_tables(self, database: str) -> list[str]:
+        """List all tables in a database."""
+        result = self.query(f'SHOW TABLES IN {database}')
+        return [row[0] for row in result.data] if result.data else []
+
+
+class CommitDBLocal:
+    """
+    CommitDB embedded client using Go bindings.
+    
+    This mode runs the database engine directly in-process without
+    requiring a separate server.
+
+    Example:
+        # In-memory database
+        db = CommitDBLocal()
+        
+        # File-based database
+        db = CommitDBLocal('/path/to/data')
+        
+        db.execute('CREATE DATABASE mydb')
+        result = db.query('SELECT * FROM mydb.users')
+        db.close()
+    """
+
+    def __init__(self, path: Optional[str] = None, lib_path: Optional[str] = None):
+        """
+        Initialize CommitDB embedded client.
+
+        Args:
+            path: Path for file-based persistence. If None, uses in-memory storage.
+            lib_path: Optional path to libcommitdb shared library.
+        """
+        from .binding import CommitDBBinding
+        
+        self._binding = CommitDBBinding
+        if lib_path:
+            self._binding.load(lib_path)
+        
+        self._path = path
+        self._handle: Optional[int] = None
+
+    def open(self) -> 'CommitDBLocal':
+        """Open the database."""
+        if self._path:
+            self._handle = self._binding.open_file(self._path)
+        else:
+            self._handle = self._binding.open_memory()
+        return self
+
+    def close(self) -> None:
+        """Close the database."""
+        if self._handle is not None:
+            self._binding.close(self._handle)
+            self._handle = None
+
+    def __enter__(self) -> 'CommitDBLocal':
+        return self.open()
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    def _parse_response(self, response: dict) -> CommitResult | QueryResult:
+        """Parse a response dict into result objects."""
+        if not response.get('success'):
+            raise CommitDBError(response.get('error', 'Unknown error'))
+
+        result_type = response.get('type')
+        result_data = response.get('result', {})
+
+        if result_type == 'query':
+            return QueryResult(
+                columns=result_data.get('columns', []),
+                data=result_data.get('data', []),
+                records_read=result_data.get('records_read', 0),
+                time_ms=result_data.get('time_ms', 0.0)
+            )
+        elif result_type == 'commit':
+            return CommitResult(
+                databases_created=result_data.get('databases_created', 0),
+                databases_deleted=result_data.get('databases_deleted', 0),
+                tables_created=result_data.get('tables_created', 0),
+                tables_deleted=result_data.get('tables_deleted', 0),
+                records_written=result_data.get('records_written', 0),
+                records_deleted=result_data.get('records_deleted', 0),
+                time_ms=result_data.get('time_ms', 0.0)
+            )
+        else:
+            return CommitResult()
+
+    def execute(self, query: str) -> CommitResult | QueryResult:
+        """
+        Execute a SQL query.
+
+        Args:
+            query: SQL query to execute
+
+        Returns:
+            QueryResult for SELECT queries, CommitResult for mutations
+        """
+        if self._handle is None:
+            raise CommitDBError("Database not open. Call open() first.")
+        
+        response = self._binding.execute(self._handle, query)
+        return self._parse_response(response)
+
+    def query(self, sql: str) -> QueryResult:
+        """Execute a SELECT query and return results."""
+        result = self.execute(sql)
+        if not isinstance(result, QueryResult):
+            raise CommitDBError("Expected query result, got commit result")
+        return result
+
+    def create_database(self, name: str) -> CommitResult:
+        """Create a database."""
+        result = self.execute(f'CREATE DATABASE {name}')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+
+    def create_table(self, database: str, table: str, columns: str) -> CommitResult:
+        """Create a table."""
+        result = self.execute(f'CREATE TABLE {database}.{table} ({columns})')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+
+    def insert(self, database: str, table: str, columns: list[str], values: list) -> CommitResult:
+        """Insert a row."""
+        cols = ', '.join(columns)
+        vals = ', '.join(
+            f"'{v}'" if isinstance(v, str) else str(v)
+            for v in values
+        )
+        result = self.execute(f'INSERT INTO {database}.{table} ({cols}) VALUES ({vals})')
+        if not isinstance(result, CommitResult):
+            raise CommitDBError("Expected commit result")
+        return result
+

commitdb-1.2.0.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: commitdb
+Version: 1.2.0
+Summary: Python driver for CommitDB SQL Server
+Author: CommitDB Contributors
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/nickyhof/CommitDB
+Project-URL: Documentation, https://github.com/nickyhof/CommitDB#readme
+Project-URL: Repository, https://github.com/nickyhof/CommitDB
+Keywords: database,sql,git,commitdb
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# CommitDB Python Driver
+
+Python client for connecting to CommitDB SQL Server.
+
+## Installation
+
+```bash
+pip install -e drivers/python
+```
+
+## Quick Start
+
+```python
+from commitdb import CommitDB
+
+# Connect to server
+db = CommitDB('localhost', 3306)
+db.connect()
+
+# Or use context manager
+with CommitDB('localhost', 3306) as db:
+    # Create database and table
+    db.execute('CREATE DATABASE mydb')
+    db.execute('CREATE TABLE mydb.users (id INT PRIMARY KEY, name STRING)')
+
+    # Insert data
+    db.execute("INSERT INTO mydb.users (id, name) VALUES (1, 'Alice')")
+    db.execute("INSERT INTO mydb.users (id, name) VALUES (2, 'Bob')")
+
+    # Query data
+    result = db.query('SELECT * FROM mydb.users')
+    print(f"Columns: {result.columns}")
+    print(f"Rows: {len(result)}")
+
+    # Iterate over rows as dictionaries
+    for row in result:
+        print(f"  {row['id']}: {row['name']}")
+
+    # Use convenience methods
+    db.insert('mydb', 'users', ['id', 'name'], [3, 'Charlie'])
+    tables = db.show_tables('mydb')
+```
+
+## API Reference
+
+### CommitDB
+
+```python
+CommitDB(host='localhost', port=3306)
+```
+
+**Methods:**
+
+- `connect(timeout=10.0)` - Connect to server
+- `close()` - Close connection
+- `execute(sql)` - Execute any SQL query
+- `query(sql)` - Execute SELECT query, returns QueryResult
+- `create_database(name)` - Create a database
+- `drop_database(name)` - Drop a database
+- `create_table(database, table, columns)` - Create a table
+- `insert(database, table, columns, values)` - Insert a row
+- `show_databases()` - List databases
+- `show_tables(database)` - List tables
+
+### QueryResult
+
+```python
+result = db.query('SELECT * FROM mydb.users')
+result.columns  # ['id', 'name']
+result.data     # [['1', 'Alice'], ['2', 'Bob']]
+len(result)     # 2
+result[0]       # {'id': '1', 'name': 'Alice'}
+for row in result:
+    print(row)  # {'id': '1', 'name': 'Alice'}
+```
+
+### CommitResult
+
+```python
+result = db.execute('INSERT INTO mydb.users ...')
+result.records_written   # 1
+result.affected_rows     # 1
+result.time_ms           # 1.5
+```
+
+## Embedded Mode (CommitDBLocal)
+
+Run CommitDB directly in-process without a separate server. Requires the `libcommitdb` shared library.
+
+### Quick Start
+
+```python
+from commitdb import CommitDBLocal
+
+# In-memory database (no persistence)
+with CommitDBLocal() as db:
+    db.execute('CREATE DATABASE mydb')
+    db.execute('CREATE TABLE mydb.users (id INT PRIMARY KEY, name STRING)')
+    db.execute("INSERT INTO mydb.users (id, name) VALUES (1, 'Alice')")
+    result = db.query('SELECT * FROM mydb.users')
+
+# File-based persistence
+with CommitDBLocal('/path/to/data') as db:
+    db.execute('CREATE DATABASE mydb')
+    # Data persists between sessions
+```
+
+### Building the Shared Library
+
+If the library isn't bundled with your pip install:
+
+```bash
+# From CommitDB root
+make lib  # Creates lib/libcommitdb.dylib (macOS) or .so (Linux)
+```
+
+### CommitDBLocal API
+
+```python
+CommitDBLocal(path=None, lib_path=None)
+```
+
+**Parameters:**
+- `path` - Directory for file-based persistence. If `None`, uses in-memory storage.
+- `lib_path` - Optional path to `libcommitdb` shared library.
+
+**Methods:**
+- `open()` - Open the database
+- `close()` - Close the database
+- `execute(sql)` - Execute any SQL query
+- `query(sql)` - Execute SELECT query
+- `create_database(name)` - Create a database
+- `create_table(database, table, columns)` - Create a table
+- `insert(database, table, columns, values)` - Insert a row
+
+### Example: Full CRUD
+
+```python
+from commitdb import CommitDBLocal
+
+with CommitDBLocal() as db:
+    # Create
+    db.create_database('app')
+    db.create_table('app', 'users', 'id INT PRIMARY KEY, name STRING, email STRING')
+    
+    # Insert
+    db.insert('app', 'users', ['id', 'name', 'email'], [1, 'Alice', 'alice@example.com'])
+    db.insert('app', 'users', ['id', 'name', 'email'], [2, 'Bob', 'bob@example.com'])
+    
+    # Read
+    result = db.query('SELECT * FROM app.users')
+    for row in result:
+        print(f"{row['name']}: {row['email']}")
+    
+    # Update
+    db.execute("UPDATE app.users SET email = 'alice@new.com' WHERE id = 1")
+    
+    # Delete
+    db.execute('DELETE FROM app.users WHERE id = 2')
+```
+

commitdb-1.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+commitdb/__init__.py,sha256=A0vyiCY3du55mA9914aRAd9PoAQMM3SrcBf_Ek3aNQs,916
+commitdb/binding.py,sha256=_PaafsoHxGgpZSOd27FkymM4x6BhwK07XZPXVxjvALU,4585
+commitdb/client.py,sha256=PZvPAnKUEefzJmGJhoG-qYy9g91kPYQB-G1PGQ7_a3s,12465
+commitdb/lib/libcommitdb-linux-amd64.so,sha256=AOblBS3zyXqMLyjxYFzYcyH00xc-z6-T1o4hjNgeIz8,14729328
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_client.py,sha256=c4L72UbKP5sBg2AHerJ5jJchWL7jE89JBga4MlQVfDQ,7385
+commitdb-1.2.0.dist-info/METADATA,sha256=8_tiO1o0IL4suMHzvSVh5O7ACqKnDnMsqdCJb4HbnHo,5041
+commitdb-1.2.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+commitdb-1.2.0.dist-info/top_level.txt,sha256=hxbEo9CCoDzsT0VaAiV1QViidkmyaBJtUDtCFOBH-t8,15
+commitdb-1.2.0.dist-info/RECORD,,

commitdb-1.2.0.dist-info/WHEEL

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

commitdb-1.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+commitdb
+tests

tests/test_client.py

@@ -0,0 +1,221 @@
+"""
+Tests for CommitDB Python driver.
+
+To run with a live server:
+    1. Start the server: go run ./cmd/server
+    2. Run tests: pytest drivers/python/tests/
+"""
+
+import pytest
+from commitdb import CommitDB, QueryResult, CommitResult, CommitDBError
+
+
+class TestQueryResult:
+    """Tests for QueryResult class."""
+
+    def test_iteration(self):
+        result = QueryResult(
+            columns=['id', 'name'],
+            data=[['1', 'Alice'], ['2', 'Bob']],
+            records_read=2,
+            time_ms=1.0
+        )
+
+        rows = list(result)
+        assert rows == [
+            {'id': '1', 'name': 'Alice'},
+            {'id': '2', 'name': 'Bob'}
+        ]
+
+    def test_len(self):
+        result = QueryResult(
+            columns=['id'],
+            data=[['1'], ['2'], ['3']],
+            records_read=3,
+            time_ms=1.0
+        )
+        assert len(result) == 3
+
+    def test_getitem(self):
+        result = QueryResult(
+            columns=['id', 'name'],
+            data=[['1', 'Alice'], ['2', 'Bob']],
+            records_read=2,
+            time_ms=1.0
+        )
+        assert result[0] == {'id': '1', 'name': 'Alice'}
+        assert result[1] == {'id': '2', 'name': 'Bob'}
+
+
+class TestCommitResult:
+    """Tests for CommitResult class."""
+
+    def test_affected_rows(self):
+        result = CommitResult(
+            databases_created=1,
+            tables_created=2,
+            records_written=3
+        )
+        assert result.affected_rows == 6
+
+    def test_defaults(self):
+        result = CommitResult()
+        assert result.affected_rows == 0
+        assert result.time_ms == 0.0
+
+
+class TestCommitDBUnit:
+    """Unit tests for CommitDB client (no server required)."""
+
+    def test_init(self):
+        db = CommitDB('localhost', 3306)
+        assert db.host == 'localhost'
+        assert db.port == 3306
+
+    def test_not_connected_error(self):
+        db = CommitDB('localhost', 3306)
+        with pytest.raises(CommitDBError, match="Not connected"):
+            db.execute("SELECT 1")
+
+
+# Integration tests require a running server
+# These run automatically in CI where the server is started
+
+import os
+SKIP_INTEGRATION = os.environ.get('COMMITDB_SERVER_URL') is None and os.environ.get('CI') is None
+
+
+@pytest.mark.skipif(SKIP_INTEGRATION, reason="Server not running - set COMMITDB_SERVER_URL or CI env var")
+class TestCommitDBIntegration:
+    """Integration tests (requires running server)."""
+
+    @pytest.fixture
+    def db(self):
+        host = os.environ.get('COMMITDB_HOST', 'localhost')
+        port = int(os.environ.get('COMMITDB_PORT', '3306'))
+        db = CommitDB(host, port)
+        db.connect()
+        yield db
+        db.close()
+
+    def test_create_database(self, db):
+        result = db.execute('CREATE DATABASE pytest_int_test1')
+        assert isinstance(result, CommitResult)
+        assert result.databases_created == 1
+
+    def test_create_table(self, db):
+        db.execute('CREATE DATABASE pytest_int_test2')
+        result = db.execute('CREATE TABLE pytest_int_test2.users (id INT PRIMARY KEY, name STRING)')
+        assert isinstance(result, CommitResult)
+        assert result.tables_created == 1
+
+    def test_insert_and_query(self, db):
+        db.execute('CREATE DATABASE pytest_int_test3')
+        db.execute('CREATE TABLE pytest_int_test3.items (id INT PRIMARY KEY, value STRING)')
+        db.execute("INSERT INTO pytest_int_test3.items (id, value) VALUES (1, 'hello')")
+
+        result = db.query('SELECT * FROM pytest_int_test3.items')
+        assert isinstance(result, QueryResult)
+        assert len(result) == 1
+        assert result[0] == {'id': '1', 'value': 'hello'}
+
+
+
+
+# Embedded mode tests (require libcommitdb shared library)
+# Run with: make lib && pytest drivers/python/tests/ -v
+
+import os
+from pathlib import Path
+
+# Try to find the shared library
+def _find_lib():
+    lib_paths = [
+        Path(__file__).parent.parent.parent.parent.parent / 'lib' / 'libcommitdb.dylib',
+        Path(__file__).parent.parent.parent.parent.parent / 'lib' / 'libcommitdb.so',
+    ]
+    for p in lib_paths:
+        if p.exists():
+            return str(p)
+    return None
+
+LIB_PATH = _find_lib()
+
+
+@pytest.mark.skipif(LIB_PATH is None, reason="libcommitdb not found - run 'make lib' first")
+class TestCommitDBLocal:
+    """Tests for embedded mode using Go bindings."""
+
+    @pytest.fixture
+    def db(self):
+        from commitdb import CommitDBLocal
+        db = CommitDBLocal(lib_path=LIB_PATH)
+        db.open()
+        yield db
+        db.close()
+
+    def test_create_database(self, db):
+        result = db.execute('CREATE DATABASE local_test1')
+        assert isinstance(result, CommitResult)
+        assert result.databases_created == 1
+
+    def test_create_table(self, db):
+        db.execute('CREATE DATABASE local_test2')
+        result = db.execute('CREATE TABLE local_test2.users (id INT PRIMARY KEY, name STRING)')
+        assert isinstance(result, CommitResult)
+        assert result.tables_created == 1
+
+    def test_insert_and_query(self, db):
+        db.execute('CREATE DATABASE local_test3')
+        db.execute('CREATE TABLE local_test3.items (id INT PRIMARY KEY, value STRING)')
+        db.execute("INSERT INTO local_test3.items (id, value) VALUES (1, 'hello')")
+        db.execute("INSERT INTO local_test3.items (id, value) VALUES (2, 'world')")
+
+        result = db.query('SELECT * FROM local_test3.items')
+        assert isinstance(result, QueryResult)
+        assert len(result) == 2
+        assert result[0] == {'id': '1', 'value': 'hello'}
+        assert result[1] == {'id': '2', 'value': 'world'}
+
+    def test_update(self, db):
+        db.execute('CREATE DATABASE local_test4')
+        db.execute('CREATE TABLE local_test4.data (id INT PRIMARY KEY, val STRING)')
+        db.execute("INSERT INTO local_test4.data (id, val) VALUES (1, 'old')")
+        
+        result = db.execute("UPDATE local_test4.data SET val = 'new' WHERE id = 1")
+        assert isinstance(result, CommitResult)
+
+        result = db.query('SELECT * FROM local_test4.data WHERE id = 1')
+        assert result[0]['val'] == 'new'
+
+    def test_delete(self, db):
+        db.execute('CREATE DATABASE local_test5')
+        db.execute('CREATE TABLE local_test5.data (id INT PRIMARY KEY)')
+        db.execute('INSERT INTO local_test5.data (id) VALUES (1)')
+        db.execute('INSERT INTO local_test5.data (id) VALUES (2)')
+        
+        db.execute('DELETE FROM local_test5.data WHERE id = 1')
+        
+        result = db.query('SELECT * FROM local_test5.data')
+        assert len(result) == 1
+        assert result[0]['id'] == '2'
+
+    def test_context_manager(self):
+        from commitdb import CommitDBLocal
+        with CommitDBLocal(lib_path=LIB_PATH) as db:
+            result = db.execute('CREATE DATABASE local_test6')
+            assert result.databases_created == 1
+
+    def test_convenience_methods(self, db):
+        db.create_database('local_test7')
+        db.create_table('local_test7', 'users', 'id INT PRIMARY KEY, name STRING')
+        db.insert('local_test7', 'users', ['id', 'name'], [1, 'Alice'])
+        
+        result = db.query('SELECT * FROM local_test7.users')
+        assert len(result) == 1
+        assert result[0] == {'id': '1', 'name': 'Alice'}
+
+    def test_error_handling(self, db):
+        with pytest.raises(CommitDBError):
+            db.query('SELECT * FROM nonexistent.table')
+