hexcore 2.1.1__tar.gz

hexcore-2.1.1/LICENSE

@@ -0,0 +1,25 @@
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+MIT License
+
+Copyright (c) 2025 David Latosefki (Indroic)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hexcore-2.1.1/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: hexcore
+Version: 2.1.1
+Summary: Núcleo reutilizable para proyectos Python con arquitectura hexagonal y event handling. Provee abstracciones, utilidades y contratos para DDD, eventos y desacoplamiento de infraestructura.
+Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: alembic>=1.16.5
+Requires-Dist: async-typer>=0.1.10
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: beanie>=2.0.0
+Requires-Dist: build>=1.3.0
+Requires-Dist: fastapi>=0.116.1
+Requires-Dist: pika>=1.3.2
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: redis>=6.4.0
+Requires-Dist: sqlalchemy>=2.0.43
+Requires-Dist: twine>=6.2.0
+Requires-Dist: typer>=0.17.3
+Dynamic: license-file
+
+# HexCore
+
+HexCore es un módulo base reutilizable para proyectos Python que implementan arquitectura hexagonal y event handling.
+
+## ¿Qué provee HexCore?
+
+- **Clases base y abstracciones** para entidades, repositorios, servicios y unidad de trabajo (UoW), siguiendo los principios de DDD y arquitectura hexagonal.
+- **Interfaces y contratos** para caché, eventos y manejo de dependencias, desacoplando la lógica de negocio de la infraestructura.
+- **Utilidades para event sourcing y event dispatching** listas para usar en cualquier proyecto.
+- **Estructura flexible** para que puedas construir microservicios o aplicaciones monolíticas desacopladas y testeables.
+
+---
+
+**Versión:** 2.1.1

hexcore-2.1.1/README.md

@@ -0,0 +1,14 @@
+# HexCore
+
+HexCore es un módulo base reutilizable para proyectos Python que implementan arquitectura hexagonal y event handling.
+
+## ¿Qué provee HexCore?
+
+- **Clases base y abstracciones** para entidades, repositorios, servicios y unidad de trabajo (UoW), siguiendo los principios de DDD y arquitectura hexagonal.
+- **Interfaces y contratos** para caché, eventos y manejo de dependencias, desacoplando la lógica de negocio de la infraestructura.
+- **Utilidades para event sourcing y event dispatching** listas para usar en cualquier proyecto.
+- **Estructura flexible** para que puedas construir microservicios o aplicaciones monolíticas desacopladas y testeables.
+
+---
+
+**Versión:** 2.1.1

hexcore-2.1.1/hexcore/__init__.py

@@ -0,0 +1,42 @@
+"""
+Euphoria Kernel Core
+Submódulo principal con entidades, eventos y repositorios.
+"""
+
+from .domain.base import BaseEntity
+from .domain.auth.permissions import PermissionsEnum
+from .domain.auth.value_objects import TokenClaims
+from .application.dtos.base import DTO
+from .domain.events import (
+    DomainEvent,
+    EntityCreatedEvent,
+    EntityDeletedEvent,
+    EntityUpdatedEvent,
+)
+from .infrastructure.repositories.base import (
+    IBaseRepository,
+    IBaseTenantAwareRepository,
+    BaseSQLRepository,
+    BaseSQLTenantAwareRepository,
+)
+from .infrastructure import cli
+from .infrastructure import cache
+from . import config
+
+__all__ = [
+    "BaseEntity",
+    "PermissionsEnum",
+    "TokenClaims",
+    "DTO",
+    "DomainEvent",
+    "EntityCreatedEvent",
+    "EntityDeletedEvent",
+    "EntityUpdatedEvent",
+    "IBaseRepository",
+    "IBaseTenantAwareRepository",
+    "BaseSQLRepository",
+    "BaseSQLTenantAwareRepository",
+    "cli",
+    "cache",
+    "config",
+]

hexcore-2.1.1/hexcore/__init__.pyi

