commitdb 1.1.2__tar.gz

commitdb-1.1.2/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: commitdb
+Version: 1.1.2
+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
+```

commitdb-1.1.2/README.md

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

commitdb-1.1.2/commitdb/__init__.py

@@ -0,0 +1,30 @@
+"""
+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()
+"""
+
+from .client import CommitDB, QueryResult, CommitResult, CommitDBError
+
+__version__ = '0.1.0'
+__all__ = ['CommitDB', 'QueryResult', 'CommitResult', 'CommitDBError']

commitdb-1.1.2/commitdb/client.py

@@ -0,0 +1,244 @@
+"""
+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 []

commitdb-1.1.2/commitdb.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: commitdb
+Version: 1.1.2
+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
+```

commitdb-1.1.2/commitdb.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+commitdb/__init__.py
+commitdb/client.py
+commitdb.egg-info/PKG-INFO
+commitdb.egg-info/SOURCES.txt
+commitdb.egg-info/dependency_links.txt
+commitdb.egg-info/requires.txt
+commitdb.egg-info/top_level.txt
+tests/__init__.py
+tests/test_client.py

commitdb-1.1.2/commitdb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

commitdb-1.1.2/commitdb.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0

commitdb-1.1.2/commitdb.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+commitdb
+dist
+tests

commitdb-1.1.2/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "commitdb"
+version = "1.1.2"
+description = "Python driver for CommitDB SQL Server"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+authors = [
+    {name = "CommitDB Contributors"}
+]
+keywords = ["database", "sql", "git", "commitdb"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/nickyhof/CommitDB"
+Documentation = "https://github.com/nickyhof/CommitDB#readme"
+Repository = "https://github.com/nickyhof/CommitDB"
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]

commitdb-1.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

commitdb-1.1.2/tests/test_client.py

@@ -0,0 +1,113 @@
+"""
+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
+# Uncomment and run with: pytest drivers/python/tests/ -v
+
+# class TestCommitDBIntegration:
+#     """Integration tests (requires running server)."""
+#
+#     @pytest.fixture
+#     def db(self):
+#         db = CommitDB('localhost', 3306)
+#         db.connect()
+#         yield db
+#         db.close()
+#
+#     def test_create_database(self, db):
+#         result = db.execute('CREATE DATABASE pytest_test')
+#         assert isinstance(result, CommitResult)
+#         assert result.databases_created == 1
+#
+#     def test_create_table(self, db):
+#         db.execute('CREATE DATABASE pytest_test2')
+#         result = db.execute('CREATE TABLE pytest_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_test3')
+#         db.execute('CREATE TABLE pytest_test3.items (id INT PRIMARY KEY, value STRING)')
+#         db.execute("INSERT INTO pytest_test3.items (id, value) VALUES (1, 'hello')")
+#
+#         result = db.query('SELECT * FROM pytest_test3.items')
+#         assert isinstance(result, QueryResult)
+#         assert len(result) == 1
+#         assert result[0] == {'id': '1', 'value': 'hello'}