alt-python-pynosqlc-cassandra 1.0.4__tar.gz

alt_python_pynosqlc_cassandra-1.0.4/.gitignore

@@ -0,0 +1,30 @@
+
+# ── GSD baseline (auto-generated) ──
+.gsd
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*~
+.idea/
+.vscode/
+*.code-workspace
+.env
+.env.*
+!.env.example
+node_modules/
+.next/
+dist/
+build/
+__pycache__/
+*.pyc
+.venv/
+venv/
+target/
+vendor/
+*.log
+coverage/
+.cache/
+tmp/
+
+/.bg-shell/

alt_python_pynosqlc_cassandra-1.0.4/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: alt-python-pynosqlc-cassandra
+Version: 1.0.4
+Summary: Cassandra driver for pynosqlc
+Project-URL: Homepage, https://github.com/alt-python/pynosqlc
+Project-URL: Repository, https://github.com/alt-python/pynosqlc
+Project-URL: Documentation, https://github.com/alt-python/pynosqlc#getting-started
+Project-URL: Bug Tracker, https://github.com/alt-python/pynosqlc/issues
+Author: Craig Parravicini, Claude (Anthropic)
+License: MIT
+Keywords: async,cassandra,database,driver,nosql
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: alt-python-pynosqlc-core
+Requires-Dist: alt-python-pynosqlc-memory
+Requires-Dist: cassandra-driver>=3.29.1
+Description-Content-Type: text/markdown
+
+# pynosqlc-cassandra
+
+Cassandra 4 driver for [pynosqlc](https://github.com/alt-python/pynosqlc) — a
+JDBC-inspired unified async NoSQL access layer for Python.
+
+Install this driver to connect pynosqlc to a Cassandra 4 instance using the
+cassandra-driver library, bridged into Python's asyncio via
+`asyncio.run_in_executor`. All pynosqlc operations — `store`, `get`, `insert`,
+`update`, `delete`, and `find` — are supported.
+
+## Requirements
+
+- Python 3.12+
+- Cassandra 4.0+ instance (local or remote)
+- `pynosqlc-core` and `pynosqlc-memory` (installed automatically as dependencies)
+
+## Installation
+
+```bash
+pip install alt-python-pynosqlc-cassandra
+```
+
+## Quick Start
+
+```python
+import asyncio
+from pynosqlc.core import DriverManager, Filter
+import pynosqlc.cassandra  # auto-registers CassandraDriver on import
+
+async def main():
+    async with await DriverManager.get_client(
+        'pynosqlc:cassandra:localhost:9042/my_keyspace'
+    ) as client:
+        col = client.get_collection('orders')
+
+        # Store a document at a known key (upsert semantics)
+        await col.store('order-001', {'item': 'widget', 'qty': 5, 'status': 'pending'})
+
+        # Retrieve a document by key
+        doc = await col.get('order-001')
+        print(doc)  # {'item': 'widget', 'qty': 5, 'status': 'pending', '_id': 'order-001'}
+
+        # Insert a document with a driver-assigned key
+        key = await col.insert({'item': 'gadget', 'qty': 2, 'status': 'pending'})
+        print(key)  # e.g. 'a1b2c3d4-...'
+
+        # Update fields (shallow merge — only listed fields change)
+        await col.update('order-001', {'qty': 10, 'status': 'shipped'})
+
+        # Find documents matching a filter
+        f = Filter.where('status').eq('pending').build()
+        async for doc in await col.find(f):
+            print(doc)
+
+        # Delete a document
+        await col.delete('order-001')
+
+asyncio.run(main())
+```
+
+## URL Scheme
+
+```
+pynosqlc:cassandra:<host>:<port>/<keyspace>
+```
+
+| URL | Description |
+|-----|-------------|
+| `pynosqlc:cassandra:localhost:9042/my_keyspace` | Local Cassandra, named keyspace |
+| `pynosqlc:cassandra:cassandra.example.com:9042/prod` | Remote instance |
+
+The `<keyspace>` segment is required. If the keyspace does not exist, the driver
+creates it automatically using `SimpleStrategy` with replication factor 1. For
+production use, create the keyspace manually with appropriate replication
+settings before connecting.
+
+## Schema
+
+Each pynosqlc collection maps to a Cassandra table in the configured keyspace:
+
+```cql
+CREATE TABLE IF NOT EXISTS <collection_name> (
+    pk   TEXT PRIMARY KEY,
+    data TEXT
+);
+```
+
+- `pk` — the document key (string)
+- `data` — the document serialised as a JSON string
+
+Tables are created automatically on the first operation against a collection.
+You do not need to create tables manually.
+
+## Filtering
+
+Filters are evaluated **in-process** after a full table scan. `find()` fetches
+every row from the collection table, deserialises the `data` column, then
+applies the pynosqlc filter AST in memory using `MemoryFilterEvaluator`. There
+is no CQL WHERE clause generated.
+
+This matches the design of the jsnosqlc Cassandra driver and is appropriate for
+development, testing, and moderate-sized collections. For production workloads
+with large tables, evaluate CQL secondary indexes or materialised views as
+complementary tools.
+
+All filter operators are supported: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`,
+`contains`, `in_`, `nin`, `exists`, and their `and_` / `or_` / `not_`
+combinators.
+
+## Async Integration
+
+cassandra-driver uses a synchronous API. This driver wraps every blocking CQL
+call in `asyncio.get_event_loop().run_in_executor(None, ...)` so the asyncio
+event loop is never blocked. The default cassandra-driver reactor
+(thread-based) is used. Do not set `connection_class=AsyncioConnection` —
+`AsyncioConnection` hooks into the event loop from the main thread and cannot
+be used from a thread-pool executor.
+
+## Troubleshooting
+
+**`NoHostAvailable` or `ConnectionException` on connect**
+Cassandra is not running or is not reachable on the configured host and port.
+Verify with `cqlsh <host> <port>` — you should reach the CQL shell prompt.
+
+**`ImportError: No module named 'pynosqlc.cassandra'`**
+The package is not installed. Run `pip install alt-python-pynosqlc-cassandra`.
+
+**`ValueError: No driver found for URL ...`**
+The import `import pynosqlc.cassandra` was not executed before calling
+`DriverManager.get_client(...)`. The import is what triggers driver
+registration — it must come before any `get_client` call.
+
+**`InvalidRequest: Keyspace '<name>' does not exist`**
+This should not occur in normal use because the driver creates the keyspace
+automatically. If you see this error, check that the connecting user has
+`CREATE KEYSPACE` permission, or create the keyspace manually:
+
+```cql
+CREATE KEYSPACE my_keyspace
+  WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};
+```
+
+**Filter returns no results despite documents being present**
+Confirm you called `.build()` at the end of your filter chain:
+`Filter.where('field').eq('value').build()`. Passing an unbuilt `FieldCondition`
+object instead of the built `dict` will match nothing.
+
+## Further Reading
+
+- [pynosqlc API reference](../../docs/api-reference.md) — complete method signatures
+- [Driver implementation guide](../../docs/driver-guide.md) — how pynosqlc drivers work
+- [Getting started tutorial](../../docs/getting-started.md) — step-by-step introduction

alt_python_pynosqlc_cassandra-1.0.4/README.md

@@ -0,0 +1,152 @@
+# pynosqlc-cassandra
+
+Cassandra 4 driver for [pynosqlc](https://github.com/alt-python/pynosqlc) — a
+JDBC-inspired unified async NoSQL access layer for Python.
+
+Install this driver to connect pynosqlc to a Cassandra 4 instance using the
+cassandra-driver library, bridged into Python's asyncio via
+`asyncio.run_in_executor`. All pynosqlc operations — `store`, `get`, `insert`,
+`update`, `delete`, and `find` — are supported.
+
+## Requirements
+
+- Python 3.12+
+- Cassandra 4.0+ instance (local or remote)
+- `pynosqlc-core` and `pynosqlc-memory` (installed automatically as dependencies)
+
+## Installation
+
+```bash
+pip install alt-python-pynosqlc-cassandra
+```
+
+## Quick Start
+
+```python
+import asyncio
+from pynosqlc.core import DriverManager, Filter
+import pynosqlc.cassandra  # auto-registers CassandraDriver on import
+
+async def main():
+    async with await DriverManager.get_client(
+        'pynosqlc:cassandra:localhost:9042/my_keyspace'
+    ) as client:
+        col = client.get_collection('orders')
+
+        # Store a document at a known key (upsert semantics)
+        await col.store('order-001', {'item': 'widget', 'qty': 5, 'status': 'pending'})
+
+        # Retrieve a document by key
+        doc = await col.get('order-001')
+        print(doc)  # {'item': 'widget', 'qty': 5, 'status': 'pending', '_id': 'order-001'}
+
+        # Insert a document with a driver-assigned key
+        key = await col.insert({'item': 'gadget', 'qty': 2, 'status': 'pending'})
+        print(key)  # e.g. 'a1b2c3d4-...'
+
+        # Update fields (shallow merge — only listed fields change)
+        await col.update('order-001', {'qty': 10, 'status': 'shipped'})
+
+        # Find documents matching a filter
+        f = Filter.where('status').eq('pending').build()
+        async for doc in await col.find(f):
+            print(doc)
+
+        # Delete a document
+        await col.delete('order-001')
+
+asyncio.run(main())
+```
+
+## URL Scheme
+
+```
+pynosqlc:cassandra:<host>:<port>/<keyspace>
+```
+
+| URL | Description |
+|-----|-------------|
+| `pynosqlc:cassandra:localhost:9042/my_keyspace` | Local Cassandra, named keyspace |
+| `pynosqlc:cassandra:cassandra.example.com:9042/prod` | Remote instance |
+
+The `<keyspace>` segment is required. If the keyspace does not exist, the driver
+creates it automatically using `SimpleStrategy` with replication factor 1. For
+production use, create the keyspace manually with appropriate replication
+settings before connecting.
+
+## Schema
+
+Each pynosqlc collection maps to a Cassandra table in the configured keyspace:
+
+```cql
+CREATE TABLE IF NOT EXISTS <collection_name> (
+    pk   TEXT PRIMARY KEY,
+    data TEXT
+);
+```
+
+- `pk` — the document key (string)
+- `data` — the document serialised as a JSON string
+
+Tables are created automatically on the first operation against a collection.
+You do not need to create tables manually.
+
+## Filtering
+
+Filters are evaluated **in-process** after a full table scan. `find()` fetches
+every row from the collection table, deserialises the `data` column, then
+applies the pynosqlc filter AST in memory using `MemoryFilterEvaluator`. There
+is no CQL WHERE clause generated.
+
+This matches the design of the jsnosqlc Cassandra driver and is appropriate for
+development, testing, and moderate-sized collections. For production workloads
+with large tables, evaluate CQL secondary indexes or materialised views as
+complementary tools.
+
+All filter operators are supported: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`,
+`contains`, `in_`, `nin`, `exists`, and their `and_` / `or_` / `not_`
+combinators.
+
+## Async Integration
+
+cassandra-driver uses a synchronous API. This driver wraps every blocking CQL
+call in `asyncio.get_event_loop().run_in_executor(None, ...)` so the asyncio
+event loop is never blocked. The default cassandra-driver reactor
+(thread-based) is used. Do not set `connection_class=AsyncioConnection` —
+`AsyncioConnection` hooks into the event loop from the main thread and cannot
+be used from a thread-pool executor.
+
+## Troubleshooting
+
+**`NoHostAvailable` or `ConnectionException` on connect**
+Cassandra is not running or is not reachable on the configured host and port.
+Verify with `cqlsh <host> <port>` — you should reach the CQL shell prompt.
+
+**`ImportError: No module named 'pynosqlc.cassandra'`**
+The package is not installed. Run `pip install alt-python-pynosqlc-cassandra`.
+
+**`ValueError: No driver found for URL ...`**
+The import `import pynosqlc.cassandra` was not executed before calling
+`DriverManager.get_client(...)`. The import is what triggers driver
+registration — it must come before any `get_client` call.
+
+**`InvalidRequest: Keyspace '<name>' does not exist`**
+This should not occur in normal use because the driver creates the keyspace
+automatically. If you see this error, check that the connecting user has
+`CREATE KEYSPACE` permission, or create the keyspace manually:
+
+```cql
+CREATE KEYSPACE my_keyspace
+  WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};
+```
+
+**Filter returns no results despite documents being present**
+Confirm you called `.build()` at the end of your filter chain:
+`Filter.where('field').eq('value').build()`. Passing an unbuilt `FieldCondition`
+object instead of the built `dict` will match nothing.
+
+## Further Reading
+
+- [pynosqlc API reference](../../docs/api-reference.md) — complete method signatures
+- [Driver implementation guide](../../docs/driver-guide.md) — how pynosqlc drivers work
+- [Getting started tutorial](../../docs/getting-started.md) — step-by-step introduction