@@ -0,0 +1,10 @@
+from . import config as config
+from .application.dtos.base import DTO as DTO
+from .domain.auth.permissions import PermissionsEnum as PermissionsEnum
+from .domain.auth.value_objects import TokenClaims as TokenClaims
+from .domain.base import BaseEntity as BaseEntity
+from .domain.events import DomainEvent as DomainEvent, EntityCreatedEvent as EntityCreatedEvent, EntityDeletedEvent as EntityDeletedEvent, EntityUpdatedEvent as EntityUpdatedEvent
+from .infrastructure import cache as cache, cli as cli
+from .infrastructure.repositories.base import BaseSQLRepository as BaseSQLRepository, BaseSQLTenantAwareRepository as BaseSQLTenantAwareRepository, IBaseRepository as IBaseRepository, IBaseTenantAwareRepository as IBaseTenantAwareRepository
+
+__all__ = ['BaseEntity', 'PermissionsEnum', 'TokenClaims', 'DTO', 'DomainEvent', 'EntityCreatedEvent', 'EntityDeletedEvent', 'EntityUpdatedEvent', 'IBaseRepository', 'IBaseTenantAwareRepository', 'BaseSQLRepository', 'BaseSQLTenantAwareRepository', 'cli', 'cache', 'config']

hexcore-2.1.1/hexcore/application/__init__.py

@@ -0,0 +1,8 @@
+"""
+Submódulo de aplicación: DTOs y casos de uso.
+"""
+
+from .dtos.base import DTO
+from .use_cases.base import UseCase
+
+__all__ = ["DTO", "UseCase"]

hexcore-2.1.1/hexcore/application/__init__.pyi

@@ -0,0 +1,4 @@
+from .dtos.base import DTO as DTO
+from .use_cases.base import UseCase as UseCase
+
+__all__ = ['DTO', 'UseCase']

hexcore-2.1.1/hexcore/application/dtos/__init__.py

@@ -0,0 +1,7 @@
+"""
+Submódulo de DTOs base para la aplicación.
+"""
+
+from .base import DTO
+
+__all__ = ["DTO"]

hexcore-2.1.1/hexcore/application/dtos/__init__.pyi

@@ -0,0 +1,3 @@
+from .base import DTO as DTO
+
+__all__ = ['DTO']

hexcore-2.1.1/hexcore/application/dtos/base.py

@@ -0,0 +1,13 @@
+from abc import ABC
+from pydantic import BaseModel
+
+
+class DTO(BaseModel, ABC):
+    """
+    Clase base para todos los DTOs de la capa de aplicación.
+
+    Estos representan los datos que se desea exponer o recibir a través de la API,
+    evitando la exposición de detalles internos del dominio.
+    """
+
+    pass

hexcore-2.1.1/hexcore/application/dtos/base.pyi

@@ -0,0 +1,4 @@
+from abc import ABC
+from pydantic import BaseModel
+
+class DTO(BaseModel, ABC): ...

hexcore-2.1.1/hexcore/application/use_cases/__init__.py

@@ -0,0 +1,7 @@
+"""
+Submódulo de casos de uso base para la aplicación.
+"""
+
+from .base import UseCase
+
+__all__ = ["UseCase"]

hexcore-2.1.1/hexcore/application/use_cases/__init__.pyi

@@ -0,0 +1,3 @@
+from .base import UseCase as UseCase
+
+__all__ = ['UseCase']

hexcore-2.1.1/hexcore/application/use_cases/base.py

@@ -0,0 +1,15 @@
+import typing as t
+from abc import ABC, abstractmethod
+from hexcore.application.dtos.base import DTO
+
+# Tipo del Input
+T = t.TypeVar("T", bound=DTO)
+
+# Tipo del Output(o resultado)
+R = t.TypeVar("R", bound=DTO)
+
+
+class UseCase(ABC, t.Generic[T, R]):
+    @abstractmethod
+    async def execute(self, command: T) -> R:
+        raise NotImplementedError("Subclasses must implement this method")

