swiftpy-framework 0.1.0__py3-none-any.whl

swiftpy/__init__.py

@@ -0,0 +1,572 @@
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from swiftpy.admin import (
+        AdminSite,
+        ModelAdmin,
+        admin,
+    )
+    from swiftpy.ai.agents import (
+        Agent,
+        AgentMemory,
+        AgentResponse,
+        AgentTask,
+        BaseAgent,
+    )
+    from swiftpy.auth import (
+        ApiKeyGuard,
+        AuthManager,
+        CurrentUser,
+        JWTGuard,
+        JWTIssuer,
+        TokenBlacklist,
+        current_user,
+        hash_api_key,
+        require_api_key,
+        require_jwt,
+        verify_api_key_hash,
+    )
+    from swiftpy.cache import (
+        Cache,
+        CacheDriver,
+        CacheManager,
+        MemoryDriver,
+        RedisDriver,
+    )
+    from swiftpy.core.application import Application
+    from swiftpy.core.config import Config
+    from swiftpy.core.container import Container
+    from swiftpy.core.container_exceptions import CircularDependencyError
+    from swiftpy.core.exceptions import (
+        BadRequestError,
+        ClientDisconnect,
+        ExceptionHandler,
+        ForbiddenError,
+        HttpException,
+        InternalServerError,
+        MethodNotAllowedError,
+        NotFoundError,
+        PayloadTooLargeError,
+        UnauthorizedError,
+        ValidationError,
+    )
+    from swiftpy.core.providers.base import ServiceProvider
+    from swiftpy.database import (
+        DatabaseError,
+        ModelNotFoundError,
+        RecordNotFoundError,
+        Seeder,
+    )
+    from swiftpy.database.orm import (
+        BelongsTo,
+        BelongsToMany,
+        Field,
+        HasMany,
+        HasOne,
+        LazyLoadingDisabledError,
+        Model,
+        RelationNotLoadedError,
+        Vector,
+    )
+    from swiftpy.database.pagination import (
+        Paginator,
+        SimplePaginator,
+    )
+    from swiftpy.events import (
+        EventDispatcher,
+        EventHandler,
+        RedisEventBus,
+    )
+    from swiftpy.filesystem import (
+        FileMetadata,
+        FilesystemManager,
+        LocalStorageDriver,
+        PathNormalizer,
+        S3StorageDriver,
+        Storage,
+        StorageDisk,
+        StorageDriver,
+        UploadedFile,
+        Visibility,
+    )
+    from swiftpy.helpers.helper import (
+        app,
+        cache,
+        config,
+        container,
+        dispatch,
+        dispatcher,
+        env,
+        env_bool,
+        event,
+        mail,
+        pluralize,
+        queue,
+        resolve,
+        snake_case,
+        storage,
+        websocket_manager,
+        ws_manager,
+    )
+    from swiftpy.http.middleware import (
+        CORS,
+        CORSMiddleware,
+        Middleware,
+        RequestId,
+        RequestIdMiddleware,
+        SecurityHeaders,
+        SecurityHeadersMiddleware,
+    )
+    from swiftpy.http.request import Request
+    from swiftpy.http.response import (
+        Response,
+        forbidden,
+        json_response,
+        unauthorized,
+    )
+    from swiftpy.http.router import RouteGroup, Router
+    from swiftpy.mail import (
+        Attachment,
+        Mail,
+        Mailable,
+        MailFake,
+        MailManager,
+        MailMessage,
+        MailSendResult,
+        MailTransport,
+    )
+    from swiftpy.queue import (
+        Job,
+        JobSerializationError,
+        QueueDispatcher,
+        QueueWorker,
+        push,
+    )
+    from swiftpy.testing import (
+        TestCase,
+        TestClient,
+        TestResponse,
+        db_transaction,
+        transactional_test,
+    )
+    from swiftpy.validation import (
+        BetweenRule,
+        BoolRule,
+        EmailRule,
+        ExistsRule,
+        FloatRule,
+        FormRequest,
+        InRule,
+        IntRule,
+        MaxRule,
+        MinRule,
+        NotInRule,
+        NullableRule,
+        RegexRule,
+        RequiredRule,
+        StrRule,
+        UniqueRule,
+        UrlRule,
+        ValidationException,
+        ValidationResult,
+        Validator,
+        ValidatorRule,
+        between,
+        bool_,
+        email,
+        exists,
+        float_,
+        in_,
+        int_,
+        max_,
+        min_,
+        not_in,
+        nullable,
+        regex,
+        required,
+        str_,
+        unique,
+        url,
+        validate,
+    )
+    from swiftpy.websockets import (
+        WebSocket,
+        WebSocketConnection,
+        WebSocketDisconnect,
+        WebSocketException,
+        WebSocketManager,
+        WebSocketState,
+    )
+
+_EXPORT_MAP: dict[str, tuple[str, str]] = {
+    'AdminSite': ('swiftpy.admin', 'AdminSite'),
+    'Agent': ('swiftpy.ai.agents', 'Agent'),
+    'AgentMemory': ('swiftpy.ai.agents', 'AgentMemory'),
+    'AgentResponse': ('swiftpy.ai.agents', 'AgentResponse'),
+    'AgentTask': ('swiftpy.ai.agents', 'AgentTask'),
+    'ApiKeyGuard': ('swiftpy.auth', 'ApiKeyGuard'),
+    'Application': ('swiftpy.core.application', 'Application'),
+    'Attachment': ('swiftpy.mail', 'Attachment'),
+    'AuthManager': ('swiftpy.auth', 'AuthManager'),
+    'BadRequestError': ('swiftpy.core.exceptions', 'BadRequestError'),
+    'BaseAgent': ('swiftpy.ai.agents', 'BaseAgent'),
+    'BelongsTo': ('swiftpy.database.orm', 'BelongsTo'),
+    'BelongsToMany': ('swiftpy.database.orm', 'BelongsToMany'),
+    'BetweenRule': ('swiftpy.validation', 'BetweenRule'),
+    'BoolRule': ('swiftpy.validation', 'BoolRule'),
+    'CORS': ('swiftpy.http.middleware', 'CORS'),
+    'CORSMiddleware': ('swiftpy.http.middleware', 'CORSMiddleware'),
+    'Cache': ('swiftpy.cache', 'Cache'),
+    'CacheDriver': ('swiftpy.cache', 'CacheDriver'),
+    'CacheManager': ('swiftpy.cache', 'CacheManager'),
+    'CircularDependencyError': ('swiftpy.core.container_exceptions', 'CircularDependencyError'),
+    'ClientDisconnect': ('swiftpy.core.exceptions', 'ClientDisconnect'),
+    'Config': ('swiftpy.core.config', 'Config'),
+    'Container': ('swiftpy.core.container', 'Container'),
+    'CurrentUser': ('swiftpy.auth', 'CurrentUser'),
+    'DatabaseError': ('swiftpy.database', 'DatabaseError'),
+    'EmailRule': ('swiftpy.validation', 'EmailRule'),
+    'EventDispatcher': ('swiftpy.events', 'EventDispatcher'),
+    'EventHandler': ('swiftpy.events', 'EventHandler'),
+    'ExceptionHandler': ('swiftpy.core.exceptions', 'ExceptionHandler'),
+    'ExistsRule': ('swiftpy.validation', 'ExistsRule'),
+    'Field': ('swiftpy.database.orm', 'Field'),
+    'FileMetadata': ('swiftpy.filesystem', 'FileMetadata'),
+    'FilesystemManager': ('swiftpy.filesystem', 'FilesystemManager'),
+    'FloatRule': ('swiftpy.validation', 'FloatRule'),
+    'ForbiddenError': ('swiftpy.core.exceptions', 'ForbiddenError'),
+    'FormRequest': ('swiftpy.validation', 'FormRequest'),
+    'HasMany': ('swiftpy.database.orm', 'HasMany'),
+    'HasOne': ('swiftpy.database.orm', 'HasOne'),
+    'HttpException': ('swiftpy.core.exceptions', 'HttpException'),
+    'InRule': ('swiftpy.validation', 'InRule'),
+    'IntRule': ('swiftpy.validation', 'IntRule'),
+    'InternalServerError': ('swiftpy.core.exceptions', 'InternalServerError'),
+    'JWTGuard': ('swiftpy.auth', 'JWTGuard'),
+    'JWTIssuer': ('swiftpy.auth', 'JWTIssuer'),
+    'Job': ('swiftpy.queue', 'Job'),
+    'JobSerializationError': ('swiftpy.queue', 'JobSerializationError'),
+    'LazyLoadingDisabledError': ('swiftpy.database.orm', 'LazyLoadingDisabledError'),
+    'LocalStorageDriver': ('swiftpy.filesystem', 'LocalStorageDriver'),
+    'Mail': ('swiftpy.mail', 'Mail'),
+    'MailFake': ('swiftpy.mail', 'MailFake'),
+    'MailManager': ('swiftpy.mail', 'MailManager'),
+    'MailMessage': ('swiftpy.mail', 'MailMessage'),
+    'MailSendResult': ('swiftpy.mail', 'MailSendResult'),
+    'MailTransport': ('swiftpy.mail', 'MailTransport'),
+    'Mailable': ('swiftpy.mail', 'Mailable'),
+    'MaxRule': ('swiftpy.validation', 'MaxRule'),
+    'MemoryDriver': ('swiftpy.cache', 'MemoryDriver'),
+    'MethodNotAllowedError': ('swiftpy.core.exceptions', 'MethodNotAllowedError'),
+    'Middleware': ('swiftpy.http.middleware', 'Middleware'),
+    'MinRule': ('swiftpy.validation', 'MinRule'),
+    'Model': ('swiftpy.database.orm', 'Model'),
+    'ModelAdmin': ('swiftpy.admin', 'ModelAdmin'),
+    'ModelNotFoundError': ('swiftpy.database', 'ModelNotFoundError'),
+    'NotFoundError': ('swiftpy.core.exceptions', 'NotFoundError'),
+    'NotInRule': ('swiftpy.validation', 'NotInRule'),
+    'NullableRule': ('swiftpy.validation', 'NullableRule'),
+    'Paginator': ('swiftpy.database.pagination', 'Paginator'),
+    'PathNormalizer': ('swiftpy.filesystem', 'PathNormalizer'),
+    'PayloadTooLargeError': ('swiftpy.core.exceptions', 'PayloadTooLargeError'),
+    'QueueDispatcher': ('swiftpy.queue', 'QueueDispatcher'),
+    'QueueWorker': ('swiftpy.queue', 'QueueWorker'),
+    'RecordNotFoundError': ('swiftpy.database', 'RecordNotFoundError'),
+    'RedisDriver': ('swiftpy.cache', 'RedisDriver'),
+    'RedisEventBus': ('swiftpy.events', 'RedisEventBus'),
+    'RegexRule': ('swiftpy.validation', 'RegexRule'),
+    'RelationNotLoadedError': ('swiftpy.database.orm', 'RelationNotLoadedError'),
+    'Request': ('swiftpy.http.request', 'Request'),
+    'RequestId': ('swiftpy.http.middleware', 'RequestId'),
+    'RequestIdMiddleware': ('swiftpy.http.middleware', 'RequestIdMiddleware'),
+    'RequiredRule': ('swiftpy.validation', 'RequiredRule'),
+    'Response': ('swiftpy.http.response', 'Response'),
+    'RouteGroup': ('swiftpy.http.router', 'RouteGroup'),
+    'Router': ('swiftpy.http.router', 'Router'),
+    'S3StorageDriver': ('swiftpy.filesystem', 'S3StorageDriver'),
+    'SecurityHeaders': ('swiftpy.http.middleware', 'SecurityHeaders'),
+    'SecurityHeadersMiddleware': ('swiftpy.http.middleware', 'SecurityHeadersMiddleware'),
+    'Seeder': ('swiftpy.database', 'Seeder'),
+    'ServiceProvider': ('swiftpy.core.providers.base', 'ServiceProvider'),
+    'SimplePaginator': ('swiftpy.database.pagination', 'SimplePaginator'),
+    'Storage': ('swiftpy.filesystem', 'Storage'),
+    'StorageDisk': ('swiftpy.filesystem', 'StorageDisk'),
+    'StorageDriver': ('swiftpy.filesystem', 'StorageDriver'),
+    'StrRule': ('swiftpy.validation', 'StrRule'),
+    'TestCase': ('swiftpy.testing', 'TestCase'),
+    'TestClient': ('swiftpy.testing', 'TestClient'),
+    'TestResponse': ('swiftpy.testing', 'TestResponse'),
+    'TokenBlacklist': ('swiftpy.auth', 'TokenBlacklist'),
+    'UnauthorizedError': ('swiftpy.core.exceptions', 'UnauthorizedError'),
+    'UniqueRule': ('swiftpy.validation', 'UniqueRule'),
+    'UploadedFile': ('swiftpy.filesystem', 'UploadedFile'),
+    'UrlRule': ('swiftpy.validation', 'UrlRule'),
+    'ValidationError': ('swiftpy.core.exceptions', 'ValidationError'),
+    'ValidationException': ('swiftpy.validation', 'ValidationException'),
+    'ValidationResult': ('swiftpy.validation', 'ValidationResult'),
+    'Validator': ('swiftpy.validation', 'Validator'),
+    'ValidatorRule': ('swiftpy.validation', 'ValidatorRule'),
+    'Vector': ('swiftpy.database.orm', 'Vector'),
+    'Visibility': ('swiftpy.filesystem', 'Visibility'),
+    'WebSocket': ('swiftpy.websockets', 'WebSocket'),
+    'WebSocketConnection': ('swiftpy.websockets', 'WebSocketConnection'),
+    'WebSocketDisconnect': ('swiftpy.websockets', 'WebSocketDisconnect'),
+    'WebSocketException': ('swiftpy.websockets', 'WebSocketException'),
+    'WebSocketManager': ('swiftpy.websockets', 'WebSocketManager'),
+    'WebSocketState': ('swiftpy.websockets', 'WebSocketState'),
+    'admin': ('swiftpy.admin', 'admin'),
+    'app': ('swiftpy.helpers.helper', 'app'),
+    'between': ('swiftpy.validation', 'between'),
+    'bool_': ('swiftpy.validation', 'bool_'),
+    'cache': ('swiftpy.helpers.helper', 'cache'),
+    'config': ('swiftpy.helpers.helper', 'config'),
+    'container': ('swiftpy.helpers.helper', 'container'),
+    'current_user': ('swiftpy.auth', 'current_user'),
+    'db_transaction': ('swiftpy.testing', 'db_transaction'),
+    'dispatch': ('swiftpy.helpers.helper', 'dispatch'),
+    'dispatcher': ('swiftpy.helpers.helper', 'dispatcher'),
+    'email': ('swiftpy.validation', 'email'),
+    'env': ('swiftpy.helpers.helper', 'env'),
+    'env_bool': ('swiftpy.helpers.helper', 'env_bool'),
+    'event': ('swiftpy.helpers.helper', 'event'),
+    'exists': ('swiftpy.validation', 'exists'),
+    'float_': ('swiftpy.validation', 'float_'),
+    'forbidden': ('swiftpy.http.response', 'forbidden'),
+    'hash_api_key': ('swiftpy.auth', 'hash_api_key'),
+    'in_': ('swiftpy.validation', 'in_'),
+    'int_': ('swiftpy.validation', 'int_'),
+    'json_response': ('swiftpy.http.response', 'json_response'),
+    'mail': ('swiftpy.helpers.helper', 'mail'),
+    'max_': ('swiftpy.validation', 'max_'),
+    'min_': ('swiftpy.validation', 'min_'),
+    'not_in': ('swiftpy.validation', 'not_in'),
+    'nullable': ('swiftpy.validation', 'nullable'),
+    'pluralize': ('swiftpy.helpers.helper', 'pluralize'),
+    'push': ('swiftpy.queue', 'push'),
+    'queue': ('swiftpy.helpers.helper', 'queue'),
+    'regex': ('swiftpy.validation', 'regex'),
+    'require_api_key': ('swiftpy.auth', 'require_api_key'),
+    'require_jwt': ('swiftpy.auth', 'require_jwt'),
+    'required': ('swiftpy.validation', 'required'),
+    'resolve': ('swiftpy.helpers.helper', 'resolve'),
+    'snake_case': ('swiftpy.helpers.helper', 'snake_case'),
+    'storage': ('swiftpy.helpers.helper', 'storage'),
+    'str_': ('swiftpy.validation', 'str_'),
+    'transactional_test': ('swiftpy.testing', 'transactional_test'),
+    'unauthorized': ('swiftpy.http.response', 'unauthorized'),
+    'unique': ('swiftpy.validation', 'unique'),
+    'url': ('swiftpy.validation', 'url'),
+    'validate': ('swiftpy.validation', 'validate'),
+    'verify_api_key_hash': ('swiftpy.auth', 'verify_api_key_hash'),
+    'websocket_manager': ('swiftpy.helpers.helper', 'websocket_manager'),
+    'ws_manager': ('swiftpy.helpers.helper', 'ws_manager'),
+}
+
+_SUBMODULE_EXPORTS: frozenset[str] = frozenset({
+    'admin',
+    'ai',
+    'auth',
+    'cache',
+    'cli',
+    'console',
+    'core',
+    'database',
+    'events',
+    'filesystem',
+    'helpers',
+    'http',
+    'mail',
+    'queue',
+    'support',
+    'testing',
+    'validation',
+    'websockets',
+})
+
+
+def __getattr__(name: str) -> Any:
+    """Lazily resolve top-level SwiftPY exports without eager subsystem imports."""
+    target = _EXPORT_MAP.get(name)
+    if target is not None:
+        module_name, attr_name = target
+        module = importlib.import_module(module_name)
+        value = getattr(module, attr_name)
+        globals()[name] = value
+        return value
+    if name in _SUBMODULE_EXPORTS:
+        module = importlib.import_module(f"swiftpy.{name}")
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))
+
+
+__all__ = [
+    'CORS',
+    'AdminSite',
+    'Agent',
+    'AgentMemory',
+    'AgentResponse',
+    'AgentTask',
+    'ApiKeyGuard',
+    'Application',
+    'Attachment',
+    'AuthManager',
+    'BadRequestError',
+    'BaseAgent',
+    'BelongsTo',
+    'BelongsToMany',
+    'BetweenRule',
+    'BoolRule',
+    'CORSMiddleware',
+    'Cache',
+    'CacheDriver',
+    'CacheManager',
+    'CircularDependencyError',
+    'ClientDisconnect',
+    'Config',
+    'Container',
+    'CurrentUser',
+    'DatabaseError',
+    'EmailRule',
+    'EventDispatcher',
+    'EventHandler',
+    'ExceptionHandler',
+    'ExistsRule',
+    'Field',
+    'FileMetadata',
+    'FilesystemManager',
+    'FloatRule',
+    'ForbiddenError',
+    'FormRequest',
+    'HasMany',
+    'HasOne',
+    'HttpException',
+    'InRule',
+    'IntRule',
+    'InternalServerError',
+    'JWTGuard',
+    'JWTIssuer',
+    'Job',
+    'JobSerializationError',
+    'LazyLoadingDisabledError',
+    'LocalStorageDriver',
+    'Mail',
+    'MailFake',
+    'MailManager',
+    'MailMessage',
+    'MailSendResult',
+    'MailTransport',
+    'Mailable',
+    'MaxRule',
+    'MemoryDriver',
+    'MethodNotAllowedError',
+    'Middleware',
+    'MinRule',
+    'Model',
+    'ModelAdmin',
+    'ModelNotFoundError',
+    'NotFoundError',
+    'NotInRule',
+    'NullableRule',
+    'Paginator',
+    'PathNormalizer',
+    'PayloadTooLargeError',
+    'QueueDispatcher',
+    'QueueWorker',
+    'RecordNotFoundError',
+    'RedisDriver',
+    'RedisEventBus',
+    'RegexRule',
+    'RelationNotLoadedError',
+    'Request',
+    'RequestId',
+    'RequestIdMiddleware',
+    'RequiredRule',
+    'Response',
+    'RouteGroup',
+    'Router',
+    'S3StorageDriver',
+    'SecurityHeaders',
+    'SecurityHeadersMiddleware',
+    'Seeder',
+    'ServiceProvider',
+    'SimplePaginator',
+    'Storage',
+    'StorageDisk',
+    'StorageDriver',
+    'StrRule',
+    'TestCase',
+    'TestClient',
+    'TestResponse',
+    'TokenBlacklist',
+    'UnauthorizedError',
+    'UniqueRule',
+    'UploadedFile',
+    'UrlRule',
+    'ValidationError',
+    'ValidationException',
+    'ValidationResult',
+    'Validator',
+    'ValidatorRule',
+    'Vector',
+    'Visibility',
+    'WebSocket',
+    'WebSocketConnection',
+    'WebSocketDisconnect',
+    'WebSocketException',
+    'WebSocketManager',
+    'WebSocketState',
+    'admin',
+    'app',
+    'between',
+    'bool_',
+    'cache',
+    'config',
+    'container',
+    'current_user',
+    'db_transaction',
+    'dispatch',
+    'dispatcher',
+    'email',
+    'env',
+    'env_bool',
+    'event',
+    'exists',
+    'float_',
+    'forbidden',
+    'hash_api_key',
+    'in_',
+    'int_',
+    'json_response',
+    'mail',
+    'max_',
+    'min_',
+    'not_in',
+    'nullable',
+    'pluralize',
+    'push',
+    'queue',
+    'regex',
+    'require_api_key',
+    'require_jwt',
+    'required',
+    'resolve',
+    'snake_case',
+    'storage',
+    'str_',
+    'transactional_test',
+    'unauthorized',
+    'unique',
+    'url',
+    'validate',
+    'verify_api_key_hash',
+    'websocket_manager',
+    'ws_manager',
+]

