activemodel 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

activemodel/session_manager.py

@@ -3,24 +3,57 @@ Class to make managing sessions with SQL Model easy. Also provides a common entr
 database environment when testing.
 """
 
+import contextlib
+import contextvars
+import json
 import typing as t
 
 from decouple import config
-from sqlalchemy import Engine
+from pydantic import BaseModel
+from sqlalchemy import Connection, Engine
 from sqlmodel import Session, create_engine
 
 
+def _serialize_pydantic_model(model: BaseModel | list[BaseModel] | None) -> str | None:
+    """
+    Pydantic models do not serialize to JSON. You'll get an error such as:
+
+    'TypeError: Object of type TranscriptEntry is not JSON serializable'
+
+    https://github.com/fastapi/sqlmodel/issues/63#issuecomment-2581016387
+
+    This custom serializer is passed to the DB engine to properly serialize pydantic models to
+    JSON for storage in a JSONB column.
+    """
+
+    # TODO I bet this will fail on lists with mixed types
+
+    if isinstance(model, BaseModel):
+        return model.model_dump_json()
+    if isinstance(model, list):
+        # not everything in a list is a pydantic model
+        def dump_if_model(m):
+            if isinstance(m, BaseModel):
+                return m.model_dump()
+            return m
+
+        return json.dumps([dump_if_model(m) for m in model])
+    else:
+        return json.dumps(model)
+
+
 class SessionManager:
     _instance: t.ClassVar[t.Optional["SessionManager"]] = None
 
-    session_connection: str
+    session_connection: Connection | None
+    "optionally specify a specific session connection to use for all get_session() calls, useful for testing"
 
     @classmethod
     def get_instance(cls, database_url: str | None = None) -> "SessionManager":
         if cls._instance is None:
-            assert (
-                database_url is not None
-            ), "Database URL required for first initialization"
+            assert database_url is not None, (
+                "Database URL required for first initialization"
+            )
             cls._instance = cls(database_url)
 
         return cls._instance
@@ -28,6 +61,7 @@ class SessionManager:
     def __init__(self, database_url: str):
         self._database_url = database_url
         self._engine = None
+
         self.session_connection = None
 
     # TODO why is this type not reimported?
@@ -35,6 +69,7 @@ class SessionManager:
         if not self._engine:
             self._engine = create_engine(
                 self._database_url,
+                json_serializer=_serialize_pydantic_model,
                 echo=config("ACTIVEMODEL_LOG_SQL", cast=bool, default=False),
                 # https://docs.sqlalchemy.org/en/20/core/pooling.html#disconnect-handling-pessimistic
                 pool_pre_ping=True,
@@ -44,6 +79,14 @@ class SessionManager:
         return self._engine
 
     def get_session(self):
+        if gsession := _session_context.get():
+
+            @contextlib.contextmanager
+            def _reuse_session():
+                yield gsession
+
+            return _reuse_session()
+
         if self.session_connection:
             return Session(bind=self.session_connection)
 
@@ -60,3 +103,30 @@ def get_engine():
 
 def get_session():
     return SessionManager.get_instance().get_session()
+
+
+# contextvars must be at the top-level of a module! You will not get a warning if you don't do this.
+_session_context = contextvars.ContextVar[Session | None](
+    "session_context", default=None
+)
+
+
+@contextlib.contextmanager
+def global_session():
+    with SessionManager.get_instance().get_session() as s:
+        token = _session_context.set(s)
+
+        try:
+            yield
+        finally:
+            _session_context.reset(token)
+
+
+async def aglobal_session():
+    with SessionManager.get_instance().get_session() as s:
+        token = _session_context.set(s)
+
+        try:
+            yield
+        finally:
+            _session_context.reset(token)

activemodel/types/__init__.py

@@ -0,0 +1 @@
+from .typeid import TypeIDType

activemodel/types/typeid.py

@@ -3,11 +3,18 @@ Lifted from: https://github.com/akhundMurad/typeid-python/blob/main/examples/sql
 """
 
 from typing import Optional
