gl-plugin 0.0.1b2__tar.gz

gl_plugin-0.0.1b2/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: gl-plugin
+Version: 0.0.1b2
+Summary: GL SDK's Plugin Architecture Implementation
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.2.1
+Provides-Extra: dev
+Requires-Dist: pre-commit<4.0.0,>=3.6.2; extra == "dev"
+Requires-Dist: pytest<9.0.0,>=8.3.4; extra == "dev"
+Requires-Dist: pytest-mock<4.0.0,>=3.14.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0.0,>=0.25.3; extra == "dev"
+Requires-Dist: coverage<8.0.0,>=7.6.10; extra == "dev"
+Requires-Dist: mypy<2.0.0,>=1.11.2; extra == "dev"
+Requires-Dist: ruff<1.0.0,>=0.9.9; extra == "dev"
+Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == "dev"

gl_plugin-0.0.1b2/gl_plugin/__init__.py

@@ -0,0 +1 @@
+"""GL SDK's Plugin Architecture Implementation."""

gl_plugin-0.0.1b2/gl_plugin/plugin/__init__.py

@@ -0,0 +1 @@
+"""Plugin Modules."""

gl_plugin-0.0.1b2/gl_plugin/plugin/handler.py

@@ -0,0 +1,55 @@
+"""PluginHandler interface for plugin system.
+
+Authors:
+    Samuel Lusandi (samuel.lusandi@gdplabs.id)
+
+References:
+    None
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Type
+
+
+class PluginHandler(ABC):
+    """Base interface for classes that can provide injections to the plugin system."""
+
+    @classmethod
+    @abstractmethod
+    def create_injections(cls, instance: Any) -> Dict[Type, Any]:
+        """Create injection mappings for this interface.
+
+        Args:
+            instance: The instance that will provide the injections
+
+        Returns:
+            Dictionary mapping service types to their instances
+        """
+
+    @classmethod
+    @abstractmethod
+    def initialize_plugin(cls, instance: Any, plugin: Any) -> None:
+        """Initialize plugin-specific resources for this interface.
+
+        This method is called after the plugin is created and services are injected.
+        Override this method to perform any plugin-specific initialization.
+
+        Args:
+            instance: The instance that provides the initialization
+            plugin: The plugin instance to initialize
+        """
+
+    @classmethod
+    async def ainitialize_plugin(cls, instance: Any, plugin: Any) -> None:  # pragma: no cover
+        """Initialize plugin-specific resources for this interface.
+
+        This method is called after the plugin is created and services are injected.
+        Override this method to perform any plugin-specific initialization. This method is
+        provided for compatibility with async plugins. By default it just calls the sync
+        version of the method.
+
+        Args:
+            instance: The instance that provides the initialization
+            plugin: The plugin instance to initialize
+        """
+        cls.initialize_plugin(instance, plugin)

gl_plugin-0.0.1b2/gl_plugin/plugin/manager.py

@@ -0,0 +1,395 @@
+"""Plugin manager.
+
+Authors:
+    Samuel Lusandi (samuel.lusandi@gdplabs.id)
+
+References:
+    None
+"""
+
+import asyncio
+import logging
+from pathlib import Path
+from threading import Lock
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar, Union, get_origin
+
+from dotenv import load_dotenv
+
+from gl_plugin.plugin.handler import PluginHandler
+from gl_plugin.plugin.plugin import Plugin
+from gl_plugin.plugin.registry import ServiceRegistry
+from gl_plugin.services.config import ConfigService
+
+T = TypeVar("T", bound=PluginHandler)
+
+
+class HandlerNotFoundError(RuntimeError):
+    """Raised when a requested plugin handler is not found."""
+
+
+class PluginManager:
+    """Manages plugin lifecycle and service injection.
+
+    This manager can handle different types of plugins based on the services provided.
+    Services are automatically registered based on the plugin handler interfaces provided.
+
+    This class follows the singleton pattern - only one instance will ever exist.
+    Thread-safe implementation using double-checked locking pattern.
+    """
+
+    _instance = None
+    _multi_instance = {}
+    _lock = Lock()
+    _initialized = False
+    _multi_initialized = {}  # Track initialization per key
+
+    def __new__(
+        cls,
+        *,
+        handlers: Optional[List[PluginHandler]] = None,
+        env_file: Optional[str] = None,
+        global_services: List[Any] = (),
+        key_instance: Optional[str] = None,
+    ) -> "PluginManager":
+        """Create or return the singleton instance or multi-instance.
+
+        Args:
+            handlers: List of plugin handlers that provide injections
+            env_file: Optional environment file for loading environment variables
+            global_services: List of services to register globally
+            key_instance: Optional key for multi-instance pattern. If None, uses singleton.
+
+        Returns:
+            The singleton PluginManager instance or specified multi-instance
+
+        Raises:
+            ValueError: If handlers is not provided during first initialization
+        """
+        with cls._lock:
+            if key_instance is not None:
+                # Multi-instance pattern
+                if key_instance not in cls._multi_instance:
+                    if handlers is None:
+                        raise ValueError(
+                            f"handlers must be provided when creating instance '{key_instance}' for the first time"
+                        )
+                    instance = super().__new__(cls)
+                    instance._key_instance = key_instance  # Store the key for this instance
+                    instance._initialized = False
+                    cls._multi_instance[key_instance] = instance
+                    cls._multi_initialized[key_instance] = False
+                return cls._multi_instance[key_instance]
+            else:
+                # Singleton pattern
+                if cls._instance is None:
+                    if handlers is None:
+                        raise ValueError("handlers must be provided when creating the first instance")
+                    instance = super().__new__(cls)
+                    instance._key_instance = None  # Mark as singleton
+                    instance._initialized = False
+                    cls._instance = instance
+                return cls._instance
+
+    def __init__(
+        self,
+        *,
+        handlers: Optional[List[PluginHandler]] = None,
+        env_file: Optional[str] = None,
+        global_services: List[Any] = (),
+        key_instance: Optional[str] = None,
+    ):
+        """Initialize plugin manager.
+
+        This will only run once per instance (singleton or multi-instance).
+
+        Args:
+            handlers: List of plugin handlers that provide injections
+            env_file: Optional environment file for loading environment variables
+            global_services: List of custom services to be injected into the global registry
+            key_instance: Optional key for multi-instance pattern
+        """
+        with self._lock:
+            # Check if this specific instance is already initialized
+            if key_instance is not None:
+                if self._multi_initialized.get(key_instance, False):
+                    return
+                self._multi_initialized[key_instance] = True
+            else:
+                if self._initialized:
+                    return
+                self._initialized = True
+
+            if not handlers:
+                raise ValueError("At least one plugin handler must be provided")
+
+            self._load_environment(env_file)
+
+            self._handler_registries: Dict[Type[PluginHandler], ServiceRegistry] = {}
+            self._plugins: Dict[str, Plugin] = {}
+            self._handlers: Dict[Type[PluginHandler], PluginHandler] = {}
+
+            for handler in handlers:
+                handler_type = type(handler)
+                registry = ServiceRegistry()
+                registry.register(ConfigService, ConfigService())
+
+                for service in global_services:
+                    registry.register(type(service), service)
+
+                for service_type, service_instance in handler_type.create_injections(handler).items():
+                    registry.register(service_type, service_instance)
+
+                self._handler_registries[handler_type] = registry
+                self._handlers[handler_type] = handler
+
+    def _load_environment(self, env_file: Optional[str] = None) -> None:
+        """Load environment variables from .env file.
+
+        If env_file is provided, loads from that file.
+        Otherwise, searches for .env in current directory and up to 3 levels up.
+
+        Args:
+            env_file: Optional path to environment file
+        """
+        if env_file:
+            load_dotenv(env_file)
+            return
+
+        current_dir = Path.cwd()
+        env_file_path = None
+
+        for _ in range(4):
+            if (current_dir / ".env").exists():
+                env_file_path = current_dir / ".env"
+                break
+            current_dir = current_dir.parent
+
+        if env_file_path:
+            load_dotenv(env_file_path)
+
+    def _prepare_plugin_registration(  # noqa: PLR0912
+        self, plugin_class: Type[Plugin], additional_params: Optional[Dict[str, Any]] = None
+    ) -> Tuple[Any, ServiceRegistry, Type, Plugin]:
+        """Prepare plugin registration by validating and setting up plugin instance.
+
+        Args:
+            plugin_class: Plugin class to register
+            additional_params: Optional dictionary of keyword arguments to pass to the plugin constructor
+
+        Returns:
+            Tuple containing:
+                - compatible_handler: The handler instance compatible with this plugin
+                - compatible_registry: The service registry to use for this plugin
+                - handler_type: The type of handler required by the plugin
+                - plugin: The instantiated plugin instance
+
+        Raises:
+            ValueError: If plugin doesn't specify a handler type
+            RuntimeError: If no compatible handler is found
+        """
+        if not plugin_class.get_handler_type():
+            raise ValueError(
+                f"Plugin {plugin_class.__name__} must specify a handler type using @Plugin.for_handler decorator"
+            )
+
+        # Find compatible handler (exact match or subclass)
+        handler_type = plugin_class.get_handler_type()
+        compatible_handler = None
+        compatible_registry = None
+
+        for registered_type, handler in self._handlers.items():
+            if issubclass(type(handler), handler_type):
+                compatible_handler = handler
+                compatible_registry = self._handler_registries[registered_type]
+                break
+
+        if not compatible_handler:
+            raise RuntimeError(
+                f"Plugin {plugin_class.__name__} requires handler {handler_type.__name__} or a subclass, "
+                "but none was provided"
+            )
+
+        logging.info(f"Initializing plugin {plugin_class.__name__}")
+
+        # Validate plugin requirements before instantiation
+        hints = plugin_class.__annotations__ if hasattr(plugin_class, "__annotations__") else {}
+
+        # Check for Union types and required services against handler-specific registry
+        unsupported_unions = []
+        missing_services = []
+
+        for field_name, service in hints.items():
+            if isinstance(service, type) and service.__module__ == "builtins":
+                continue
+
+            # Check for both Union[] syntax and | syntax (PEP 604)
+            is_union = (hasattr(service, "__origin__") and service.__origin__ is Union) or (
+                hasattr(service, "__or__")
+                and not isinstance(service, type)
+                and any(arg is type(None) for arg in service.__args__)
+            )
+
+            if is_union:
+                unsupported_unions.append(field_name)
+            else:
+                target_type = get_origin(service) or service
+
+                service_found = False
+                for registered_type in compatible_registry._services:
+                    registered_base = get_origin(registered_type) or registered_type
+                    try:
+                        if isinstance(registered_base, type) and issubclass(registered_base, target_type):
+                            service_found = True
+                            break
+                    except TypeError:
+                        continue
+
+                if not service_found:
+                    missing_services.append(getattr(service, "__name__", str(service)))
+
+        if unsupported_unions:
+            logging.warning(
+                f"Plugin {plugin_class.__name__} using handler {handler_type.__name__} has "
+                f"Union types which are not supported for injection: {', '.join(unsupported_unions)}",
+            )
+
+        if missing_services:
+            logging.warning(
+                f"Plugin {plugin_class.__name__} using handler {handler_type.__name__} "
+                f"could not inject the following services: {', '.join(missing_services)}",
+            )
+
+        # Set handler-specific registry and initialize plugin
+        plugin_class.set_registry(compatible_registry)
+        plugin = plugin_class(**additional_params) if additional_params else plugin_class()
+        self._plugins[plugin.name] = plugin
+
+        return compatible_handler, compatible_registry, handler_type, plugin
+
+    def register_plugin(  # noqa: PLR0912
+        self,
+        plugin_class: Type[Plugin],
+        custom_initializer: Optional[Callable[[Plugin], None]] = None,
+        additional_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Register and initialize a plugin.
+
+        Args:
+            plugin_class: Plugin class to register
+            custom_initializer: Optional callable that will be called with the plugin instance after initialization
+            additional_params: Optional dictionary of keyword arguments to pass to the plugin constructor
+
+        Raises:
+            ValueError: If plugin doesn't specify a handler type
+        """
+        compatible_handler, _, _, plugin = self._prepare_plugin_registration(plugin_class, additional_params)
+
+        # Initialize plugin with its specific handler
+        type(compatible_handler).initialize_plugin(compatible_handler, plugin)
+
+        # Call custom initializer if provided
+        if custom_initializer is not None:
+            custom_initializer(plugin)
+
+    async def aregister_plugin(
+        self,
+        plugin_class: Type[Plugin],
+        custom_initializer: Optional[Callable[[Plugin], Any]] = None,
+        additional_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Register and initialize a plugin asynchronously.
+
+        This is backwards compatible with the synchronous version;
+        passing a synchronous plugin will be handled appropriately.
+
+        Args:
+            plugin_class: Plugin class to register
+            custom_initializer: Optional callable that will be called with the plugin instance after initialization.
+                               Can be either a synchronous or asynchronous function.
+            additional_params: Optional dictionary of keyword arguments to pass to the plugin constructor
+
+        Raises:
+            ValueError: If plugin doesn't specify a handler type
+        """
+        compatible_handler, _, _, plugin = self._prepare_plugin_registration(plugin_class, additional_params)
+
+        if asyncio.iscoroutinefunction(type(compatible_handler).ainitialize_plugin):
+            await type(compatible_handler).ainitialize_plugin(compatible_handler, plugin)
+        else:
+            type(compatible_handler).initialize_plugin(compatible_handler, plugin)
+
+        # Call custom initializer if provided
+        if custom_initializer is not None:
+            if asyncio.iscoroutinefunction(custom_initializer):
+                await custom_initializer(plugin)
+            else:
+                custom_initializer(plugin)
+
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        """Get a plugin by name.
+
+        Args:
+            name: Name of plugin to get
+
+        Returns:
+            Plugin instance if found, None otherwise
+        """
+        return self._plugins.get(name)
+
+    def get_plugins(
+        self, handler_type: Optional[Type[PluginHandler]] = None, plugin_names: Optional[List[str]] = None
+    ) -> List[Plugin]:
+        """Get all registered plugins, optionally filtered by handler type and names.
+
+        Args:
+            handler_type: Optional handler type to filter plugins by. If provided,
+                        only returns plugins that have this handler type registered.
+            plugin_names: Optional list of plugin names to filter by. If provided,
+                        only returns plugins whose names are in this list.
+
+        Returns:
+            List of plugin instances
+        """
+        plugins = list(self._plugins.values())
+
+        if handler_type is not None:
+            plugins = [
+                plugin for plugin in plugins if plugin.handler_type and issubclass(plugin.handler_type, handler_type)
+            ]
+
+        if plugin_names is not None:
+            plugins = [plugin for plugin in plugins if plugin.name in plugin_names]
+
+        return plugins
+
+    def get_handlers(self, handler_type: Optional[Type[PluginHandler]] = None) -> List[PluginHandler]:
+        """Get all registered handlers, optionally filtered by type.
+
+        Args:
+            handler_type: Optional handler type to filter by. If provided,
+                        only returns handlers that are instances of this type.
+
+        Returns:
+            List of handler instances
+        """
+        if handler_type is None:
+            return list(self._handlers.values())
+
+        return [handler for handler in self._handlers.values() if isinstance(handler, handler_type)]
+
+    def get_handler(self, handler_type: Type[T]) -> T:
+        """Get a handler of the specified type.
+
+        Args:
+            handler_type: The type of handler to get
+
+        Returns:
+            The handler instance of the specified type
+
+        Raises:
+            HandlerNotFoundError: If no handler of the specified type is found
+        """
+        for handler in self._handlers.values():
+            if isinstance(handler, handler_type):
+                return handler  # type: ignore
+        raise HandlerNotFoundError(f"No handler of type {handler_type.__name__} found")

gl_plugin-0.0.1b2/gl_plugin/plugin/plugin.py

@@ -0,0 +1,99 @@
+"""Plugin base class for the Plugin Architecture.
+
+Authors:
+    Samuel Lusandi (samuel.lusandi@gdplabs.id)
+
+References:
+    None
+"""
+
+from typing import Callable, Optional, Type
+
+from gl_plugin.plugin.handler import PluginHandler
+from gl_plugin.plugin.registry import ServiceRegistry
+
+
+class Plugin:
+    """Base class for BOSA Plugins."""
+
+    name: str = None
+    description: str = None
+    version: str = None
+    _handler_type: Optional[Type["PluginHandler"]] = None
+
+    _registry: Optional[ServiceRegistry] = None
+
+    def __init__(self, *args, **kwargs):
+        """Initialize plugin instance.
+
+        Raises:
+            ValueError: If required class attributes are not set
+        """
+        super().__init__(*args, **kwargs)
+
+        if not all([self.name, self.description, self.version]):
+            raise ValueError(
+                f"Plugin class {self.__class__.__name__} must set name, description, and version as class attributes"
+            )
+
+    @classmethod
+    def get_handler_type(cls) -> Optional[Type["PluginHandler"]]:
+        """Get the handler type for this plugin class.
+
+        This method walks up the inheritance chain to find the handler_type.
+
+        Returns:
+            The handler type for this plugin, or None if not set
+        """
+        for base in cls.__mro__:
+            if "_handler_type" in base.__dict__:
+                return base._handler_type
+        return None
+
+    @classmethod
+    def for_handler(cls, handler_type: Type["PluginHandler"]) -> Callable[[Type["Plugin"]], Type["Plugin"]]:
+        """Decorator to specify which handler this plugin is designed for.
+
+        Args:
+            handler_type: The type of handler this plugin works with
+
+        Returns:
+            A decorator function that sets the handler type on the plugin class
+        """
+
+        def decorator(plugin_cls: Type["Plugin"]) -> Type["Plugin"]:
+            plugin_cls._handler_type = handler_type
+            return plugin_cls
+
+        return decorator
+
+    @classmethod
+    def set_registry(cls, registry: ServiceRegistry) -> None:
+        """Set the service registry for this plugin class.
+
+        Args:
+            registry: Service registry to use for dependency injection
+        """
+        cls._registry = registry
+
+    @property
+    def handler_type(self) -> Optional[Type["PluginHandler"]]:
+        """Get the handler type for this plugin instance.
+
+        Returns:
+            The handler type for this plugin, or None if not set
+        """
+        return self.__class__.get_handler_type()
+
+    def __new__(cls, *args, **kwargs):
+        """Create a new plugin instance with injected services.
+
+        This is called before __init__ and allows us to inject services
+        before the instance is initialized.
+        """
+        instance = super().__new__(cls)
+
+        if cls._registry is not None:
+            cls._registry.inject_services(instance)
+
+        return instance

gl_plugin-0.0.1b2/gl_plugin/plugin/registry.py

@@ -0,0 +1,92 @@
+"""Service registry for core services that can be injected into plugins.
+
+Authors:
+    Samuel Lusandi (samuel.lusandi@gdplabs.id)
+
+References:
+    None
+"""
+
+from typing import Any, Dict, Type, TypeVar, get_origin, get_type_hints
+
+T = TypeVar("T")
+
+
+class ServiceRegistry:
+    """Registry for core services that can be injected into plugins."""
+
+    def __init__(self):
+        """Initialize an empty service registry."""
+        self._services: Dict[Type, Any] = {}
+
+    def register(self, service_type: Type[T], instance: T) -> None:
+        """Register a service instance for a given type.
+
+        Args:
+            service_type: The type of the service (usually its class)
+            instance: The service instance
+        """
+        self._services[service_type] = instance
+
+    def get(self, service_type: Type[T]) -> T:
+        """Get a service instance by its type.
+
+        Args:
+            service_type: The type of service to retrieve
+
+        Returns:
+            The service instance
+
+        Raises:
+            TypeError: If the service type is a built-in type
+            KeyError: If the service type is not registered
+        """
+        if isinstance(service_type, type) and service_type.__module__ == "builtins":
+            raise TypeError(
+                f"Built-in type {service_type.__name__} cannot be injected. Pass this value directly instead."
+            )
+
+        if service_type not in self._services:
+            raise KeyError(f"Service {getattr(service_type, '__name__', str(service_type))} not registered")
+        return self._services[service_type]
+
+    def inject_services(self, target: Any) -> None:
+        """Inject registered services into an object based on its type hints.
+
+        This will look for class-level type hints and inject matching services.
+        If a service is registered that is a subclass of the requested type,
+        it will be injected. Handles both regular and generic types.
+
+        Args:
+            target: The object to inject services into
+        """
+        hints = get_type_hints(target.__class__)
+
+        for attr_name, attr_type in hints.items():
+            # First try exact type match
+            service = self._services.get(attr_type)
+
+            # If no exact match, look for a subclass that implements the interface
+            if service is None:
+                target_type = get_origin(attr_type) or attr_type
+
+                for registered_type, registered_service in self._services.items():
+                    registered_base = get_origin(registered_type) or registered_type
+                    try:
+                        if isinstance(registered_base, type) and issubclass(registered_base, target_type):
+                            service = registered_service
+                            break
+                    except TypeError:
+                        # Skip if type checking fails (e.g. with complex generic types)
+                        continue
+
+            if service is not None:
+                # This is created in order to accommodate services that are to be injected
+                # as a new object. Usually, services are to be injected as a singleton or
+                # as a class method. However, some services are to be injected as a new
+                # object so their behavior is not shared. An example is the Router;
+                # each Plugin *must* have its own Router otherwise, a shared route can
+                # cause a conflict with another plugin.
+                if callable(service) and not isinstance(service, type):
+                    service = service()
+                setattr(target, attr_name, service)

gl_plugin-0.0.1b2/gl_plugin/services/__init__.py

@@ -0,0 +1,5 @@
+"""Services module for BOSA Core."""
+
+from gl_plugin.services.config import ConfigService
+
+__all__ = ["ConfigService"]

gl_plugin-0.0.1b2/gl_plugin/services/config.py

@@ -0,0 +1,97 @@
+"""Configuration service for accessing environment variables."""
+
+import os
+from typing import Optional, Type, TypeVar, cast
+
+U = TypeVar("U")
+
+
+class ConfigService:
+    """Service for accessing environment variables with type conversion."""
+
+    @staticmethod
+    def get_string(key: str, default: Optional[str] = None) -> Optional[str]:
+        """Get environment variable as string."""
+        return os.environ.get(key, default)
+
+    @staticmethod
+    def get_int(key: str, default: Optional[int] = None) -> Optional[int]:
+        """Get environment variable as integer."""
+        value = os.environ.get(key)
+        if value is None:
+            return default
+        try:
+            return int(value)
+        except ValueError:
+            return default
+
+    @staticmethod
+    def get_float(key: str, default: Optional[float] = None) -> Optional[float]:
+        """Get environment variable as float."""
+        value = os.environ.get(key)
+        if value is None:
+            return default
+        try:
+            return float(value)
+        except ValueError:
+            return default
+
+    @staticmethod
+    def get_bool(key: str, default: Optional[bool] = None) -> Optional[bool]:
+        """Get environment variable as boolean.
+
+        'true', 'yes', '1', 'on' are considered True
+        'false', 'no', '0', 'off' are considered False
+        """
+        value = os.environ.get(key)
+        if value is None:
+            return default
+
+        value = value.lower()
+        if value in ("true", "yes", "1", "on"):
+            return True
+        if value in ("false", "no", "0", "off"):
+            return False
+        return default
+
+    @staticmethod
+    def get_list(key: str, separator: str = ",", default: Optional[list[str]] = None) -> Optional[list[str]]:
+        """Get environment variable as list of strings."""
+        value = os.environ.get(key)
+        if value is None:
+            return default
+        return [item.strip() for item in value.split(separator)]
+
+    @staticmethod
+    def require(key: str) -> str:
+        """Get required environment variable.
+
+        Raises:
+            ValueError: If environment variable is not set
+        """
+        value = os.environ.get(key)
+        if value is None:
+            raise ValueError(f"Required environment variable {key} is not set")
+        return value
+
+    @staticmethod
+    def require_as(key: str, type_: Type[U]) -> U:
+        """Get required environment variable with type conversion.
+
+        Args:
+            key: Environment variable key
+            type_: Type to convert to (int, float, bool)
+
+        Raises:
+            ValueError: If environment variable is not set or cannot be converted
+        """
+        value = ConfigService.require(key)
+        try:
+            if type_ == bool:  # noqa: E721 # pylint: disable=unidiomatic-typecheck
+                result = ConfigService.get_bool(key)
+                if result is None:
+                    raise ValueError
+                return cast(U, result)
+            return type_(value)  # type: ignore
+        except ValueError as exc:
+            raise ValueError(f"Environment variable {key} cannot be converted to {type_.__name__}") from exc

gl_plugin-0.0.1b2/gl_plugin.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: gl-plugin
+Version: 0.0.1b2
+Summary: GL SDK's Plugin Architecture Implementation
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.2.1
+Provides-Extra: dev
+Requires-Dist: pre-commit<4.0.0,>=3.6.2; extra == "dev"
+Requires-Dist: pytest<9.0.0,>=8.3.4; extra == "dev"
+Requires-Dist: pytest-mock<4.0.0,>=3.14.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0.0,>=0.25.3; extra == "dev"
+Requires-Dist: coverage<8.0.0,>=7.6.10; extra == "dev"
+Requires-Dist: mypy<2.0.0,>=1.11.2; extra == "dev"
+Requires-Dist: ruff<1.0.0,>=0.9.9; extra == "dev"
+Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == "dev"

gl_plugin-0.0.1b2/gl_plugin.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+setup.py
+gl_plugin/__init__.py
+gl_plugin.egg-info/PKG-INFO
+gl_plugin.egg-info/SOURCES.txt
+gl_plugin.egg-info/dependency_links.txt
+gl_plugin.egg-info/requires.txt
+gl_plugin.egg-info/top_level.txt
+gl_plugin/plugin/__init__.py
+gl_plugin/plugin/handler.py
+gl_plugin/plugin/manager.py
+gl_plugin/plugin/plugin.py
+gl_plugin/plugin/registry.py
+gl_plugin/services/__init__.py
+gl_plugin/services/config.py

gl_plugin-0.0.1b2/gl_plugin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gl_plugin-0.0.1b2/gl_plugin.egg-info/requires.txt

@@ -0,0 +1,11 @@
+python-dotenv>=1.2.1
+
+[dev]
+pre-commit<4.0.0,>=3.6.2
+pytest<9.0.0,>=8.3.4
+pytest-mock<4.0.0,>=3.14.0
+pytest-asyncio<1.0.0,>=0.25.3
+coverage<8.0.0,>=7.6.10
+mypy<2.0.0,>=1.11.2
+ruff<1.0.0,>=0.9.9
+pytest-cov<6.0.0,>=5.0.0

gl_plugin-0.0.1b2/gl_plugin.egg-info/top_level.txt

@@ -0,0 +1 @@
+gl_plugin

gl_plugin-0.0.1b2/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "gl-plugin"
+version = "0.0.1b2"
+description = "GL SDK's Plugin Architecture Implementation"
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+
+dependencies = [
+    "python-dotenv>=1.2.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pre-commit>=3.6.2,<4.0.0",
+    "pytest>=8.3.4,<9.0.0",
+    "pytest-mock>=3.14.0,<4.0.0",
+    "pytest-asyncio>=0.25.3,<1.0.0",
+    "coverage>=7.6.10,<8.0.0",
+    "mypy>=1.11.2,<2.0.0",
+    "ruff>=0.9.9,<1.0.0",
+    "pytest-cov>=5.0.0,<6.0.0",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = { find = { include = ["gl_plugin*"] } }

gl_plugin-0.0.1b2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gl_plugin-0.0.1b2/setup.py

@@ -0,0 +1,10 @@
+"""Setup script for GLLM Modules."""
+
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup(
+        build_with_nuitka=True,
+        name="-binary",
+        version="0.0.1b2",
+    )