ergon-framework-python 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

ergon/__init__.py

@@ -10,4 +10,4 @@ __all__ = [
     "manager",
 ]
 
-__version__ = "0.1.8"
+__version__ = "0.2.0"

ergon/connector/__init__.py

@@ -1,63 +1,150 @@
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+from ._lazy import exported_names, load_export
 from .connector import AsyncConnector, Connector, ConnectorConfig
-from .ergon_platform import (
-    AsyncErgonPlatformConnector,
-    CreateItemInput,
-    ErgonPlatformClient,
-    ErgonPlatformConnector,
-    ErgonPlatformConsumerConfig,
-    ErgonPlatformProducerConfig,
-)
-from .excel import ExcelConnector, ExcelFetchConfig, ExcelRow, ExcelService
-from .nylas import (
-    AckActionConfig,
-    AsyncNylasAuthService,
-    AsyncNylasConnector,
-    AsyncNylasService,
-    AuthUrlConfig,
-    CodeExchangeInput,
-    GrantAuthResult,
-    MessageQueryFilter,
-    NylasAuthClient,
-    NylasAuthService,
-    NylasClient,
-    NylasConnector,
-    NylasConsumerConfig,
-    NylasProducerConfig,
-    NylasService,
-    SendMessageInput,
-)
-from .postgres import (
-    AsyncPostgresConnector,
-    AsyncPostgresService,
-    PostgresClient,
-    PostgresConsumerConfig,
-    PostgresProducerConfig,
-)
-from .rabbitmq import (
-    AsyncRabbitmqClient,
-    AsyncRabbitMQConnector,
-    AsyncRabbitmqConsumerConfig,
-    AsyncRabbitmqExchangeBinding,
-    AsyncRabbitmqProducerConfig,
-    AsyncRabbitmqQueueSubscription,
-    AsyncRabbitMQService,
-    RabbitmqClient,
-    RabbitMQConnector,
-    RabbitmqConsumerMessage,
-    RabbitmqProducerMessage,
-    RabbitMQService,
-)
-from .sqs import (
-    AsyncSQSConnector,
-    AsyncSQSService,
-    SQSClient,
-    SQSConnector,
-    SQSConsumerConfig,
-    SQSProducerConfig,
-    SQSService,
-)
 from .transaction import Transaction
 