hexcore-2.1.1/hexcore/application/use_cases/base.pyi

@@ -0,0 +1,11 @@
+import abc
+import typing as t
+from abc import ABC, abstractmethod
+from hexcore.application.dtos.base import DTO as DTO
+
+T = t.TypeVar('T', bound=DTO)
+R = t.TypeVar('R', bound=DTO)
+
+class UseCase(ABC, t.Generic[T, R], metaclass=abc.ABCMeta):
+    @abstractmethod
+    async def execute(self, command: T) -> R: ...

hexcore-2.1.1/hexcore/config.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+import importlib
+import typing as t
+from pydantic import BaseModel, ConfigDict
+from pathlib import Path
+from hexcore.infrastructure.cache import ICache
+from hexcore.domain.events import IEventDispatcher
+
+
+from hexcore.infrastructure.cache.cache_backends.memory import MemoryCache
+from hexcore.infrastructure.events.events_backends.memory import InMemoryEventDispatcher
+
+
+class ServerConfig(BaseModel):
+    # Project Config
+    base_dir: Path = Path(".")
+
+    # SERVER CONFIG
+    host: str = "localhost"
+    port: int = 8000
+    debug: bool = True
+
+    # DB CONFIG
+    sql_database_url: str = "sqlite:///./db.sqlite3"
+    async_sql_database_url: str = "sqlite+aiosqlite:///./db.sqlite3"
+
+    mongo_database_url: str = "mongodb://localhost:27017"
+    async_mongo_database_url: str = "mongodb+async://localhost:27017"
+    mongo_db_name: str = "euphoria_db"
+    mongo_uri: str = "mongodb://localhost:27017/euphoria_db"
+
+    redis_uri: str = "redis://localhost:6379/0"
+    redis_host: str = "localhost"
+    redis_port: int = 6379
+    redis_db: int = 0
+    redis_cache_duration: int = 300  # seconds
+
+    # Security
+    allow_origins: list[str] = [
+        "*" if debug else "http://localhost:{port}".format(port=port)
+    ]
+    allow_credentials: bool = True
+    allow_methods: list[str] = ["*"]
+    allow_headers: list[str] = ["*"]
+
+    # caching
+    cache_backend: ICache = (
+        MemoryCache()
+    )  # Debe ser una instancia de ICache(o subclase)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    # Event Dispatcher
+    event_dispatcher: IEventDispatcher = InMemoryEventDispatcher()
+
+
+class LazyConfig:
+    """
+    Loader de configuración flexible.
+    Busca una variable 'config' (instancia de ServerConfig) o una clase 'ServerConfig' en los módulos personalizados.
+    Si no la encuentra, usa la configuración base del kernel.
+
+    IMPORTANTE: La configuración personalizada debe estar en un módulo llamado 'config' en src.domain
+
+    """
+
+    _imported_config: t.Optional[ServerConfig] = None
+
+    @classmethod
+    def get_config(cls) -> ServerConfig:
+        if cls._imported_config is not None:
+            return cls._imported_config
+        # Intenta importar la config personalizada
+        for modpath in ("config", "src.domain.config"):
+            try:
+                mod = importlib.import_module(modpath)
+                config_instance = getattr(mod, "config", None)
+                if config_instance is not None:
+                    # Si es clase, instanciar
+                    if isinstance(config_instance, type) and issubclass(
+                        config_instance, ServerConfig
+                    ):
+                        config_instance = config_instance()
+                    if isinstance(config_instance, ServerConfig):
+                        cls._imported_config = config_instance
+                        return cls._imported_config
+                # Alternativamente, busca la clase ServerConfig
+                config_class = getattr(mod, "ServerConfig", None)
+                if isinstance(config_class, type) and issubclass(
+                    config_class, ServerConfig
+                ):
+                    config_instance = config_class()
+                    cls._imported_config = config_instance
+                    return cls._imported_config
+            except (ModuleNotFoundError, AttributeError):
+                continue
+        # Fallback: config base del kernel
+        cls._imported_config = ServerConfig()
+        return cls._imported_config

