amsdal 0.1.26__cp311-cp311-win_amd64.whl → 0.2.0__cp311-cp311-win_amd64.whl

amsdal/mixins/class_versions_mixin.pyi

@@ -1,10 +1,6 @@
-from amsdal.migration.utils import object_schema_to_table_schema as object_schema_to_table_schema
-from amsdal_models.classes.model import Model
-
 class ClassVersionsMixin:
-    @classmethod
-    def _create_table(cls, class_object: Model, *, skip_class_meta: bool = False) -> None: ...
-    @classmethod
-    def init_class_versions(cls, *, create_tables: bool = False) -> None: ...
+    """
+    Mixin class to manage class versions and related table schemas.
+    """
     @staticmethod
     def register_internal_classes() -> None: ...

amsdal/schemas/core/class_object/properties/display_name.py

@@ -1,3 +1,9 @@
 @property  # type: ignore[misc]
 def display_name(self) -> str:  # type: ignore[no-untyped-def]
+    """
+    Returns the display name of the object.
+
+    Returns:
+        str: The display name, which is the title of the object.
+    """
     return self.title

amsdal/schemas/core/file/hooks/pre_create.py

@@ -1,2 +1,11 @@
 def pre_create(self) -> None:  # type: ignore[no-untyped-def]
+    """
+    Prepares the object for creation by setting its size attribute.
+
+    This method calculates the size of the object's data and assigns it to the size attribute.
+    If the data is None, it defaults to an empty byte string.
+
+    Args:
+        None
+    """
     self.size = len(self.data or b'')

amsdal/schemas/core/file/hooks/pre_update.py

@@ -1,2 +1,11 @@
 def pre_update(self):  # type: ignore[no-untyped-def]
+    """
+    Prepares the object for update by setting its size attribute.
+
+    This method calculates the size of the object's data and assigns it to the size attribute.
+    If the data is None, it defaults to an empty byte string.
+
+    Args:
+        None
+    """
     self.size = len(self.data or b'')

amsdal/schemas/core/file/properties/from_file.py

@@ -7,6 +7,18 @@ def from_file(
     cls,
     file_or_path: Path | BinaryIO,
 ) -> 'File':  # type: ignore[name-defined]  # noqa: F821
+    """
+    Creates a `File` object from a file path or a binary file object.
+
+    Args:
+        file_or_path (Path | BinaryIO): The file path or binary file object.
+
+    Returns:
+        File: The created `File` object.
+
+    Raises:
+        ValueError: If the provided path is a directory.
+    """
     if isinstance(file_or_path, Path):
         if file_or_path.is_dir():
             msg = f'{file_or_path} is a directory'

amsdal/schemas/core/file/properties/mimetype.py

@@ -1,5 +1,13 @@
 @property  # type: ignore[misc]
 def mimetype(self) -> str | None:  # type: ignore[no-untyped-def]
+    """
+    Returns the MIME type of the file based on its filename.
+
+    This method uses the `mimetypes` module to guess the MIME type of the file.
+
+    Returns:
+        str | None: The guessed MIME type of the file, or None if it cannot be determined.
+    """
     import mimetypes
 
     return mimetypes.guess_type(self.filename)[0]

amsdal/schemas/core/file/properties/to_file.py

@@ -3,6 +3,18 @@ from typing import BinaryIO
 
 
 def to_file(self, file_or_path: Path | BinaryIO) -> None:  # type: ignore[no-untyped-def]
+    """
+    Writes the object's data to a file path or a binary file object.
+
+    Args:
+        file_or_path (Path | BinaryIO): The file path or binary file object where the data will be written.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the provided path is a directory.
+    """
     if isinstance(file_or_path, Path):
         if file_or_path.is_dir():
             file_or_path = file_or_path / self.name

amsdal/schemas/core/file/properties/validate_data.py

@@ -6,6 +6,19 @@ from pydantic import field_validator
 @field_validator('data')  # type: ignore[misc]
 @classmethod
 def data_base64_decode(cls, v: bytes) -> bytes:  # type: ignore[no-untyped-def]  # noqa: ARG001
+    """
+    Decodes a base64-encoded byte string if it is base64-encoded.
+
+    This method checks if the provided byte string is base64-encoded and decodes it if true.
+    If the byte string is not base64-encoded, it returns the original byte string.
+
+    Args:
+        cls: The class this method belongs to.
+        v (bytes): The byte string to be checked and potentially decoded.
+
+    Returns:
+        bytes: The decoded byte string if it was base64-encoded, otherwise the original byte string.
+    """
     is_base64: bool = False
 
     try:

amsdal/schemas/manager.py

@@ -1,6 +1,6 @@
-from amsdal_models.enums import BaseClasses
-from amsdal_models.schemas.data_models.schema import ObjectSchema
 from amsdal_models.schemas.manager import SchemaManagerHandler
+from amsdal_utils.models.data_models.enums import BaseClasses
+from amsdal_utils.models.data_models.schema import ObjectSchema
 from amsdal_utils.models.enums import SchemaTypes
 from amsdal_utils.utils.singleton import Singleton
 
@@ -8,13 +8,39 @@ from amsdal.configs.main import settings
 
 
 class SchemaManager(metaclass=Singleton):
+    """
+    Manages schema operations including retrieval, invalidation, and sorting.
+
+    This class handles various schema-related operations such as invalidating user schemas,
+    retrieving schemas by name or type, and sorting schemas based on predefined rules.
+    """
+
     def __init__(self) -> None:
         self._schema_manager_handler = SchemaManagerHandler(settings.schemas_root_path)
 
     def invalidate_user_schemas(self) -> None:
+        """
+        Invalidates user schemas.
+
+        This method calls the handler to invalidate all user schemas, ensuring that any cached or outdated schemas
+            are refreshed.
+
+        Returns:
+            None
+        """
         self._schema_manager_handler.invalidate_user_schemas()
 
     def class_schemas(self) -> list[tuple[ObjectSchema, SchemaTypes]]:
+        """
+        Returns a list of tuples containing object schemas and their types.
+
+        This method retrieves and sorts various schemas managed by the schema manager handler.
+        The schemas are categorized into types, core, user, and contrib schemas.
+
+        Returns:
+            list[tuple[ObjectSchema, SchemaTypes]]: A list of tuples where each tuple contains an object schema
+                and its corresponding type.
+        """
         return (
             [
                 (type_schema, SchemaTypes.TYPE)
@@ -41,6 +67,19 @@ class SchemaManager(metaclass=Singleton):
             return 2
 
     def get_schema_by_name(self, title: str, schema_type: SchemaTypes | None = None) -> ObjectSchema | None:
+        """
+        Retrieves a schema by its title and optional type.
+
+        This method searches for a schema with the specified title and optional type
+        among the schemas managed by the schema manager handler.
+
+        Args:
+            title (str): The title of the schema to be retrieved.
+            schema_type (SchemaTypes | None, optional): The type of the schema to be retrieved. Defaults to None.
+
+        Returns:
+            ObjectSchema | None: The schema with the specified title and type, or None if not found.
+        """
         _schemas = self.get_schemas(schema_type)
 
         for schema in _schemas:
@@ -50,6 +89,18 @@ class SchemaManager(metaclass=Singleton):
         return None
 
     def get_schemas(self, schema_type: SchemaTypes | None = None) -> list[ObjectSchema]:
+        """
+        Retrieves schemas based on the provided type.
+
+        This method returns a list of schemas filtered by the specified type. If no type is provided,
+        it returns all schemas managed by the schema manager handler.
+
+        Args:
+            schema_type (SchemaTypes | None, optional): The type of schemas to retrieve. Defaults to None.
+
+        Returns:
+            list[ObjectSchema]: A list of schemas filtered by the specified type, or all schemas if no type is provided.
+        """
         if schema_type == SchemaTypes.CONTRIB:
             return self._schema_manager_handler.contrib_schemas
 

amsdal/schemas/manager.pyi

@@ -1,15 +1,65 @@
 from _typeshed import Incomplete
 from amsdal.configs.main import settings as settings
-from amsdal_models.schemas.data_models.schema import ObjectSchema
+from amsdal_utils.models.data_models.schema import ObjectSchema as ObjectSchema
 from amsdal_utils.models.enums import SchemaTypes
 from amsdal_utils.utils.singleton import Singleton
 
 class SchemaManager(metaclass=Singleton):
+    """
+    Manages schema operations including retrieval, invalidation, and sorting.
+
+    This class handles various schema-related operations such as invalidating user schemas,
+    retrieving schemas by name or type, and sorting schemas based on predefined rules.
+    """
     _schema_manager_handler: Incomplete
     def __init__(self) -> None: ...
-    def invalidate_user_schemas(self) -> None: ...
-    def class_schemas(self) -> list[tuple[ObjectSchema, SchemaTypes]]: ...
+    def invalidate_user_schemas(self) -> None:
+        """
+        Invalidates user schemas.
+
+        This method calls the handler to invalidate all user schemas, ensuring that any cached or outdated schemas
+            are refreshed.
+
+        Returns:
+            None
+        """
+    def class_schemas(self) -> list[tuple[ObjectSchema, SchemaTypes]]:
+        """
+        Returns a list of tuples containing object schemas and their types.
+
+        This method retrieves and sorts various schemas managed by the schema manager handler.
+        The schemas are categorized into types, core, user, and contrib schemas.
+
+        Returns:
+            list[tuple[ObjectSchema, SchemaTypes]]: A list of tuples where each tuple contains an object schema
+                and its corresponding type.
+        """
     @staticmethod
     def _sort_key_for_schema(schema: ObjectSchema) -> int: ...
-    def get_schema_by_name(self, title: str, schema_type: SchemaTypes | None = None) -> ObjectSchema | None: ...
-    def get_schemas(self, schema_type: SchemaTypes | None = None) -> list[ObjectSchema]: ...
+    def get_schema_by_name(self, title: str, schema_type: SchemaTypes | None = None) -> ObjectSchema | None:
+        """
+        Retrieves a schema by its title and optional type.
+
+        This method searches for a schema with the specified title and optional type
+        among the schemas managed by the schema manager handler.
+
+        Args:
+            title (str): The title of the schema to be retrieved.
+            schema_type (SchemaTypes | None, optional): The type of the schema to be retrieved. Defaults to None.
+
+        Returns:
+            ObjectSchema | None: The schema with the specified title and type, or None if not found.
+        """
+    def get_schemas(self, schema_type: SchemaTypes | None = None) -> list[ObjectSchema]:
+        """
+        Retrieves schemas based on the provided type.
+
+        This method returns a list of schemas filtered by the specified type. If no type is provided,
+        it returns all schemas managed by the schema manager handler.
+
+        Args:
+            schema_type (SchemaTypes | None, optional): The type of schemas to retrieve. Defaults to None.
+
+        Returns:
+            list[ObjectSchema]: A list of schemas filtered by the specified type, or all schemas if no type is provided.
+        """

amsdal/services/transaction_execution.pyi

@@ -9,13 +9,62 @@ from typing import Any
 
 logger: Incomplete
 
-def is_transaction(statement: ast.AST) -> bool: ...
+def is_transaction(statement: ast.AST) -> bool:
+    """
+    Determines if a given AST statement is a transaction function.
+
+    This function checks if the provided AST statement is an asynchronous or synchronous function
+    definition that is decorated with the `transaction` decorator.
+
+    Args:
+        statement (ast.AST): The AST statement to check.
+
+    Returns:
+        bool: True if the statement is a transaction function, False otherwise.
+    """
 
 class TransactionExecutionService(metaclass=Singleton):
+    """
+    Service for executing transactions.
+
+    This class provides methods to execute transactions, load transaction functions,
+    and handle asynchronous transactions. It ensures that transactions are executed
+    with the correct arguments and handles any necessary preprocessing of arguments.
+    """
     _transactions: Incomplete
     def __init__(self) -> None: ...
-    def execute_transaction(self, transaction_name: str, args: dict[str, Any], *, load_references: bool = True) -> Any: ...
-    def get_transaction_func(self, transaction_name: str) -> Callable[..., Any]: ...
+    def execute_transaction(self, transaction_name: str, args: dict[str, Any], *, load_references: bool = True) -> Any:
+        """
+        Executes a transaction with the given name and arguments.
+
+        This method retrieves the transaction function by its name, processes the arguments,
+        and executes the transaction. It handles both synchronous and asynchronous transactions
+        and performs necessary preprocessing of arguments, such as loading references.
+
+        Args:
+            transaction_name (str): The name of the transaction to execute.
+            args (dict[str, Any]): The arguments to pass to the transaction function.
+            load_references (bool, optional): Whether to load references in the arguments. Defaults to True.
+
+        Returns:
+            Any: The result of the transaction execution.
+        """
+    def get_transaction_func(self, transaction_name: str) -> Callable[..., Any]:
+        """
+        Retrieves the transaction function by its name.
+
+        This method checks if the transaction function is already loaded in the `_transactions` dictionary.
+        If not, it attempts to load the transaction function from the available transaction definitions.
+
+        Args:
+            transaction_name (str): The name of the transaction function to retrieve.
+
+        Returns:
+            Callable[..., Any]: The transaction function corresponding to the given name.
+
+        Raises:
+            TransactionNotFoundError: If the transaction function with the specified name is not found.
+        """
     @staticmethod
     def _run_async_transaction(transaction_func: Callable[..., Any], args: dict[str, Any]) -> Any: ...
     def _load_transaction(self, transaction_name: str) -> Callable[..., Any]: ...

amsdal/utils/contrib_paths.py

@@ -4,6 +4,16 @@ from pathlib import Path
 
 
 def get_contrib_schemas_paths() -> Generator[Path, None, None]:
+    """
+    Retrieves paths to contribution schemas.
+
+    This function iterates over the configured contributions in the settings and yields
+    the paths to the 'models' directories for each contribution.
+
+    Returns:
+        Generator[Path, None, None]: A generator that yields paths to the 'models' directories
+        of the configured contributions.
+    """
     from amsdal.configs.main import settings
 
     for contrib in settings.CONTRIB:

amsdal/utils/contrib_paths.pyi

@@ -1,4 +1,14 @@
 from collections.abc import Generator
 from pathlib import Path
 
-def get_contrib_schemas_paths() -> Generator[Path, None, None]: ...
+def get_contrib_schemas_paths() -> Generator[Path, None, None]:
+    """
+    Retrieves paths to contribution schemas.
+
+    This function iterates over the configured contributions in the settings and yields
+    the paths to the 'models' directories for each contribution.
+
+    Returns:
+        Generator[Path, None, None]: A generator that yields paths to the 'models' directories
+        of the configured contributions.
+    """

amsdal/utils/tests/helpers.py

@@ -35,24 +35,23 @@ TESTS_DIR = Path(os.getcwd())
 
 
 def create_postgres_database(database: str) -> tuple[str, str, str, str]:
-    import psycopg2
-    from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
+    import psycopg
 
     db_host = os.getenv('POSTGRES_HOST', 'localhost')
     db_port = os.getenv('POSTGRES_PORT', '5432')
     db_user = os.getenv('POSTGRES_USER', 'postgres')
     db_password = os.getenv('POSTGRES_PASSWORD', 'example')
 
-    conn = psycopg2.connect(
+    conn = psycopg.connect(
         host=db_host,
         port=db_port,
         user=db_user,
         password=db_password,
+        autocommit=True,
     )
-    conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
     cur = conn.cursor()
 
-    with suppress(psycopg2.errors.DuplicateDatabase):
+    with suppress(psycopg.errors.DuplicateDatabase):
         cur.execute(f'CREATE DATABASE "{database}"')
 
     cur.close()
@@ -210,7 +209,7 @@ def init_manager(
             config_manager.load_config(config_path)
             manager = AmsdalManager()
             manager.setup()
-            manager.post_setup()
+            manager.post_setup()  # type: ignore[call-arg]
 
             try:
                 yield manager
@@ -306,6 +305,5 @@ def init_manager_and_migrate(
         manager.authenticate()
         migrate(app_schemas_path)
         manager.init_classes()
-        manager.init_class_versions()
 
         yield manager

{amsdal-0.1.26.dist-info → amsdal-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amsdal
-Version: 0.1.26
+Version: 0.2.0
 Summary: AMSDAL
 License: AMSDAL End User License Agreement
         
@@ -130,17 +130,15 @@ Requires-Dist: cryptography ~=42.0
 Requires-Dist: httpx ~=0.25
 Requires-Dist: bcrypt ~=4.0
 Requires-Dist: black >=24.3.0
-Requires-Dist: amsdal-utils ==0.1.*
-Requires-Dist: amsdal-data[postgres] ==0.1.*
-Requires-Dist: amsdal-models ==0.1.*
+Requires-Dist: amsdal-utils ==0.2.*
+Requires-Dist: amsdal-data[postgres-binary] ==0.2.*
+Requires-Dist: amsdal-models ==0.2.*
 Provides-Extra: celery
 Requires-Dist: celery ==5.4.0 ; extra == 'celery'
 Provides-Extra: cli
 Requires-Dist: amsdal-cli ==0.1.* ; extra == 'cli'
 Provides-Extra: factory
 Requires-Dist: polyfactory ==2.* ; extra == 'factory'
-Provides-Extra: redis-lock
-Requires-Dist: amsdal-data[redis-lock] ==0.1.* ; extra == 'redis-lock'
 Provides-Extra: server
 Requires-Dist: amsdal-server ==0.1.* ; extra == 'server'