alt_python_pynosqlc_cassandra-1.0.4/pynosqlc/cassandra/__init__.py

@@ -0,0 +1,17 @@
+"""
+pynosqlc.cassandra — Cassandra driver for pynosqlc.
+
+Handles URLs of the form: pynosqlc:cassandra:host:port/keyspace
+
+Auto-registers ``CassandraDriver`` with ``DriverManager`` on import via
+the ``cassandra_driver`` module.
+"""
+
+from __future__ import annotations
+
+from pynosqlc.cassandra import cassandra_driver  # noqa: F401
+from pynosqlc.cassandra.cassandra_client import CassandraClient
+from pynosqlc.cassandra.cassandra_collection import CassandraCollection
+from pynosqlc.cassandra.cassandra_driver import CassandraDriver
+
+__all__ = ["CassandraDriver", "CassandraClient", "CassandraCollection"]

alt_python_pynosqlc_cassandra-1.0.4/pynosqlc/cassandra/cassandra_client.py

@@ -0,0 +1,49 @@
+"""
+cassandra_client.py — Cassandra Client implementation.
+
+Each collection is created on demand; the parent Client base class
+caches by name via get_collection().
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from pynosqlc.core.client import Client
+from pynosqlc.cassandra.cassandra_collection import CassandraCollection
+
+if TYPE_CHECKING:
+    from cassandra.cluster import Cluster, Session
+
+
+class CassandraClient(Client):
+    """Client backed by a cassandra-driver synchronous session.
+
+    Args:
+        url: the pynosqlc URL used to open this connection
+        cluster: the connected ``Cluster`` instance (for shutdown)
+        session: the connected ``Session`` instance
+        keyspace: the active Cassandra keyspace
+    """
+
+    def __init__(
+        self,
+        url: str,
+        cluster: "Cluster",
+        session: "Session",
+        keyspace: str,
+    ) -> None:
+        super().__init__({"url": url})
+        self._cluster = cluster
+        self._session = session
+        self._keyspace = keyspace
+
+    def _get_collection(self, name: str) -> CassandraCollection:
+        """Create and return a :class:`CassandraCollection` for *name*."""
+        return CassandraCollection(self, name, self._session)
+
+    async def _close(self) -> None:
+        """Shut down the underlying Cassandra cluster connection."""
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, self._cluster.shutdown)

alt_python_pynosqlc_cassandra-1.0.4/pynosqlc/cassandra/cassandra_collection.py

@@ -0,0 +1,113 @@
+"""
+cassandra_collection.py — Cassandra Collection implementation.
+
+Storage layout
+--------------
+Each pynosqlc collection maps to one Cassandra table:
+
+    CREATE TABLE IF NOT EXISTS <name> (
+        pk   TEXT PRIMARY KEY,
+        data TEXT
+    )
+
+Documents are stored as JSON in the ``data`` column.  Filtering is
+performed in-process using :class:`MemoryFilterEvaluator` after a full
+table scan — appropriate for test/dev workloads.
+
+All session.execute() calls are dispatched via run_in_executor so they
+don't block the asyncio event loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import uuid
+from typing import TYPE_CHECKING
+
+from pynosqlc.core.collection import Collection
+from pynosqlc.core.cursor import Cursor
+from pynosqlc.memory.memory_filter_evaluator import MemoryFilterEvaluator
+
+if TYPE_CHECKING:
+    from cassandra.cluster import Session
+
+    from pynosqlc.core.client import Client
+
+
+class CassandraCollection(Collection):
+    """Collection backed by a Cassandra table (pk TEXT, data TEXT).
+
+    Args:
+        client: the owning :class:`CassandraClient`
+        name: collection name (used as the CQL table name)
+        session: the shared cassandra-driver ``Session``
+    """
+
+    def __init__(self, client: "Client", name: str, session: "Session") -> None:
+        super().__init__(client, name)
+        self._session = session
+        self._table_ready: bool = False
+
+    # ── Table bootstrap ────────────────────────────────────────────────────
+
+    async def _ensure_table(self) -> None:
+        """Create the backing table if it does not yet exist."""
+        if self._table_ready:
+            return
+        loop = asyncio.get_event_loop()
+        cql = (
+            f"CREATE TABLE IF NOT EXISTS {self._name} ("
+            f"pk TEXT PRIMARY KEY, data TEXT)"
+        )
+        await loop.run_in_executor(None, self._session.execute, cql)
+        self._table_ready = True
+
+    # ── Abstract implementation hooks ──────────────────────────────────────
+
+    async def _get(self, key: str) -> dict | None:
+        await self._ensure_table()
+        loop = asyncio.get_event_loop()
+        cql = f"SELECT data FROM {self._name} WHERE pk = %s"
+        rows = await loop.run_in_executor(None, self._session.execute, cql, (key,))
+        row = rows.one()
+        return json.loads(row["data"]) if row is not None else None
+
+    async def _store(self, key: str, doc: dict) -> None:
+        await self._ensure_table()
+        loop = asyncio.get_event_loop()
+        cql = f"INSERT INTO {self._name} (pk, data) VALUES (%s, %s)"
+        await loop.run_in_executor(
+            None, self._session.execute, cql, (key, json.dumps(doc))
+        )
+
+    async def _delete(self, key: str) -> None:
+        await self._ensure_table()
+        loop = asyncio.get_event_loop()
+        cql = f"DELETE FROM {self._name} WHERE pk = %s"
+        await loop.run_in_executor(None, self._session.execute, cql, (key,))
+
+    async def _insert(self, doc: dict) -> str:
+        key = str(uuid.uuid4())
+        await self._store(key, {**doc, "_id": key})
+        return key
+
+    async def _update(self, key: str, patch: dict) -> None:
+        existing = await self._get(key)
+        if existing is None:
+            raise KeyError(f"Document not found for key: {key!r}")
+        await self._store(key, {**existing, **patch})
+
+    async def _find(self, ast: dict) -> Cursor:
+        await self._ensure_table()
+        loop = asyncio.get_event_loop()
+        cql = f"SELECT pk, data FROM {self._name}"
+        rows = await loop.run_in_executor(None, self._session.execute, cql)
+
+        results = []
+        for row in rows:
+            doc = json.loads(row["data"])
+            if MemoryFilterEvaluator.matches(doc, ast):
+                results.append(doc)
+
+        return Cursor(results)