swiftpy/admin/__init__.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from swiftpy.admin.auth import (
+    ADMIN_COOKIE_NAME,
+    AdminAuthenticator,
+    AdminSessionStore,
+    AdminUnauthorizedError,
+    AdminUser,
+    clear_admin_session,
+    create_admin_session,
+    current_admin,
+    get_admin_authenticator,
+    get_admin_session_store,
+    get_current_admin,
+    require_admin,
+)
+from swiftpy.admin.registry import (
+    AdminSite,
+    FieldMetadata,
+    ModelAdmin,
+    RelationshipMetadata,
+    admin,
+)
+from swiftpy.admin.views import (
+    compile_admin_routes,
+    create_admin_router,
+)
+
+__all__ = [
+    "ADMIN_COOKIE_NAME",
+    "AdminAuthenticator",
+    "AdminSessionStore",
+    "AdminSite",
+    "AdminUnauthorizedError",
+    "AdminUser",
+    "FieldMetadata",
+    "ModelAdmin",
+    "RelationshipMetadata",
+    "admin",
+    "clear_admin_session",
+    "compile_admin_routes",
+    "create_admin_router",
+    "create_admin_session",
+    "current_admin",
+    "get_admin_authenticator",
+    "get_admin_session_store",
+    "get_current_admin",
+    "require_admin",
+]
+