django-tortoise-objects 0.1.0__py3-none-any.whl

django_tortoise/manager.py

@@ -0,0 +1,184 @@
+"""
+TortoiseObjects descriptor for the ``tortoise_objects`` attribute.
+
+Provides a Django-model-attached descriptor that lazily initializes
+Tortoise ORM and returns an async-capable queryset interface.
+"""
+
+import logging
+
+logger = logging.getLogger("django_tortoise")
+
+
+class TortoiseObjects:
+    """
+    Descriptor/proxy that provides access to Tortoise QuerySet for a Django model.
+
+    Usage: ``MyDjangoModel.tortoise_objects.filter(name="foo")``
+
+    All async QuerySet operations automatically trigger lazy initialization
+    of Tortoise ORM connections on first use.
+    """
+
+    def __init__(self, tortoise_model_class):
+        self._tortoise_model = tortoise_model_class
+
+    def __get__(self, obj, objtype=None):
+        """
+        When accessed as class attribute, return self (the manager).
+        When accessed as instance attribute, also return self.
+        """
+        return self
+
+    @property
+    def model(self):
+        """The underlying Tortoise model class."""
+        return self._tortoise_model
+
+    def _get_queryset(self):
+        """Get a fresh Tortoise QuerySet for the model."""
+        return self._tortoise_model.all()
+
+    # --- QuerySet proxy methods ---
+    # Each method returns a _LazyQuerySet that ensures init before execution.
+
+    def all(self):
+        return _LazyQuerySet(self._tortoise_model, "all")
+
+    def filter(self, *args, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "filter", *args, **kwargs)
+
+    def exclude(self, *args, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "exclude", *args, **kwargs)
+
+    def get(self, *args, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "get", *args, **kwargs)
+
+    def create(self, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "create", **kwargs)
+
+    def first(self):
+        return _LazyQuerySet(self._tortoise_model, "first")
+
+    def count(self):
+        return _LazyQuerySet(self._tortoise_model, "count")
+
+    def exists(self):
+        return _LazyQuerySet(self._tortoise_model, "exists")
+
+    def values(self, *args, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "values", *args, **kwargs)
+
+    def values_list(self, *args, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "values_list", *args, **kwargs)
+
+    def delete(self):
+        return _LazyQuerySet(self._tortoise_model, "delete")
+
+    def update(self, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "update", **kwargs)
+
+    def get_or_create(self, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "get_or_create", **kwargs)
+
+    def bulk_create(self, objects, **kwargs):
+        return _LazyQuerySet(self._tortoise_model, "bulk_create", objects, **kwargs)
+
+
+class _LazyQuerySet:
+    """
+    A lazy wrapper around a Tortoise QuerySet method call.
+
+    Ensures Tortoise is initialized before executing the query.
+    Supports both ``__await__`` (for direct ``await``) and chaining.
+    """
+
+    def __init__(self, tortoise_model, method_name, *args, **kwargs):
+        self._tortoise_model = tortoise_model
+        self._method_name = method_name
+        self._args = args
+        self._kwargs = kwargs
+        self._chain = []  # List of (method_name, args, kwargs) for chaining
+
+    def filter(self, *args, **kwargs):
+        self._chain.append(("filter", args, kwargs))
+        return self
+
+    def exclude(self, *args, **kwargs):
+        self._chain.append(("exclude", args, kwargs))
+        return self
+
+    def order_by(self, *args):
+        self._chain.append(("order_by", args, {}))
+        return self
+
+    def limit(self, limit):
+        self._chain.append(("limit", (limit,), {}))
+        return self
+
+    def offset(self, offset):
+        self._chain.append(("offset", (offset,), {}))
+        return self
+
+    def values(self, *args, **kwargs):
+        self._chain.append(("values", args, kwargs))
+        return self
+
+    def values_list(self, *args, **kwargs):
+        self._chain.append(("values_list", args, kwargs))
+        return self
+
+    def count(self):
+        self._chain.append(("count", (), {}))
+        return self
+
+    def first(self):
+        self._chain.append(("first", (), {}))
+        return self
+
+    def exists(self):
+        self._chain.append(("exists", (), {}))
+        return self
+
+    def delete(self):
+        self._chain.append(("delete", (), {}))
+        return self
+
+    def update(self, **kwargs):
+        self._chain.append(("update", (), kwargs))
+        return self
+
+    async def _execute(self):
+        """Execute the query chain with lazy initialization."""
+        from django_tortoise.initialization import ensure_initialized
+
+        await ensure_initialized()
+
+        # Start with the initial method call
+        qs = getattr(self._tortoise_model, self._method_name)(*self._args, **self._kwargs)
+
+        # Apply chain
+        for method_name, args, kwargs in self._chain:
+            qs = getattr(qs, method_name)(*args, **kwargs)
+
+        # If the result is awaitable (queryset), await it
+        if hasattr(qs, "__await__"):
+            return await qs
+        return qs
+
+    def __await__(self):
+        return self._execute().__await__()
+
+    def __aiter__(self):
+        return self._async_iter()
+
+    async def _async_iter(self):
+        result = await self._execute()
+        if hasattr(result, "__aiter__"):
+            async for item in result:
+                yield item
+        elif hasattr(result, "__iter__"):
+            for item in result:
+                yield item
+        else:
+            yield result