alt_python_pynosqlc_cassandra-1.0.4/pynosqlc/cassandra/cassandra_driver.py

@@ -0,0 +1,94 @@
+"""
+cassandra_driver.py — Cassandra pynosqlc driver.
+
+Handles URL: pynosqlc:cassandra:host:port/keyspace
+Auto-registers with DriverManager on import.
+
+cassandra-driver uses a synchronous API; all blocking calls are executed
+via asyncio.get_event_loop().run_in_executor(None, ...) so they don't
+block the event loop.
+
+The default LibevConnection / ThreadedRequestExecutor reactor is used
+(not AsyncioConnection) because AsyncioConnection cannot hook into the
+running event loop when invoked from run_in_executor's thread-pool thread.
+The standard reactor works correctly from any thread.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from pynosqlc.core.driver import Driver
+from pynosqlc.core.driver_manager import DriverManager
+from pynosqlc.cassandra.cassandra_client import CassandraClient
+
+
+class CassandraDriver(Driver):
+    """Driver that creates :class:`CassandraClient` instances.
+
+    URL format: ``pynosqlc:cassandra:host:port/keyspace``
+    Default port: 9042
+    Default keyspace: ``pynosqlc``
+    """
+
+    URL_PREFIX: str = "pynosqlc:cassandra:"
+
+    def accepts_url(self, url: str) -> bool:
+        """Return ``True`` for ``'pynosqlc:cassandra:...'`` URLs."""
+        return isinstance(url, str) and url.startswith(self.URL_PREFIX)
+
+    async def connect(
+        self,
+        url: str,
+        properties: dict | None = None,
+    ) -> CassandraClient:
+        """Parse URL, connect, and return a :class:`CassandraClient`.
+
+        URL format: ``pynosqlc:cassandra:host:port/keyspace``
+        Example:    ``pynosqlc:cassandra:localhost:9042/pynosqlc_test``
+
+        Connection errors from cassandra-driver propagate directly —
+        ``NoHostAvailable`` is the expected signal when Cassandra is absent
+        (used by compliance tests to skip).
+        """
+        from cassandra.cluster import Cluster
+        from cassandra.query import dict_factory
+
+        # Parse: strip prefix → "host:port/keyspace"
+        tail = url[len(self.URL_PREFIX):]
+        if "/" in tail:
+            host_port, keyspace = tail.split("/", 1)
+        else:
+            host_port, keyspace = tail, "pynosqlc"
+
+        if ":" in host_port:
+            host, port_str = host_port.rsplit(":", 1)
+            port = int(port_str)
+        else:
+            host = host_port
+            port = 9042
+
+        loop = asyncio.get_event_loop()
+
+        cluster = Cluster(
+            contact_points=[host],
+            port=port,
+        )
+        session = await loop.run_in_executor(None, lambda: cluster.connect())
+        await loop.run_in_executor(
+            None,
+            session.execute,
+            (
+                f"CREATE KEYSPACE IF NOT EXISTS {keyspace} "
+                f"WITH REPLICATION = {{'class': 'SimpleStrategy', 'replication_factor': 1}}"
+            ),
+        )
+        await loop.run_in_executor(None, session.set_keyspace, keyspace)
+        session.row_factory = dict_factory
+
+        return CassandraClient(url, cluster, session, keyspace)
+
+
+# Auto-register on import — a single shared instance is sufficient.
+_driver = CassandraDriver()
+DriverManager.register_driver(_driver)

alt_python_pynosqlc_cassandra-1.0.4/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "alt-python-pynosqlc-cassandra"
+version = "1.0.4"
+description = "Cassandra driver for pynosqlc"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "alt-python-pynosqlc-core",
+    "alt-python-pynosqlc-memory",
+    "cassandra-driver>=3.29.1",
+]
+authors = [
+    {name = "Craig Parravicini"},
+    {name = "Claude (Anthropic)"},
+]
+license = {text = "MIT"}
+keywords = ["nosql", "database", "async", "cassandra", "driver"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/alt-python/pynosqlc"
+Repository = "https://github.com/alt-python/pynosqlc"
+Documentation = "https://github.com/alt-python/pynosqlc#getting-started"
+"Bug Tracker" = "https://github.com/alt-python/pynosqlc/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["pynosqlc"]
+
+[tool.uv.sources]
+alt-python-pynosqlc-core = { workspace = true }
+alt-python-pynosqlc-memory = { workspace = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+addopts = "--import-mode=importlib"

alt_python_pynosqlc_cassandra-1.0.4/tests/test_compliance.py

@@ -0,0 +1,66 @@
+"""
+test_compliance.py — Cassandra driver compliance tests.
+
+Wires the shared pynosqlc.core compliance suite into the cassandra package.
+Each test run gets a fresh CassandraClient connected to a live Cassandra 4 instance.
+
+Set CASSANDRA_URL to override the default URL
+(default: pynosqlc:cassandra:localhost:9042/pynosqlc_test).
+Tests are skipped automatically if Cassandra is not reachable.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+import pytest
+
+from pynosqlc.core import DriverManager
+from pynosqlc.core.testing import run_compliance
+import pynosqlc.cassandra  # noqa: F401 — registers CassandraDriver on import
+from pynosqlc.cassandra.cassandra_driver import _driver
+
+CASSANDRA_URL = os.environ.get(
+    "CASSANDRA_URL", "pynosqlc:cassandra:localhost:9042/pynosqlc_test"
+)
+
+
+async def _factory():
+    """Return a fresh, open CassandraClient for each test class fixture.
+
+    Clears and re-registers the driver, connects to Cassandra, drops and
+    recreates the keyspace so each test class starts with a clean slate,
+    and returns the client.
+
+    Skips the test if Cassandra is not reachable.
+    """
+    DriverManager.clear()
+    DriverManager.register_driver(_driver)
+
+    try:
+        client = await DriverManager.get_client(CASSANDRA_URL)
+        # Drop and recreate keyspace for a clean slate between test classes
+        loop = asyncio.get_event_loop()
+        keyspace = "pynosqlc_test"
+        await loop.run_in_executor(
+            None,
+            client._session.execute,
+            f"DROP KEYSPACE IF EXISTS {keyspace}",
+        )
+        await loop.run_in_executor(
+            None,
+            client._session.execute,
+            (
+                f"CREATE KEYSPACE IF NOT EXISTS {keyspace} "
+                f"WITH REPLICATION = {{'class': 'SimpleStrategy', 'replication_factor': 1}}"
+            ),
+        )
+        await loop.run_in_executor(None, client._session.set_keyspace, keyspace)
+    except Exception as e:
+        pytest.skip(f"Cassandra not available: {e}")
+
+    return client
+
+
+run_compliance(_factory)