+if TYPE_CHECKING:
+    from .ergon_platform import (
+        AsyncErgonPlatformConnector,
+        CreateItemInput,
+        ErgonPlatformClient,
+        ErgonPlatformConnector,
+        ErgonPlatformConsumerConfig,
+        ErgonPlatformProducerConfig,
+    )
+    from .excel import ExcelConnector, ExcelFetchConfig, ExcelRow, ExcelService
+    from .nylas import (
+        AckActionConfig,
+        AsyncNylasAuthService,
+        AsyncNylasConnector,
+        AsyncNylasService,
+        AuthUrlConfig,
+        CodeExchangeInput,
+        GrantAuthResult,
+        MessageQueryFilter,
+        NylasAuthClient,
+        NylasAuthService,
+        NylasClient,
+        NylasConnector,
+        NylasConsumerConfig,
+        NylasProducerConfig,
+        NylasService,
+        SendMessageInput,
+    )
+    from .postgres import (
+        AsyncPostgresConnector,
+        AsyncPostgresService,
+        PostgresClient,
+        PostgresConsumerConfig,
+        PostgresProducerConfig,
+    )
+    from .rabbitmq import (
+        AsyncRabbitmqClient,
+        AsyncRabbitMQConnector,
+        AsyncRabbitmqConsumerConfig,
+        AsyncRabbitmqExchangeBinding,
+        AsyncRabbitmqProducerConfig,
+        AsyncRabbitmqQueueSubscription,
+        AsyncRabbitMQService,
+        RabbitmqClient,
+        RabbitMQConnector,
+        RabbitmqConsumerMessage,
+        RabbitmqProducerMessage,
+        RabbitMQService,
+    )
+    from .sqs import (
+        AsyncSQSConnector,
+        AsyncSQSService,
+        SQSClient,
+        SQSConnector,
+        SQSConsumerConfig,
+        SQSProducerConfig,
+        SQSService,
+    )
+
+_CONNECTOR_SUBPACKAGES = (
+    "ergon_platform",
+    "excel",
+    "nylas",
+    "pipefy",
+    "postgres",
+    "rabbitmq",
+    "sqs",
+)
+
+_LAZY_EXPORTS = {
+    "AckActionConfig": "nylas",
+    "AsyncErgonPlatformConnector": "ergon_platform",
+    "AsyncNylasAuthService": "nylas",
+    "AsyncNylasConnector": "nylas",
+    "AsyncNylasService": "nylas",
+    "AsyncPostgresConnector": "postgres",
+    "AsyncPostgresService": "postgres",
+    "AsyncRabbitMQConnector": "rabbitmq",
+    "AsyncRabbitMQService": "rabbitmq",
+    "AsyncRabbitmqClient": "rabbitmq",
+    "AsyncRabbitmqConsumerConfig": "rabbitmq",
+    "AsyncRabbitmqExchangeBinding": "rabbitmq",
+    "AsyncRabbitmqProducerConfig": "rabbitmq",
+    "AsyncRabbitmqQueueSubscription": "rabbitmq",
+    "AsyncSQSConnector": "sqs",
+    "AsyncSQSService": "sqs",
+    "AuthUrlConfig": "nylas",
+    "CodeExchangeInput": "nylas",
+    "CreateItemInput": "ergon_platform",
+    "ErgonPlatformClient": "ergon_platform",
+    "ErgonPlatformConnector": "ergon_platform",
+    "ErgonPlatformConsumerConfig": "ergon_platform",
+    "ErgonPlatformProducerConfig": "ergon_platform",
+    "ExcelConnector": "excel",
+    "ExcelFetchConfig": "excel",
+    "ExcelRow": "excel",
+    "ExcelService": "excel",
+    "GrantAuthResult": "nylas",
+    "MessageQueryFilter": "nylas",
+    "NylasAuthClient": "nylas",
+    "NylasAuthService": "nylas",
+    "NylasClient": "nylas",
+    "NylasConnector": "nylas",
+    "NylasConsumerConfig": "nylas",
+    "NylasProducerConfig": "nylas",
+    "NylasService": "nylas",
+    "PostgresClient": "postgres",
+    "PostgresConsumerConfig": "postgres",
+    "PostgresProducerConfig": "postgres",
+    "RabbitMQConnector": "rabbitmq",
+    "RabbitMQService": "rabbitmq",
+    "RabbitmqClient": "rabbitmq",
+    "RabbitmqConsumerMessage": "rabbitmq",
+    "RabbitmqProducerMessage": "rabbitmq",
+    "SQSClient": "sqs",
+    "SQSConnector": "sqs",
+    "SQSConsumerConfig": "sqs",
+    "SQSProducerConfig": "sqs",
+    "SQSService": "sqs",
+    "SendMessageInput": "nylas",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _CONNECTOR_SUBPACKAGES:
+        module = import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    return load_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+    )
+
+
+def __dir__() -> list[str]:
+    return sorted(set(exported_names(globals(), _LAZY_EXPORTS)) | set(_CONNECTOR_SUBPACKAGES))
+
+
 __all__ = [
     "AckActionConfig",
     "AsyncConnector",

ergon/connector/_lazy.py

@@ -0,0 +1,51 @@
+"""Helpers for loading connector implementations only when requested."""
+
+from importlib import import_module
+from typing import Any, Mapping, MutableMapping, Sequence
+
+
+def load_export(
+    *,
+    name: str,
+    package: str,
+    exports: Mapping[str, str],
+    namespace: MutableMapping[str, Any],
+) -> Any:
+    """Load and cache one lazily exported attribute."""
+    module_name = exports.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {package!r} has no attribute {name!r}")
+
+    module = import_module(f".{module_name}", package)
+    value = getattr(module, name)
+    namespace[name] = value
+    return value
+
+
+def load_optional_export(
+    *,
+    name: str,
+    package: str,
+    exports: Mapping[str, str],
+    namespace: MutableMapping[str, Any],
+    extra: str,
+    dependencies: Sequence[str],
+) -> Any:
+    """Load a connector export and explain how to install a missing extra."""
+    try:
+        return load_export(name=name, package=package, exports=exports, namespace=namespace)
+    except ModuleNotFoundError as exc:
+        missing_module = exc.name or ""
+        if not any(
+            missing_module == dependency or missing_module.startswith(f"{dependency}.") for dependency in dependencies
+        ):
+            raise
+        raise ImportError(
+            f"The {extra!r} connector dependencies are not installed. "
+            f"Install them with: pip install 'ergon-framework-python[{extra}]'"
+        ) from exc
+
+
+def exported_names(namespace: Mapping[str, Any], exports: Mapping[str, str]) -> list[str]:
+    """Return module names including lazy exports for interactive discovery."""
+    return sorted(set(namespace) | set(exports))

ergon/connector/ergon_platform/__init__.py

@@ -1,5 +1,6 @@
-from .async_connector import AsyncErgonPlatformConnector
-from .connector import ErgonPlatformConnector
+from typing import TYPE_CHECKING, Any
+
+from .._lazy import exported_names, load_optional_export
 from .models import (
     CreateItemInput,
     ErgonPlatformClient,
@@ -7,6 +8,31 @@ from .models import (
     ErgonPlatformProducerConfig,
 )
 
+if TYPE_CHECKING:
+    from .async_connector import AsyncErgonPlatformConnector
+    from .connector import ErgonPlatformConnector
+
+_LAZY_EXPORTS = {
+    "AsyncErgonPlatformConnector": "async_connector",
+    "ErgonPlatformConnector": "connector",
+}
+
+
+def __getattr__(name: str) -> Any:
+    return load_optional_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+        extra="ergon-platform",
+        dependencies=("ergon_platform", "httpx"),
+    )
+
+
+def __dir__() -> list[str]:
+    return exported_names(globals(), _LAZY_EXPORTS)
+
+
 __all__ = [
     "AsyncErgonPlatformConnector",
     "CreateItemInput",

ergon/connector/ergon_platform/_client.py

@@ -1,6 +1,9 @@
 from .models import ErgonPlatformClient
 
-_ERGON_PLATFORM_IMPORT_ERROR = "Install the ergon-platform-sdk package in the same environment"
+_ERGON_PLATFORM_IMPORT_ERROR = (
+    "The 'ergon-platform' connector dependencies are not installed. "
+    "Install them with: pip install 'ergon-framework-python[ergon-platform]'"
+)
 
 
 def _get_ergon_client():

ergon/connector/excel/__init__.py

@@ -6,9 +6,35 @@ Provides transaction-based access to Excel files with support for:
 - Sharding for parallel processing
 """
 
-from .connector import ExcelConnector
+from typing import TYPE_CHECKING, Any
+
+from .._lazy import exported_names, load_optional_export
 from .models import ExcelFetchConfig, ExcelRow
-from .service import ExcelService
+
+if TYPE_CHECKING:
+    from .connector import ExcelConnector
+    from .service import ExcelService
+
+_LAZY_EXPORTS = {
+    "ExcelConnector": "connector",
+    "ExcelService": "service",
+}
+
+
+def __getattr__(name: str) -> Any:
+    return load_optional_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+        extra="excel",
+        dependencies=("openpyxl",),
+    )
+
+
+def __dir__() -> list[str]:
+    return exported_names(globals(), _LAZY_EXPORTS)
+
 
 __all__ = [
     "ExcelConnector",

ergon/connector/nylas/__init__.py

@@ -1,8 +1,6 @@
-from .async_auth_service import AsyncNylasAuthService
-from .async_connector import AsyncNylasConnector
-from .async_service import AsyncNylasService
-from .auth_service import NylasAuthService
-from .connector import NylasConnector
+from typing import TYPE_CHECKING, Any
+
+from .._lazy import exported_names, load_optional_export
 from .models import (
     AckActionConfig,
     AttachmentInput,
@@ -19,7 +17,39 @@ from .models import (
     NylasProducerConfig,
     SendMessageInput,
 )
-from .service import NylasService
+
+if TYPE_CHECKING:
+    from .async_auth_service import AsyncNylasAuthService
+    from .async_connector import AsyncNylasConnector
+    from .async_service import AsyncNylasService
+    from .auth_service import NylasAuthService
+    from .connector import NylasConnector
+    from .service import NylasService
+
+_LAZY_EXPORTS = {
+    "AsyncNylasAuthService": "async_auth_service",
+    "AsyncNylasConnector": "async_connector",
+    "AsyncNylasService": "async_service",
+    "NylasAuthService": "auth_service",
+    "NylasConnector": "connector",
+    "NylasService": "service",
+}
+
+
+def __getattr__(name: str) -> Any:
+    return load_optional_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+        extra="nylas",
+        dependencies=("nylas",),
+    )
+
+
+def __dir__() -> list[str]:
+    return exported_names(globals(), _LAZY_EXPORTS)
+
 
 __all__ = [
     "AckActionConfig",

ergon/connector/pipefy/__init__.py

@@ -1,13 +1,41 @@
-from .async_connector import AsyncPipefyConnector
-from .async_service import AsyncPipefyService
-from .connector import PipefyConnector
+from typing import TYPE_CHECKING, Any
+
+from .._lazy import exported_names, load_optional_export
 from .models import (
     CreateCardInput,
     FieldFilter,
     FieldFilterOperator,
     PipefyClient,
 )
-from .service import PipefyService
+
+if TYPE_CHECKING:
+    from .async_connector import AsyncPipefyConnector
+    from .async_service import AsyncPipefyService
+    from .connector import PipefyConnector
+    from .service import PipefyService
+
+_LAZY_EXPORTS = {
+    "AsyncPipefyConnector": "async_connector",
+    "AsyncPipefyService": "async_service",
+    "PipefyConnector": "connector",
+    "PipefyService": "service",
+}
+
+
+def __getattr__(name: str) -> Any:
+    return load_optional_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+        extra="pipefy",
+        dependencies=("httpx", "requests"),
+    )
+
+
+def __dir__() -> list[str]:
+    return exported_names(globals(), _LAZY_EXPORTS)
+
 
 __all__ = [
     "AsyncPipefyConnector",

ergon/connector/postgres/__init__.py

@@ -1,7 +1,33 @@
-from .async_connector import AsyncPostgresConnector
-from .async_service import AsyncPostgresService
+from typing import TYPE_CHECKING, Any
+
+from .._lazy import exported_names, load_optional_export
 from .models import PostgresClient, PostgresConsumerConfig, PostgresProducerConfig
 
+if TYPE_CHECKING:
+    from .async_connector import AsyncPostgresConnector
+    from .async_service import AsyncPostgresService
+
+_LAZY_EXPORTS = {
+    "AsyncPostgresConnector": "async_connector",
+    "AsyncPostgresService": "async_service",
+}
+
+
+def __getattr__(name: str) -> Any:
+    return load_optional_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+        extra="postgres",
+        dependencies=("asyncpg",),
+    )
+
+
+def __dir__() -> list[str]:
+    return exported_names(globals(), _LAZY_EXPORTS)
+
+
 __all__ = [
     "AsyncPostgresConnector",
     "AsyncPostgresService",

ergon/connector/rabbitmq/__init__.py

@@ -1,6 +1,6 @@
-from .async_connector import AsyncRabbitMQConnector
-from .async_service import AsyncRabbitMQService
-from .connector import RabbitMQConnector
+from typing import TYPE_CHECKING, Any
+
+from .._lazy import exported_names, load_optional_export
 from .models import (
     AsyncRabbitmqClient,
     AsyncRabbitmqConsumerConfig,
@@ -11,7 +11,35 @@ from .models import (
     RabbitmqConsumerMessage,
     RabbitmqProducerMessage,
 )
-from .service import RabbitMQService
+
+if TYPE_CHECKING:
+    from .async_connector import AsyncRabbitMQConnector
+    from .async_service import AsyncRabbitMQService
+    from .connector import RabbitMQConnector
+    from .service import RabbitMQService
+
+_LAZY_EXPORTS = {
+    "AsyncRabbitMQConnector": "async_connector",
+    "AsyncRabbitMQService": "async_service",
+    "RabbitMQConnector": "connector",
+    "RabbitMQService": "service",
+}
+
+
+def __getattr__(name: str) -> Any:
+    return load_optional_export(
+        name=name,
+        package=__name__,
+        exports=_LAZY_EXPORTS,
+        namespace=globals(),
+        extra="rabbitmq",
+        dependencies=("aio_pika", "aiormq", "pika"),
+    )
+
+
+def __dir__() -> list[str]:
+    return exported_names(globals(), _LAZY_EXPORTS)
+
 
 __all__ = [
     "AsyncRabbitMQConnector",