oxyde 0.1.0__tar.gz

oxyde-0.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: oxyde
+Version: 0.1.0
+Summary: High-performance async Python ORM with Rust core
+Author-email: Nikita Ryzhenkov <nikita.ryzhenkoff@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mr-fatalyst/oxyde
+Project-URL: Documentation, https://github.com/mr-fatalyst/oxyde#readme
+Project-URL: Repository, https://github.com/mr-fatalyst/oxyde
+Project-URL: Issues, https://github.com/mr-fatalyst/oxyde/issues
+Keywords: orm,async,database,postgresql,sqlite,mysql,pydantic
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: msgpack>=1.0
+Requires-Dist: typer>=0.9
+Requires-Dist: oxyde-core<0.2.0,>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.14.7; extra == "dev"
+Requires-Dist: pre-commit>=4.5.0; extra == "dev"
+
+# Oxyde ORM
+
+High-performance async Python ORM with Rust core.
+
+Oxyde combines Python's expressiveness with Rust's performance. Models defined with Pydantic v2, queries executed in native Rust.
+
+```python
+from oxyde import OxydeModel, Field, db
+
+class User(OxydeModel):
+    class Meta:
+        is_table = True
+
+    id: int | None = Field(default=None, db_pk=True)
+    email: str = Field(db_unique=True)
+    age: int = Field(ge=0, le=150)
+
+async def main():
+    async with db.connect("postgresql://localhost/mydb"):
+        # Create
+        user = await User.objects.create(email="alice@example.com", age=30)
+
+        # Read
+        users = await User.objects.filter(age__gte=18).limit(10).all()
+
+        # Update
+        await User.objects.filter(id=user.id).update(age=31)
+
+        # Delete
+        await User.objects.filter(id=user.id).delete()
+```
+
+## Features
+
+- **Django-style API** — Familiar `Model.objects.filter()` syntax
+- **Pydantic v2 models** — Full validation, type hints, serialization
+- **Async-first** — Built for modern async Python with `asyncio`
+- **Rust performance** — SQL generation and execution in native Rust
+- **Multi-database** — PostgreSQL, SQLite, MySQL support
+- **Transactions** — `atomic()` context manager with savepoints
+- **Migrations** — Django-style `makemigrations` and `migrate` CLI
+
+## Installation
+
+```bash
+pip install oxyde
+```
+
+## Quick Start
+
+### Define a Model
+
+```python
+from oxyde import OxydeModel, Field
+
+class User(OxydeModel):
+    class Meta:
+        is_table = True
+
+    id: int | None = Field(default=None, db_pk=True)
+    name: str
+    email: str = Field(db_unique=True)
+    age: int | None = Field(default=None)
+```
+
+### Connect and Query
+
+```python
+from oxyde import db
+
+async with db.connect("sqlite:///app.db"):
+    # Create
+    user = await User.objects.create(name="Alice", email="alice@example.com", age=30)
+
+    # Query
+    adults = await User.objects.filter(age__gte=18).all()
+
+    # Get single object
+    user = await User.objects.get(id=1)
+
+    # Update
+    user.age = 31
+    await user.save()
+
+    # Delete
+    await user.delete()
+```
+
+### Transactions
+
+```python
+from oxyde.db import transaction
+
+async with transaction.atomic():
+    user = await User.objects.create(name="Alice", email="alice@example.com")
+    await Profile.objects.create(user_id=user.id)
+    # Auto-commits on success, rolls back on exception
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from oxyde import db
+
+app = FastAPI(
+    lifespan=db.lifespan(
+        default="postgresql://localhost/mydb",
+    )
+)
+
+@app.get("/users")
+async def get_users():
+    return await User.objects.filter(is_active=True).all()
+```
+
+## Database Support
+
+| Database   | Min Version | Status | Notes |
+|------------|-------------|--------|-------|
+| PostgreSQL | 12+ | Full | RETURNING, UPSERT, FOR UPDATE/SHARE, JSON, Arrays |
+| SQLite     | 3.35+ | Full | RETURNING, UPSERT, WAL mode by default |
+| MySQL      | 8.0+ | Full | UPSERT via ON DUPLICATE KEY, FOR UPDATE/SHARE |
+
+**Recommendation**: PostgreSQL for production, SQLite for development/testing.
+
+> **SQLite < 3.35**: Falls back to `last_insert_rowid()` which may return incorrect IDs with concurrent inserts.
+>
+> **MySQL**: No RETURNING clause — uses `last_insert_id()`. Bulk INSERT returns calculated ID range which may be incorrect with concurrent inserts.
+
+**Connection URLs:**
+
+```python
+"postgresql://user:password@localhost:5432/database"
+"sqlite:///path/to/database.db"
+"sqlite:///:memory:"
+"mysql://user:password@localhost:3306/database"
+```
+
+## Documentation
+
+Full documentation: **[https://oxyde.fatalyst.dev/](https://oxyde.fatalyst.dev/)**
+
+- [Getting Started](https://oxyde.fatalyst.dev/getting-started/quickstart/) — First steps with Oxyde
+- [User Guide](https://oxyde.fatalyst.dev/guide/models/) — Models, queries, relations, transactions
+- [Cheatsheet](https://oxyde.fatalyst.dev/cheatsheet/) — Quick reference for all methods
+- [FAQ](https://oxyde.fatalyst.dev/faq/) — Common questions and answers
+
+## Contributing
+
+If you have suggestions or find a bug, please open an issue or create a pull request on GitHub.
+
+## License
+
+This project is licensed under the terms of the MIT license.

oxyde-0.1.0/README.md

@@ -0,0 +1,155 @@
+# Oxyde ORM
+
+High-performance async Python ORM with Rust core.
+
+Oxyde combines Python's expressiveness with Rust's performance. Models defined with Pydantic v2, queries executed in native Rust.
+
+```python
+from oxyde import OxydeModel, Field, db
+
+class User(OxydeModel):
+    class Meta:
+        is_table = True
+
+    id: int | None = Field(default=None, db_pk=True)
+    email: str = Field(db_unique=True)
+    age: int = Field(ge=0, le=150)
+
+async def main():
+    async with db.connect("postgresql://localhost/mydb"):
+        # Create
+        user = await User.objects.create(email="alice@example.com", age=30)
+
+        # Read
+        users = await User.objects.filter(age__gte=18).limit(10).all()
+
+        # Update
+        await User.objects.filter(id=user.id).update(age=31)
+
+        # Delete
+        await User.objects.filter(id=user.id).delete()
+```
+
+## Features
+
+- **Django-style API** — Familiar `Model.objects.filter()` syntax
+- **Pydantic v2 models** — Full validation, type hints, serialization
+- **Async-first** — Built for modern async Python with `asyncio`
+- **Rust performance** — SQL generation and execution in native Rust
+- **Multi-database** — PostgreSQL, SQLite, MySQL support
+- **Transactions** — `atomic()` context manager with savepoints
+- **Migrations** — Django-style `makemigrations` and `migrate` CLI
+
+## Installation
+
+```bash
+pip install oxyde
+```
+
+## Quick Start
+
+### Define a Model
+
+```python
+from oxyde import OxydeModel, Field
+
+class User(OxydeModel):
+    class Meta:
+        is_table = True
+
+    id: int | None = Field(default=None, db_pk=True)
+    name: str
+    email: str = Field(db_unique=True)
+    age: int | None = Field(default=None)
+```
+
+### Connect and Query
+
+```python
+from oxyde import db
+
+async with db.connect("sqlite:///app.db"):
+    # Create
+    user = await User.objects.create(name="Alice", email="alice@example.com", age=30)
+
+    # Query
+    adults = await User.objects.filter(age__gte=18).all()
+
+    # Get single object
+    user = await User.objects.get(id=1)
+
+    # Update
+    user.age = 31
+    await user.save()
+
+    # Delete
+    await user.delete()
+```
+
+### Transactions
+
+```python
+from oxyde.db import transaction
+
+async with transaction.atomic():
+    user = await User.objects.create(name="Alice", email="alice@example.com")
+    await Profile.objects.create(user_id=user.id)
+    # Auto-commits on success, rolls back on exception
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from oxyde import db
+
+app = FastAPI(
+    lifespan=db.lifespan(
+        default="postgresql://localhost/mydb",
+    )
+)
+
+@app.get("/users")
+async def get_users():
+    return await User.objects.filter(is_active=True).all()
+```
+
+## Database Support
+
+| Database   | Min Version | Status | Notes |
+|------------|-------------|--------|-------|
+| PostgreSQL | 12+ | Full | RETURNING, UPSERT, FOR UPDATE/SHARE, JSON, Arrays |
+| SQLite     | 3.35+ | Full | RETURNING, UPSERT, WAL mode by default |
+| MySQL      | 8.0+ | Full | UPSERT via ON DUPLICATE KEY, FOR UPDATE/SHARE |
+
+**Recommendation**: PostgreSQL for production, SQLite for development/testing.
+
+> **SQLite < 3.35**: Falls back to `last_insert_rowid()` which may return incorrect IDs with concurrent inserts.
+>
+> **MySQL**: No RETURNING clause — uses `last_insert_id()`. Bulk INSERT returns calculated ID range which may be incorrect with concurrent inserts.
+
+**Connection URLs:**
+
+```python
+"postgresql://user:password@localhost:5432/database"
+"sqlite:///path/to/database.db"
+"sqlite:///:memory:"
+"mysql://user:password@localhost:3306/database"
+```
+
+## Documentation
+
+Full documentation: **[https://oxyde.fatalyst.dev/](https://oxyde.fatalyst.dev/)**
+
+- [Getting Started](https://oxyde.fatalyst.dev/getting-started/quickstart/) — First steps with Oxyde
+- [User Guide](https://oxyde.fatalyst.dev/guide/models/) — Models, queries, relations, transactions
+- [Cheatsheet](https://oxyde.fatalyst.dev/cheatsheet/) — Quick reference for all methods
+- [FAQ](https://oxyde.fatalyst.dev/faq/) — Common questions and answers
+
+## Contributing
+
+If you have suggestions or find a bug, please open an issue or create a pull request on GitHub.
+
+## License
+
+This project is licensed under the terms of the MIT license.

oxyde-0.1.0/oxyde/__init__.py

@@ -0,0 +1,123 @@
+"""Oxyde ORM - High-performance async Python ORM with Rust core.
+
+This is the main entry point for the Oxyde ORM library. It re-exports
+all public APIs from submodules for convenient access.
+
+Public API:
+    Models:
+        OxydeModel: Base class for all ORM models (Pydantic v2 based).
+        Field: Field configuration with db_pk, db_index, db_default, etc.
+        Index: Composite index decorator for models.
+        Check: CHECK constraint decorator for models.
+
+    Queries:
+        Query: SELECT query builder with Django-like filter syntax.
+        QueryManager: Model.objects manager for CRUD operations.
+        Q: Boolean expressions for complex filters (AND/OR/NOT).
+        F: Database-side field references for expressions.
+
+    Aggregates:
+        Count, Sum, Avg, Max, Min: SQL aggregate functions.
+        Concat, Coalesce: SQL scalar functions.
+        RawSQL: Raw SQL expression wrapper.
+
+    Database:
+        db: Database module with init(), close(), connect(), lifespan().
+        AsyncDatabase: Connection pool wrapper.
+        PoolSettings: Pool configuration (max_connections, timeouts).
+        atomic: Transaction context manager (decorator or async with).
+
+    Exceptions:
+        OxydeError: Base exception for all Oxyde errors.
+        NotFoundError: Raised when get() finds no results.
+        MultipleObjectsReturned: Raised when get() finds multiple results.
+        IntegrityError: Raised on constraint violations.
+        FieldError, LookupError, ManagerError: Validation errors.
+
+Example:
+    from oxyde import OxydeModel, Field, db
+
+    class User(OxydeModel):
+        id: int | None = Field(default=None, db_pk=True)
+        name: str
+
+        class Meta:
+            is_table = True
+
+    async with db.connect("sqlite://app.db"):
+        user = await User.objects.create(name="Alice")
+        users = await User.objects.filter(name__startswith="A").all()
+"""
+
+from oxyde import db
+from oxyde.db import (
+    AsyncDatabase,
+    PoolSettings,
+    TransactionTimeoutError,
+    atomic,
+    disconnect_all,
+    get_connection,
+    register_connection,
+)
+from oxyde.exceptions import (
+    FieldError,
+    IntegrityError,
+    LookupError,
+    LookupValueError,
+    ManagerError,
+    MultipleObjectsReturned,
+    NotFoundError,
+    OxydeError,
+)
+from oxyde.models import Check, Field, Index, OxydeModel
+from oxyde.queries import (
+    Avg,
+    Coalesce,
+    Concat,
+    Count,
+    F,
+    Max,
+    Min,
+    Q,
+    Query,
+    QueryManager,
+    RawSQL,
+    Sum,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "OxydeModel",
+    "db",
+    "AsyncDatabase",
+    "PoolSettings",
+    "TransactionTimeoutError",
+    "register_connection",
+    "get_connection",
+    "disconnect_all",
+    "Field",
+    "Index",
+    "Check",
+    "Query",
+    "QueryManager",
+    "OxydeError",
+    "FieldError",
+    "LookupError",
+    "LookupValueError",
+    "ManagerError",
+    "NotFoundError",
+    "MultipleObjectsReturned",
+    "IntegrityError",
+    "atomic",
+    "F",
+    "Q",
+    "Count",
+    "Sum",
+    "Avg",
+    "Max",
+    "Min",
+    "Concat",
+    "Coalesce",
+    "RawSQL",
+]

oxyde-0.1.0/oxyde/codegen/__init__.py

@@ -0,0 +1,15 @@
+"""Code generation utilities for Oxyde ORM."""
+
+from oxyde.codegen.stub_generator import (
+    generate_model_stub,
+    generate_stub_for_file,
+    generate_stubs_for_models,
+    write_stubs,
+)
+
+__all__ = [
+    "generate_model_stub",
+    "generate_stub_for_file",
+    "generate_stubs_for_models",
+    "write_stubs",
+]