hexcore-2.1.1/hexcore/config.pyi

@@ -0,0 +1,35 @@
+from _typeshed import Incomplete
+from hexcore.domain.events import IEventDispatcher as IEventDispatcher
+from hexcore.infrastructure.cache import ICache as ICache
+from hexcore.infrastructure.cache.cache_backends.memory import MemoryCache as MemoryCache
+from hexcore.infrastructure.events.events_backends.memory import InMemoryEventDispatcher as InMemoryEventDispatcher
+from pathlib import Path
+from pydantic import BaseModel
+
+class ServerConfig(BaseModel):
+    base_dir: Path
+    host: str
+    port: int
+    debug: bool
+    sql_database_url: str
+    async_sql_database_url: str
+    mongo_database_url: str
+    async_mongo_database_url: str
+    mongo_db_name: str
+    mongo_uri: str
+    redis_uri: str
+    redis_host: str
+    redis_port: int
+    redis_db: int
+    redis_cache_duration: int
+    allow_origins: list[str]
+    allow_credentials: bool
+    allow_methods: list[str]
+    allow_headers: list[str]
+    cache_backend: ICache
+    model_config: Incomplete
+    event_dispatcher: IEventDispatcher
+
+class LazyConfig:
+    @classmethod
+    def get_config(cls) -> ServerConfig: ...

hexcore-2.1.1/hexcore/domain/auth/__init__.py

@@ -0,0 +1,17 @@
+"""
+Submódulo de autenticación y permisos del kernel.
+"""
+
+from .permissions import (
+    PermissionsEnum,
+    get_all_permission_values,
+    get_owner_permissions,
+)
+from .value_objects import TokenClaims
+
+__all__ = [
+    "PermissionsEnum",
+    "get_all_permission_values",
+    "get_owner_permissions",
+    "TokenClaims",
+]

hexcore-2.1.1/hexcore/domain/auth/__init__.pyi

@@ -0,0 +1,4 @@
+from .permissions import PermissionsEnum as PermissionsEnum, get_all_permission_values as get_all_permission_values, get_owner_permissions as get_owner_permissions
+from .value_objects import TokenClaims as TokenClaims
+
+__all__ = ['PermissionsEnum', 'get_all_permission_values', 'get_owner_permissions', 'TokenClaims']