django_tortoise/registry.py

@@ -0,0 +1,123 @@
+"""
+Central registry of Django-to-Tortoise model mappings.
+
+Maintains a bidirectional mapping between Django model classes and their
+dynamically generated Tortoise ORM counterparts.  Provides lookup by
+Django model class, Tortoise model class, or ``"app_label.ModelName"``
+label string.
+
+A module-level ``model_registry`` singleton is the single source of truth.
+The public ``get_tortoise_model()`` function is a convenience wrapper
+re-exported by ``django_tortoise.__init__``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tortoise.models import Model as TortoiseModel
+
+logger = logging.getLogger("django_tortoise")
+
+
+class ModelRegistry:
+    """Central registry mapping Django models to Tortoise models."""
+
+    def __init__(self) -> None:
+        self._django_to_tortoise: dict[type, type[TortoiseModel]] = {}
+        self._tortoise_to_django: dict[type[TortoiseModel], type] = {}
+        self._by_label: dict[str, type[TortoiseModel]] = {}  # "app_label.ModelName" -> Tortoise
+        self._tortoise_models: list[type[TortoiseModel]] = []
+
+    def register(
+        self,
+        django_model: type,
+        tortoise_model: type[TortoiseModel],
+        label: str,
+    ) -> None:
+        """Register a Django <-> Tortoise model pair."""
+        self._django_to_tortoise[django_model] = tortoise_model
+        self._tortoise_to_django[tortoise_model] = django_model
+        self._by_label[label] = tortoise_model
+        self._tortoise_models.append(tortoise_model)
+        logger.debug("Registered: %s -> %s", label, tortoise_model.__name__)
+
+    def get_tortoise_model(self, django_model: type) -> type[TortoiseModel] | None:
+        """Get the Tortoise model for a Django model."""
+        return self._django_to_tortoise.get(django_model)
+
+    def get_django_model(self, tortoise_model: type[TortoiseModel]) -> type | None:
+        """Get the Django model for a Tortoise model."""
+        return self._tortoise_to_django.get(tortoise_model)
+
+    def get_by_label(self, label: str) -> type[TortoiseModel] | None:
+        """Get Tortoise model by ``'app_label.ModelName'`` string."""
+        return self._by_label.get(label)
+
+    def get_all_tortoise_models(self) -> list[type[TortoiseModel]]:
+        """Get all registered Tortoise models."""
+        return list(self._tortoise_models)
+
+    def get_all_mappings(self) -> dict[type, type[TortoiseModel]]:
+        """Return a copy of the full Django -> Tortoise model registry."""
+        return dict(self._django_to_tortoise)
+
+    def is_registered(self, django_model: type) -> bool:
+        """Check if a Django model has a Tortoise counterpart."""
+        return django_model in self._django_to_tortoise
+
+    def clear(self) -> None:
+        """Clear all registrations. Primarily used in testing."""
+        self._django_to_tortoise.clear()
+        self._tortoise_to_django.clear()
+        self._by_label.clear()
+        self._tortoise_models.clear()
+
+
+# Global singleton instance
+model_registry = ModelRegistry()
+
+
+# ---------------------------------------------------------------------------
+# Public convenience functions (re-exported by django_tortoise.__init__)
+# ---------------------------------------------------------------------------
+
+
+def register_model(
+    django_model: type,
+    tortoise_model: type[TortoiseModel],
+    label: str | None = None,
+) -> None:
+    """
+    Register a Django -> Tortoise model mapping.
+
+    If *label* is not provided, it is derived from the Django model's
+    ``_meta.app_label`` and class name.
+    """
+    if label is None:
+        try:
+            label = f"{django_model._meta.app_label}.{django_model.__name__}"  # type: ignore[attr-defined]
+        except AttributeError:
+            label = django_model.__name__
+    model_registry.register(django_model, tortoise_model, label)
+
+
+def get_tortoise_model(django_model: type) -> type[TortoiseModel] | None:
+    """
+    Retrieve the Tortoise ORM model class generated for the given Django model.
+
+    Returns ``None`` if no mapping has been registered for this model.
+    """
+    return model_registry.get_tortoise_model(django_model)
+
+
+def get_all_mappings() -> dict[type, type[TortoiseModel]]:
+    """Return a copy of the full Django -> Tortoise model registry."""
+    return model_registry.get_all_mappings()
+
+
+def clear_registry() -> None:
+    """Clear all registered mappings. Primarily used in testing."""
+    model_registry.clear()

django_tortoise_objects-0.1.0.dist-info/METADATA

@@ -0,0 +1,302 @@
+Metadata-Version: 2.4
+Name: django-tortoise-objects
+Version: 0.1.0
+Summary: Bridge Django ORM models to Tortoise ORM for truly async database access
+Project-URL: Homepage, https://github.com/tortoise/django-tortoise-objects
+Project-URL: Repository, https://github.com/tortoise/django-tortoise-objects
+Project-URL: Issues, https://github.com/tortoise/django-tortoise-objects/issues
+Author: Andrei Bondar
+License: Apache-2.0
+License-File: LICENSE
+Keywords: async,database,django,orm,tortoise-orm
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Requires-Dist: tortoise-orm>=1.1.2
+Provides-Extra: all
+Requires-Dist: aiosqlite>=0.19; extra == 'all'
+Requires-Dist: asyncmy>=0.2; extra == 'all'
+Requires-Dist: psycopg[binary]>=3.1; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: aiosqlite>=0.19; extra == 'dev'
+Requires-Dist: django-stubs>=5.1; extra == 'dev'
+Requires-Dist: mypy>=1.14; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-django>=4.5; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Provides-Extra: mysql
+Requires-Dist: asyncmy>=0.2; extra == 'mysql'
+Provides-Extra: pg
+Requires-Dist: psycopg[binary]>=3.1; extra == 'pg'
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite>=0.19; extra == 'sqlite'
+Description-Content-Type: text/markdown
+
+# django-tortoise-objects
+
+Bridge Django ORM models to [Tortoise ORM](https://github.com/tortoise/tortoise-orm) for truly async database access. Define your models once in Django, query them asynchronously via Tortoise — no duplicate schema, no manual sync.
+
+## Why?
+
+Django's async ORM wraps synchronous calls in `sync_to_async` threads. Tortoise ORM is natively async but requires its own model definitions. This library eliminates that trade-off:
+
+- **Single source of truth** — Django models define the schema, migrations, and admin
+- **Truly async queries** — Tortoise ORM handles the actual database I/O with native async drivers
+- **Zero boilerplate** — Add to `INSTALLED_APPS`, and every model gets a `tortoise_objects` manager
+
+## Installation
+
+```bash
+pip install django-tortoise-objects
+```
+
+With database drivers:
+
+```bash
+# PostgreSQL
+pip install django-tortoise-objects[pg]
+
+# SQLite
+pip install django-tortoise-objects[sqlite]
+
+# MySQL
+pip install django-tortoise-objects[mysql]
+
+# All drivers
+pip install django-tortoise-objects[all]
+```
+
+## Quick Start
+
+### 1. Add to INSTALLED_APPS
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_tortoise",
+    # ... your apps
+]
+```
+
+### 2. Query your existing Django models asynchronously
+
+```python
+from myapp.models import Article
+
+# All standard query operations — fully async, no sync_to_async wrapper
+articles = await Article.tortoise_objects.filter(published=True)
+article = await Article.tortoise_objects.get(id=42)
+count = await Article.tortoise_objects.count()
+exists = await Article.tortoise_objects.filter(title="foo").exists()
+
+# Create, update, delete
+article = await Article.tortoise_objects.create(title="Hello", body="World")
+await Article.tortoise_objects.filter(published=False).update(draft=True)
+await Article.tortoise_objects.filter(id=42).delete()
+
+# Chaining
+recent = await Article.tortoise_objects.filter(published=True).order_by("-created_at").limit(10)
+
+# Prefetch relations (via underlying Tortoise model)
+employees = await Employee.tortoise_objects.model.all().prefetch_related("team")
+```
+
+### 3. Use in async Django views
+
+```python
+from django.http import JsonResponse
+from myapp.models import Tag
+
+async def tag_list(request):
+    tags = await Tag.tortoise_objects.all()
+    return JsonResponse({"tags": [{"id": t.id, "name": t.name} for t in tags]})
+```
+
+That's it. No Tortoise model definitions, no configuration files, no manual initialization.
+
+## Configuration
+
+Optional settings via `TORTOISE_OBJECTS` in your Django settings:
+
+```python
+TORTOISE_OBJECTS = {
+    # Include only specific app models (fnmatch patterns)
+    "INCLUDE_MODELS": ["myapp.*", "blog.*"],
+
+    # Exclude specific models
+    "EXCLUDE_MODELS": ["auth.*", "admin.*"],
+
+    # Override database backend mapping
+    "DB_ENGINE_MAP": {
+        "django.db.backends.postgresql": "tortoise.backends.psycopg",
+    },
+
+    # Connection pool settings per database alias
+    "CONNECTION_POOL": {
+        "default": {"minsize": 5, "maxsize": 20},
+    },
+
+    # Logging level
+    "LOG_LEVEL": "WARNING",
+}
+```
+
+All settings are optional. With no configuration, all models are included and database backends are auto-detected from Django's `DATABASES` setting.
+
+## Supported Field Types
+
+| Django Field | Tortoise Field |
+|---|---|
+| CharField, SlugField, EmailField, URLField | CharField |
+| TextField | TextField |
+| IntegerField, BigIntegerField, SmallIntegerField | IntField, BigIntField, SmallIntField |
+| BooleanField | BooleanField |
+| FloatField | FloatField |
+| DecimalField | DecimalField |
+| DateField, DateTimeField, TimeField | DateField, DatetimeField, TimeField |
+| DurationField | TimeDeltaField |
+| UUIDField | UUIDField |
+| JSONField | JSONField |
+| BinaryField | BinaryField |
+| FileField, ImageField | CharField (stores path) |
+| ForeignKey | ForeignKeyField |
+| OneToOneField | OneToOneField |
+| ManyToManyField | ManyToManyField |
+| AutoField, BigAutoField, SmallAutoField | IntField/BigIntField/SmallIntField (pk=True) |
+
+## ASGI Lifespan
+
+For production ASGI deployments, explicitly manage Tortoise connections:
+
+```python
+# asgi.py
+from django_tortoise import init, close
+
+async def lifespan(scope, receive, send):
+    if scope["type"] == "lifespan":
+        while True:
+            message = await receive()
+            if message["type"] == "lifespan.startup":
+                await init()
+                await send({"type": "lifespan.startup.complete"})
+            elif message["type"] == "lifespan.shutdown":
+                await close()
+                await send({"type": "lifespan.shutdown.complete"})
+                return
+```
+
+If you don't set up lifespan, connections are initialized lazily on first query.
+
+## Generating Static Tortoise Models
+
+By default, Tortoise models are generated dynamically at runtime. If you want static files you can inspect, customize, or version-control, use the management command:
+
+```bash
+# Generate for all apps
+python manage.py generate_tortoise_models --output-dir ./tortoise_models
+
+# Generate for a specific app
+python manage.py generate_tortoise_models --app-label demo --output-dir .
+
+# Custom Tortoise app name
+python manage.py generate_tortoise_models --tortoise-app-name myapp
+```
+
+This produces one file per Django app (e.g., `tortoise_models_demo.py`):
+
+```python
+# Auto-generated by django-tortoise-objects. Do not edit manually.
+
+import uuid
+
+from tortoise import fields
+from tortoise.fields.relational import OnDelete
+from tortoise.models import Model
+
+
+class DepartmentTortoise(Model):
+    id = fields.BigIntField(primary_key=True, generated=True)
+    name = fields.CharField(max_length=200)
+    code = fields.CharField(unique=True, max_length=20)
+    budget = fields.DecimalField(default=0, max_digits=14, decimal_places=2)
+    is_active = fields.BooleanField(default=True)
+
+    class Meta:
+        table = "demo_department"
+        app = "django_tortoise"
+
+
+class TeamTortoise(Model):
+    id = fields.BigIntField(primary_key=True, generated=True)
+    name = fields.CharField(max_length=200)
+    department = fields.ForeignKeyField(
+        "django_tortoise.DepartmentTortoise",
+        related_name='teams',
+        on_delete=OnDelete.CASCADE,
+        source_field='department_id',
+    )
+
+    class Meta:
+        table = "demo_team"
+        app = "django_tortoise"
+```
+
+The command respects `INCLUDE_MODELS` and `EXCLUDE_MODELS` from your `TORTOISE_OBJECTS` settings.
+
+## Limitations & Non-Goals
+
+**Query results are Tortoise model instances, not Django models.** Methods like `tortoise_objects.get()` and `tortoise_objects.filter()` return Tortoise ORM objects. They cannot be passed directly to Django forms, serializers, admin, or template tags that expect Django model instances. Use `tortoise_objects` for async read/write paths (APIs, WebSockets, background tasks) and the regular Django ORM for everything else.
+
+This library is **not** intended to:
+
+- **Replace Django ORM** — it is a complementary tool for async-critical paths, not a full substitute. Django ORM remains the right choice for admin, forms, management commands, and sync views.
+- **Manage schema or migrations** — all schema management is delegated to Django. Tortoise never writes to your database schema.
+- **Support cross-ORM transactions** — you cannot mix Django and Tortoise queries in a single database transaction.
+- **Provide Django admin integration** — Tortoise query results don't work with Django's admin site. Use Django's ORM for admin.
+- **Expose Tortoise-specific features** — Tortoise signals, custom managers, and validators are not bridged.
+- **Generate Django models from Tortoise** — the bridge is one-way only (Django → Tortoise).
+
+**Other things to keep in mind:**
+
+- Tortoise maintains its own connection pool, separate from Django's. Configure pool sizes via the `CONNECTION_POOL` setting to avoid excess connections.
+- Unsupported or custom Django field types are silently skipped during model generation. Check logs at `DEBUG` level if a field is missing.
+- ManyToManyField relations require that the related model is also included in the Tortoise bridge (not excluded via `EXCLUDE_MODELS`).
+
+## Performance
+
+Benchmarks comparing `tortoise_objects` vs Django's native async ORM (`aget`, `acreate`, etc.) on the same models and data. Measured on PostgreSQL (both using psycopg).
+
+### PostgreSQL
+
+![Benchmark results — PostgreSQL](example_project/diagrams/bench_postgres_summary.png)
+
+- `tortoise_objects` wins on single-record ops: `get` 1.3-2.0x, `count` 1.3-1.5x, `exists` 1.5x
+- `tortoise_objects` wins on writes: `create+delete` 1.4-2.6x
+- Bulk fetches nearly tied
+
+See [`example_project/README.md`](example_project/README.md) for full benchmark details, methodology, and raw data.
+
+## Requirements
+
+- Python >= 3.10
+- Django >= 4.2
+- Tortoise ORM >= 1.1.2
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE) for details.

django_tortoise_objects-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+django_tortoise/__init__.py,sha256=xzz7Ik8KOFbGG_unJHBmMkebf0uNcGi0MBizM5gzeps,689
+django_tortoise/_models.py,sha256=aVTW3RjLPzBzVE66y1laGqMdbojal8W9WHiAgwPMXqk,478
+django_tortoise/apps.py,sha256=3Xlyrot4GCW6SGoMdJGEDmzJX1dLDeF0U44vkhFQRds,4116
+django_tortoise/code_generator.py,sha256=Ao5acrJYw01wwLg6bbWZE9iNGRV81oxl7vc4Ifwqtcg,21544
+django_tortoise/conf.py,sha256=AlmPg5ckYOSEmgnXpVyW10zTmbon_UvLOczt0CHwZfw,2503
+django_tortoise/db_config.py,sha256=-SyesMFKrkvrBNhkV3sr7b7DhRjGlItJrHq-L_-IXB0,3127
+django_tortoise/exceptions.py,sha256=7xgmf70kTSmhnAg-23NdjGHZ8urNogBKfd5yCWp-y54,763
+django_tortoise/fields.py,sha256=ldrF5YH44Guzg3ylZr9RLe58PYZQAwHGJrQQHCLXP2w,16893
+django_tortoise/generator.py,sha256=rS6adLXeVTr84aWpB-f_jKH9ifUtOhgRq3kLU3v2_ek,6606
+django_tortoise/initialization.py,sha256=zAWRHPdMHPcAUlRPXESQ6A3klsBuAbKC3A2Rrc5POSc,2841
+django_tortoise/introspection.py,sha256=MicVL6UFxKU4_WEnsjokLXoB8LP_BMopM8tTNK-SgUI,9094
+django_tortoise/manager.py,sha256=olaStapBU9FlQ2lxlVgEkdtQ4n7IeiBrowZvKOhZ6SY,5553
+django_tortoise/registry.py,sha256=6PIlWM8KvDvF3QhwQ8nvRdrXmORMVVFBBT8uYUnn498,4465
+django_tortoise/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_tortoise/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_tortoise/management/commands/generate_tortoise_models.py,sha256=UaIigB4jgzvLq9DtOq3Gevn6q57HnH-hAdeGy7waaKQ,4063
+django_tortoise_objects-0.1.0.dist-info/METADATA,sha256=x-O67hPVa2vCtMzKT_Ub3w_v03_nYF_6FFzJ300XwN4,10914
+django_tortoise_objects-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+django_tortoise_objects-0.1.0.dist-info/licenses/LICENSE,sha256=nMXg2ykzQ9M9PgmkGBI-CJOY2yQ7alX5EcDugUFV1VY,10765
+django_tortoise_objects-0.1.0.dist-info/RECORD,,

django_tortoise_objects-0.1.0.dist-info/WHEEL

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