+from uuid import UUID
 
+from pydantic import (
+    GetJsonSchemaHandler,
+)
+from pydantic_core import CoreSchema, core_schema
 from sqlalchemy import types
 from sqlalchemy.util import generic_repr
 from typeid import TypeID
 
+from activemodel.errors import TypeIDValidationError
+
 
 class TypeIDType(types.TypeDecorator):
     """
@@ -45,12 +52,140 @@ class TypeIDType(types.TypeDecorator):
         )
 
     def process_bind_param(self, value, dialect):
-        if self.prefix is None:
-            assert value.prefix is None
-        else:
-            assert value.prefix == self.prefix
+        """
+        This is run when a search query is built or ...
+        """
+
+        if value is None:
+            return None
+
+        if isinstance(value, UUID):
+            # then it's a UUID class, such as UUID('01942886-7afc-7129-8f57-db09137ed002')
+            return value
+
+        if isinstance(value, str) and value.startswith(self.prefix + "_"):
+            # then it's a TypeID such as 'user_01h45ytscbebyvny4gc8cr8ma2'
+            value = TypeID.from_string(value)
+
+        if isinstance(value, str):
+            # no prefix, raw UUID, let's coerce it into a UUID which SQLAlchemy can handle
+            # ex: '01942886-7afc-7129-8f57-db09137ed002'
+            return UUID(value)
+
+        if isinstance(value, TypeID):
+            # TODO in what case could this None prefix ever occur?
+            if self.prefix is None:
+                if value.prefix is None:
+                    raise TypeIDValidationError(
+                        "Must have a valid prefix set on the class"
+                    )
+            else:
+                if value.prefix != self.prefix:
+                    raise TypeIDValidationError(
+                        f"Expected '{self.prefix}' but got '{value.prefix}'"
+                    )
+
+            return value.uuid
 
-        return value.uuid
+        raise ValueError("Unexpected input type")
 
     def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+
         return TypeID.from_uuid(value, self.prefix)
+
+    # def coerce_compared_value(self, op, value):
+    #     """
+    #     This method is called when SQLAlchemy needs to compare a column to a value.
+    #     By returning self, we indicate that this type can handle TypeID instances.
+    #     """
+    #     if isinstance(value, TypeID):
+    #         return self
+
+    #     return super().coerce_compared_value(op, value)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, _core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
+    ) -> CoreSchema:
+        """
+        This fixes the following error: 'Unable to serialize unknown type' by telling pydantic how to serialize this field.
+
+        Note that TypeIDType MUST be the type of the field in SQLModel otherwise you'll get serialization errors.
+        This is done automatically for the mixin but for any relationship fields you'll need to specify the type explicitly.
+
+        - https://github.com/karma-dev-team/karma-system/blob/ee0c1a06ab2cb7aaca6dc4818312e68c5c623365/app/server/value_objects/steam_id.py#L88
+        - https://github.com/hhimanshu/uv-workspaces/blob/main/packages/api/src/_lib/dto/typeid_field.py
+        - https://github.com/karma-dev-team/karma-system/blob/ee0c1a06ab2cb7aaca6dc4818312e68c5c623365/app/base/typeid/type_id.py#L14
+        - https://github.com/pydantic/pydantic/issues/10060
+        - https://github.com/fastapi/fastapi/discussions/10027
+        - https://github.com/alice-biometrics/petisco/blob/b01ef1b84949d156f73919e126ed77aa8e0b48dd/petisco/base/domain/model/uuid.py#L50
+        """
+
+        from_uuid_schema = core_schema.chain_schema(
+            [
+                # TODO not sure how this is different from the UUID schema, should try it  out.
+                # core_schema.is_instance_schema(TypeID),
+                # core_schema.uuid_schema(),
+                core_schema.no_info_plain_validator_function(
+                    TypeID.from_string,
+                    json_schema_input_schema=core_schema.str_schema(),
+                ),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=from_uuid_schema,
+            # metadata=core_schema.str_schema(
+            #     pattern="^[0-9a-f]{24}$",
+            #     min_length=24,
+            #     max_length=24,
+            # ),
+            # metadata={
+            #     "pydantic_js_input_core_schema": core_schema.str_schema(
+            #         pattern="^[0-9a-f]{24}$",
+            #         min_length=24,
+            #         max_length=24,
+            #     )
+            # },
+            python_schema=core_schema.union_schema([from_uuid_schema]),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda x: str(x)
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, schema: CoreSchema, handler: GetJsonSchemaHandler
+    ):
+        """
+        Called when generating the openapi schema. This overrides the `function-plain` type which
+        is generated by the `no_info_plain_validator_function`.
+
+        This logis seems to be a hot part of the codebase, so I'd expect this to break as pydantic
+        fastapi continue to evolve.
+
+        Note that this method can return multiple types. A return value can be as simple as:
+
+        {"type": "string"}
+
+        Or, you could return a more specific JSON schema type:
+
+        core_schema.uuid_schema()
+
+        The problem with using something like uuid_schema is the specifi patterns
+
+        https://github.com/BeanieODM/beanie/blob/2190cd9d1fc047af477d5e6897cc283799f54064/beanie/odm/fields.py#L153
+        """
+
+        return {
+            "type": "string",
+            # TODO implement a more strict pattern in regex
+            #      https://github.com/jetify-com/typeid/blob/3d182feed5687c21bb5ab93d5f457ff96749b68b/spec/README.md?plain=1#L38
+            # "pattern": "^[0-9a-f]{24}$",
+            # "minLength": 24,
+            # "maxLength": 24,
+        }
+
+        return core_schema.uuid_schema()

activemodel/utils.py

@@ -1,15 +1,65 @@
+import inspect
+import pkgutil
+import sys
+from types import ModuleType
+
+from sqlalchemy import text
+from sqlmodel import SQLModel
 from sqlmodel.sql.expression import SelectOfScalar
 
-from activemodel import get_engine
+from .logger import logger
+from .session_manager import get_engine, get_session
 
 
 def compile_sql(target: SelectOfScalar):
+    "convert a query into SQL, helpful for debugging"
     dialect = get_engine().dialect
     # TODO I wonder if we could store the dialect to avoid getting an engine reference
     compiled = target.compile(dialect=dialect, compile_kwargs={"literal_binds": True})
     return str(compiled)
 
 
+# TODO document further, lots of risks here
 def raw_sql_exec(raw_query: str):
     with get_session() as session:
         session.execute(text(raw_query))
+
+
+def find_all_sqlmodels(module: ModuleType):
+    """Import all model classes from module and submodules into current namespace."""
+
+    logger.debug(f"Starting model import from module: {module.__name__}")
+    model_classes = {}
+
+    # Walk through all submodules
+    for loader, module_name, is_pkg in pkgutil.walk_packages(module.__path__):
+        full_name = f"{module.__name__}.{module_name}"
+        logger.debug(f"Importing submodule: {full_name}")
+
+        # Check if module is already imported
+        if full_name in sys.modules:
+            submodule = sys.modules[full_name]
+        else:
+            logger.warning(
+                f"Module not found in sys.modules, not importing: {full_name}"
+            )
+            continue
+
+        # Get all classes from module
+        for name, obj in inspect.getmembers(submodule):
+            if inspect.isclass(obj) and issubclass(obj, SQLModel) and obj != SQLModel:
+                logger.debug(f"Found model class: {name}")
+                model_classes[name] = obj
+
+    logger.debug(f"Completed model import. Found {len(model_classes)} models")
+    return model_classes
+
+
+def hash_function_code(func):
+    "get sha of a function to easily assert that it hasn't changed"
+
+    import hashlib
+    import inspect
+
+    source = inspect.getsource(func)
+    return hashlib.sha256(source.encode()).hexdigest()

activemodel-0.7.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: activemodel
+Version: 0.7.0
+Summary: Make SQLModel more like an a real ORM
+Project-URL: Repository, https://github.com/iloveitaly/activemodel
+Author-email: Michael Bianco <iloveitaly@gmail.com>
+License-File: LICENSE
+Keywords: activemodel,activerecord,orm,sqlalchemy,sqlmodel
+Requires-Python: >=3.10
+Requires-Dist: pydash>=8.0.4
+Requires-Dist: python-decouple-typed>=3.11.0
+Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: typeid-python>=0.3.1
+Description-Content-Type: text/markdown
+
+# ActiveModel: ORM Wrapper for SQLModel
+
+No, this isn't *really* [ActiveModel](https://guides.rubyonrails.org/active_model_basics.html). It's just a wrapper around SQLModel that provides a more ActiveRecord-like interface.
+
+SQLModel is *not* an ORM. It's a SQL query builder and a schema definition tool.
+
+This package provides a thin wrapper around SQLModel that provides a more ActiveRecord-like interface with things like:
+
+* Timestamp column mixins
+* Lifecycle hooks
+
+## Getting Started
+
+First, setup your DB:
+
+```python
+
+```
+
+Then, setup some models:
+
+```python
+from activemodel import BaseModel
+from activemodel.mixins import TimestampsMixin, TypeIDMixin
+
+class User(
+    BaseModel,
+    # optionally, obviously
+    TimestampsMixin,
+    # you can use a different pk type, but why would you?
+    # put this mixin last otherwise `id` will not be the first column in the DB
+    TypeIDMixin("user"),
+    # wire this model into the DB, without this alembic will not generate a migration
+    table=True
+):
+    a_field: str
+```
+
+## Usage
+
+### Integrating Alembic
+
+`alembic init` will not work out of the box. You need to mutate a handful of files:
+
+* To import all of your models you want in your DB. [Here's my recommended way to do this.](https://github.com/iloveitaly/python-starter-template/blob/master/app/models/__init__.py)
+* Use your DB URL from the ENV
+* Target sqlalchemy metadata to the sqlmodel-generated metadata
+
+[Take a look at these scripts for an example of how to fully integrate Alembic into your development workflow.](https://github.com/iloveitaly/python-starter-template/blob/0af2c7e95217e34bde7357cc95be048900000e48/Justfile#L618-L712)
+
+Here's a diff from the bare `alembic init` from version `1.14.1`.
+
+```diff
+diff --git i/test/migrations/alembic.ini w/test/migrations/alembic.ini
+index 0d07420..a63631c 100644
+--- i/test/migrations/alembic.ini
++++ w/test/migrations/alembic.ini
+@@ -3,13 +3,14 @@
+ [alembic]
+ # path to migration scripts
+ # Use forward slashes (/) also on windows to provide an os agnostic path
+-script_location = .
++script_location = migrations
+ 
+ # template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+ # Uncomment the line below if you want the files to be prepended with date and time
+ # see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+ # for all available tokens
+ # file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
++file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(rev)s_%%(slug)s
+ 
+ # sys.path path, will be prepended to sys.path if present.
+ # defaults to the current working directory.
+diff --git i/test/migrations/env.py w/test/migrations/env.py
+index 36112a3..a1e15c2 100644
+--- i/test/migrations/env.py
++++ w/test/migrations/env.py
+@@ -1,3 +1,6 @@
++# fmt: off
++# isort: off
++
+ from logging.config import fileConfig
+ 
+ from sqlalchemy import engine_from_config
+@@ -14,11 +17,17 @@ config = context.config
+ if config.config_file_name is not None:
+     fileConfig(config.config_file_name)
+ 
++from sqlmodel import SQLModel
++from test.models import *
++from test.utils import database_url
++
++config.set_main_option("sqlalchemy.url", database_url())
++
+ # add your model's MetaData object here
+ # for 'autogenerate' support
+ # from myapp import mymodel
+ # target_metadata = mymodel.Base.metadata
+-target_metadata = None
++target_metadata = SQLModel.metadata
+ 
+ # other values from the config, defined by the needs of env.py,
+ # can be acquired:
+diff --git i/test/migrations/script.py.mako w/test/migrations/script.py.mako
+index fbc4b07..9dc78bb 100644
+--- i/test/migrations/script.py.mako
++++ w/test/migrations/script.py.mako
+@@ -9,6 +9,8 @@ from typing import Sequence, Union
+ 
+ from alembic import op
+ import sqlalchemy as sa
++import sqlmodel
++import activemodel
+ ${imports if imports else ""}
+ 
+ # revision identifiers, used by Alembic.
+```
+
+Here are some useful resources around Alembic + SQLModel:
+
+* https://github.com/fastapi/sqlmodel/issues/85
+* https://testdriven.io/blog/fastapi-sqlmodel/
+
+### Query Wrapper
+
+This tool is added to all `BaseModel`s and makes it easy to write SQL queries. Some examples:
+
+
+
+### Easy Database Sessions
+
+I hate the idea f 
+
+* Behavior should be intuitive and easy to understand. If you run `save()`, it should save, not stick the save in a transaction.
+* Don't worry about dead sessions. This makes it easy to lazy-load computed properties and largely eliminates the need to think about database sessions.
+
+There are a couple of thorny problems we need to solve for here:
+
+* In-memory fastapi servers are not the same as a uvicorn server, which is threaded *and* uses some sort of threadpool model for handling async requests. I don't claim to understand the entire implementation. For global DB session state (a) we can't use global variables (b) we can't use thread-local variables.
+* 
+
+https://github.com/tomwojcik/starlette-context
+
+### Example Queries
+
+* Conditional: `Scrape.select().where(Scrape.id < last_scraped.id).all()`
+* Equality: `MenuItem.select().where(MenuItem.menu_id == menu.id).all()`
+* `IN` example: `CanonicalMenuItem.select().where(col(CanonicalMenuItem.id).in_(canonized_ids)).all()`
+
+### TypeID
+
+I'm a massive fan of Stripe-style prefixed UUIDs. [There's an excellent project](https://github.com/jetify-com/typeid)
+that defined a clear spec for these IDs. I've used the python implementation of this spec and developed a clean integration
+with SQLModel that plays well with fastapi as well.
+
+Here's an example of defining a relationship:
+
+```python
+import uuid
+
+from activemodel import BaseModel
+from activemodel.mixins import TimestampsMixin, TypeIDMixin
+from activemodel.types import TypeIDType
+from sqlmodel import Field, Relationship
+
+from .patient import Patient
+
+class Appointment(
+    BaseModel,
+    # this adds an `id` field to the model with the correct type
+    TypeIDMixin("appointment"),
+    table=True
+):
+    # `foreign_key` is a activemodel-specific method to generate the right `Field` for the relationship
+    # TypeIDType is really important here for fastapi serialization
+    doctor_id: TypeIDType = Doctor.foreign_key()
+    doctor: Doctor = Relationship()
+```
+
+## Limitations
+
+### Validation
+
+SQLModel does not currently support pydantic validations (when `table=True`). This is very surprising, but is actually the intended functionality:
+
+* https://github.com/fastapi/sqlmodel/discussions/897
+* https://github.com/fastapi/sqlmodel/pull/1041
+* https://github.com/fastapi/sqlmodel/issues/453
+* https://github.com/fastapi/sqlmodel/issues/52#issuecomment-1311987732
+
+For validation:
+
+* When consuming API data, use a separate shadow model to validate the data with `table=False` and then inherit from that model in a model with `table=True`.
+* When validating ORM data, use SQL Alchemy hooks.
+
+<!--
+
+This looks neat
+https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d2a4/src/my_model/model.py#L155
+        schema_extra={
+            'pattern': r'^[a-z0-9_\-\.]+\@[a-z0-9_\-\.]+\.[a-z\.]+$'
+        },
+
+extra constraints
+
+https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d2a4/src/my_model/model.py#L424C1-L426C6
+-->
+## Related Projects
+
+* https://github.com/woofz/sqlmodel-basecrud
+* https://github.com/0xthiagomartins/sqlmodel-controller
+
+## Inspiration
+
+* https://github.com/peterdresslar/fastapi-sqlmodel-alembic-pg
+* [Albemic instructions](https://github.com/fastapi/sqlmodel/pull/899/files)
+* https://github.com/fastapiutils/fastapi-utils/
+* https://github.com/fastapi/full-stack-fastapi-template
+* https://github.com/DarylStark/my_data/
+* https://github.com/petrgazarov/FastAPI-app/tree/main/fastapi_app

activemodel-0.7.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+activemodel/__init__.py,sha256=q_lHQyIM70ApvjduTo9GtenQjJXsfYZsAAquD_51kF4,137
+activemodel/base_model.py,sha256=aa5cJYZsRvYYk-TvPP_DoblvtZrn6-KGB7YS0rbAJbw,10964
+activemodel/celery.py,sha256=F2X5VJoNej6yg__nbF2VXaq6MK8jmgUlfo5XXivfgtU,740
+activemodel/errors.py,sha256=wycWYmk9ws4TZpxvTdtXVy2SFESb8NqKgzdivBoF0vw,115
+activemodel/get_column_from_field_patch.py,sha256=Rl1KIsELSLxDGDb4K7l97Fjr1qyXZtlTJlMa7-ddllc,4869
+activemodel/logger.py,sha256=vU7QiGSy_AJuJFmClUocqIJ-Ltku_8C24ZU8L6fLJR0,53
+activemodel/query_wrapper.py,sha256=rNdvueppMse2MIi-RafTEC34GPGRal_wqH2CzhmlWS8,2520
+activemodel/session_manager.py,sha256=JpCN_mTsbYOOud9HsX6mP_HOf3i57O5haMgnv9WOeyU,3874
+activemodel/utils.py,sha256=g17UqkphzTmb6YdpmYwT1TM00eDiXXuWn39-xNiu0AA,2112
+activemodel/mixins/__init__.py,sha256=05EQl2u_Wgf_wkly-GTaTsR7zWpmpKcb96Js7r_rZTw,160
+activemodel/mixins/pydantic_json.py,sha256=HfnUKy_XA7MQcmR9yMTBweaNgxJhhEo3Z07hFz31gIg,2555
+activemodel/mixins/soft_delete.py,sha256=Ax4mGsQI7AVTE8c4GiWxpyB_W179-dDct79GtjP0owU,461
+activemodel/mixins/timestamps.py,sha256=Q-IFljeVVJQqw3XHdOi7dkqzefiVg1zhJvq_bldpmjg,992
+activemodel/mixins/typeid.py,sha256=DGjlIg8PRBYoaBbWkkxc6jkScyl-p53KuSR98lLgAvE,1284
+activemodel/pytest/__init__.py,sha256=W9KKQHbPkyq0jrMXaiL8hG2Nsbjy_LN9HhvgGm8W_7g,98
+activemodel/pytest/transaction.py,sha256=rrsoHnbu79kNdnI5fZeOZr5hzrLB-cQH10MueQp5jV4,1670
+activemodel/pytest/truncate.py,sha256=IGiPLkUm2yyOKww6c6CKcVbwi2xAAFBopx9q2ABfu8w,1582
+activemodel/types/__init__.py,sha256=y5fiGVtPJxGEhuf-TvyrkhM2yaKRcIWo6XAx-CFFjM8,31
+activemodel/types/typeid.py,sha256=uTCtTm-HdvqZ2_wkIAOkCwDMNiNZna9AbSbOBNBca7o,7225
+activemodel-0.7.0.dist-info/METADATA,sha256=Ht_6c2mD2_qGnrEDfMFxazdNqB9P4POPAU7dCrZ0s94,8216
+activemodel-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+activemodel-0.7.0.dist-info/entry_points.txt,sha256=YLX62TP_hR-n3HMBkdBex4W7XRiyOtIPkwy22puIjjQ,61
+activemodel-0.7.0.dist-info/licenses/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
+activemodel-0.7.0.dist-info/RECORD,,

{activemodel-0.5.0.dist-info → activemodel-0.7.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-