hexcore-2.1.1/hexcore/domain/auth/permissions.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from enum import Enum
+
+# --- Prefijos de Permisos ---
+_ROLES = "roles"
+_USERS = "users"
+_TENANTS = "tenants"
+
+_LOGISTICS_INVENTORY = "logistics.inventory"
+_LOGISTICS_PRODUCTS = "logistics.products"
+
+# --- Sufijos Comunes ---
+
+_VIEW = "view"
+_CREATE = "create"
+_EDIT = "edit"
+_DELETE = "delete"
+
+
+class PermissionsEnum(str, Enum):
+    """
+    Catálogo central de todos los permisos del sistema.
+    Esta es la ÚNICA fuente de la verdad para los permisos.
+    El valor (string) es lo que se almacena en la base de datos.
+    El formato es: <dominio>.<entidad>.<accion>
+    """
+
+    # -- SUPERUSER PERMISSION --
+
+    SUPERUSER = "__all__"  # Permiso especial que otorga todos los permisos del sistema
+
+    # --- Dominio: IAM (Identidad y Acceso) ---
+    ROLES_VIEW = f"{_ROLES}.{_VIEW}"
+    ROLES_CREATE = f"{_ROLES}.{_CREATE}"
+    ROLES_EDIT = f"{_ROLES}.{_EDIT}"
+    ROLES_DELETE = f"{_ROLES}.{_DELETE}"
+
+    USERS_CREATE = f"{_USERS}.{_CREATE}"
+    USERS_VIEW = f"{_USERS}.{_VIEW}"
+    USERS_INVITE = f"{_USERS}.invite"
+    USERS_EDIT = f"{_USERS}.{_EDIT}"
+    USERS_DELETE = f"{_USERS}.{_DELETE}"
+    USERS_ADD_ROLE = f"{_USERS}.add.rol"
+
+    TENANTS_VIEW = f"{_TENANTS}.{_VIEW}"
+    TENANTS_EDIT = f"{_TENANTS}.{_EDIT}"
+
+    # --- Dominio: Logistics (Logística) ---
+    LOGISTICS_INVENTORY_VIEW = f"{_LOGISTICS_INVENTORY}.{_VIEW}"
+    LOGISTICS_INVENTORY_ADJUST = f"{_LOGISTICS_INVENTORY}.adjust"
+    LOGISTICS_PRODUCTS_MANAGE = f"{_LOGISTICS_PRODUCTS}.manage"
+
+
+# Permisos que No puede tener un propietario
+OWNER_EXCLUDED_PERMISSIONS = {
+    PermissionsEnum.TENANTS_EDIT,
+    PermissionsEnum.TENANTS_VIEW,
+}
+
+
+def get_all_permission_values() -> set[str]:
+    """
+    Devuelve un conjunto con todos los valores de los permisos definidos en PermissionsEnum.
+    Ideal para usar en el comando de sincronización.
+    """
+    return {p.value for p in PermissionsEnum}
+
+
+def get_owner_permissions() -> set[str]:
+    """
+    Devuelve los permisos de un propietario.
+    """
+    return {p.value for p in PermissionsEnum} - OWNER_EXCLUDED_PERMISSIONS

hexcore-2.1.1/hexcore/domain/auth/permissions.pyi

@@ -0,0 +1,25 @@
+from _typeshed import Incomplete
+from enum import Enum
+
+class PermissionsEnum(str, Enum):
+    SUPERUSER = '__all__'
+    ROLES_VIEW = ...
+    ROLES_CREATE = ...
+    ROLES_EDIT = ...
+    ROLES_DELETE = ...
+    USERS_CREATE = ...
+    USERS_VIEW = ...
+    USERS_INVITE = ...
+    USERS_EDIT = ...
+    USERS_DELETE = ...
+    USERS_ADD_ROLE = ...
+    TENANTS_VIEW = ...
+    TENANTS_EDIT = ...
+    LOGISTICS_INVENTORY_VIEW = ...
+    LOGISTICS_INVENTORY_ADJUST = ...
+    LOGISTICS_PRODUCTS_MANAGE = ...
+
+OWNER_EXCLUDED_PERMISSIONS: Incomplete
+
+def get_all_permission_values() -> set[str]: ...
+def get_owner_permissions() -> set[str]: ...

hexcore-2.1.1/hexcore/domain/auth/value_objects.py

@@ -0,0 +1,18 @@
+import typing as t
+
+from uuid import uuid4
+from pydantic import Field, BaseModel
+from .permissions import PermissionsEnum
+
+
+class TokenClaims(BaseModel):
+    """Detalles sobre los claims de un token."""
+
+    iss: str  # Identificador del token de acceso
+    sub: str  # ID del usuario
+    exp: int  # Tiempo de expiración
+    iat: int  # Tiempo de emisión
+    jti: str = Field(default_factory=lambda: str(uuid4()))  # ID del token
+    client_id: str  # ID del cliente OAuth
+    scopes: t.List[PermissionsEnum] = []  # Permisos del Token
+    tenant_id: t.Optional[str] = None  # ID del tenant (si aplica)

hexcore-2.1.1/hexcore/domain/auth/value_objects.pyi

@@ -0,0 +1,12 @@
+from .permissions import PermissionsEnum as PermissionsEnum
+from pydantic import BaseModel
+
+class TokenClaims(BaseModel):
+    iss: str
+    sub: str
+    exp: int
+    iat: int
+    jti: str
+    client_id: str
+    scopes: list[PermissionsEnum]
+    tenant_id: str | None

hexcore-2.1.1/hexcore/domain/base.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+import typing as t
+import abc
+from pydantic import BaseModel, Field, ConfigDict
+from uuid import UUID, uuid4
+from datetime import datetime, UTC
+
+if t.TYPE_CHECKING:
+    from hexcore.domain.events import DomainEvent
+
+
+class BaseEntity(BaseModel):
+    """
+    Clase base para todas las entidades del dominio.
+
+    Proporciona campos comunes y configuración de Pydantic para asegurar consistencia
+    y comportamiento predecible en todo el modelo.
+
+    Atributos:
+        id (UUID): Identificador único universal para la entidad.
+        created_at (datetime): Marca de tiempo de la creación de la entidad (UTC).
+        updated_at (datetime): Marca de tiempo de la última actualización (UTC).
+        is_active (bool): Indicador para borrado lógico (soft delete).
+    """
+
+    id: UUID = Field(default_factory=uuid4)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    is_active: t.Optional[bool] = True
+
+    _domain_events: t.List[DomainEvent] = []
+
+    model_config = ConfigDict(
+        from_attributes=True,  # Permite crear modelos desde atributos de objetos (clave para ORMs).
+        validate_assignment=True,  # Vuelve a validar la entidad cada vez que se modifica un campo.
+        # `frozen=True` hace que las entidades sean inmutables, lo cual es un ideal de DDD.
+        # Sin embargo, puede complicar el manejo de estado con un ORM como SQLAlchemy,
+        # donde los objetos a menudo se modifican y luego se guardan.
+        # Lo cambiamos a False para un enfoque más pragmático.
+        frozen=False,
+    )
+
+    def register_event(self, event: DomainEvent):
+        """Añade un evento a la lista de la entidad."""
+        self._domain_events.append(event)
+
+    def pull_domain_events(self) -> t.List[DomainEvent]:
+        """Entrega los eventos y limpia la lista."""
+        events = self._domain_events[:]
+        self._domain_events.clear()
+        return events
+
+    def clear_domain_events(self):
+        """Limpia la lista de eventos sin entregarlos."""
+        self._domain_events.clear()
+
+    async def deactivate(self):
+        """Desactiva la Entidad(Borrado Logico)"""
+        self.is_active = False
+
+
+class AbstractModelMeta(BaseEntity, abc.ABC):
+    """
+    Metaclase para resolver un conflicto entre Pydantic y las clases abstractas de Python.
+
+    Problema:
+        - Pydantic (`BaseModel`) usa su propia metaclase para la validación de datos.
+        - Las clases abstractas de Python (`abc.ABC`) usan `abc.ABCMeta` para permitir `@abstractmethod`.
+        - Una clase no puede tener dos metaclases diferentes.
+
+    Solución:
+        Esta metaclase combina ambas, permitiendo crear clases que son a la vez
+        modelos de Pydantic y clases base abstractas.
+
+    Uso:
+        class MiClaseAbstracta(BaseEntity, abc.ABC, metaclass=AbstractModelMeta):
+            ...
+    """
+
+    pass

hexcore-2.1.1/hexcore/domain/base.pyi

@@ -0,0 +1,19 @@
+import abc
+from _typeshed import Incomplete
+from datetime import datetime
+from hexcore.domain.events import DomainEvent as DomainEvent
+from pydantic import BaseModel
+from uuid import UUID
+
+class BaseEntity(BaseModel):
+    id: UUID
+    created_at: datetime
+    updated_at: datetime
+    is_active: bool | None
+    model_config: Incomplete
+    def register_event(self, event: DomainEvent): ...
+    def pull_domain_events(self) -> list[DomainEvent]: ...
+    def clear_domain_events(self) -> None: ...
+    async def deactivate(self) -> None: ...
+
+class AbstractModelMeta(BaseEntity, abc.ABC): ...