config¶

class GlobalSetting(BaseModel):
    """
    Global configuration settings for the Bridgic framework.

    This class implements a singleton pattern to provide centralized configuration
    that applies across all Automa instances. The main methods are:

    - `GlobalSetting.read()`: Get the singleton global setting instance.
    - `GlobalSetting.set()`: Set the specific fields of the global setting instance.

    Attributes
    ----------
    callback_builders : List[WorkerCallbackBuilder]
        Callback builders that will be automatically applied to all workers
        across all Automa instances.
    """
    model_config = {"arbitrary_types_allowed": True}

    callback_builders: List["WorkerCallbackBuilder"] = []
    """Global callback builders that will be applied to all workers."""

    # Singleton instance
    _instance: ClassVar[Optional["GlobalSetting"]] = None
    _lock: ClassVar[Lock] = Lock()

    @classmethod
    def read(cls) -> "GlobalSetting":
        """
        Get the singleton global setting instance.

        Returns
        -------
        GlobalSetting
            The singleton global setting instance.
        """
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = cls()
        return cls._instance

    @classmethod
    def set(
        cls,
        callback_builders: Optional[List["WorkerCallbackBuilder"]] = None,
    ) -> None:
        """
        Set global setting fields.

        This method allows you to update specific fields of the global setting
        without needing to create a complete GlobalSetting object.

        Parameters
        ----------
        callback_builders : Optional[List[WorkerCallbackBuilder]], optional
            Global callback builders that will be applied to all workers.
            If None, the current callback_builders are not changed.
        """
        instance = cls.read()
        with cls._lock:
            if callback_builders is not None:
                instance.callback_builders = callback_builders

    @classmethod
    def add(cls, callback_builder: Optional["WorkerCallbackBuilder"] = None) -> None:
        """
        Add new element to the existing field(s) of the `GlobalSetting`.

        Parameters
        ----------
        callback_builder : Optional[WorkerCallbackBuilder]
            The callback builder to add to the global setting callback builders. If None is passed in, nothing will be done.
        """
        instance = cls.read()
        with cls._lock:
            if callback_builder is not None:
                instance.callback_builders.append(callback_builder)

class HttpClientConfig(TypedDict, total=False):
    """
    Serializable configuration for creating an HTTP client.

    This configuration can be serialized and deserialized, allowing the framework
    to recreate HTTP clients after serialization.

    Attributes
    ----------
    headers : Optional[Dict[str, str]]
        HTTP headers to include with all requests.
    timeout : Optional[HttpClientTimeoutConfig]
        Timeout configuration for the HTTP client.
    auth : Optional[HttpClientAuthConfig]
        Authentication configuration for the HTTP client.
    """
    headers: Optional[Dict[str, str]]
    timeout: Optional[HttpClientTimeoutConfig]
    auth: Optional[HttpClientAuthConfig]

class HttpClientTimeoutConfig(TypedDict, total=False):
    """
    Configuration for HTTP client timeout settings.

    Attributes
    ----------
    connect : Optional[float]
        Timeout for establishing a connection (seconds).
    read : Optional[float]
        Timeout for reading data (seconds).
    write : Optional[float]
        Timeout for writing data (seconds).
    pool : Optional[float]
        Timeout for acquiring a connection from the pool (seconds).
    """
    connect: Optional[float]
    read: Optional[float]
    write: Optional[float]
    pool: Optional[float]

class HttpClientAuthConfig(TypedDict, total=False):
    """
    Configuration for HTTP client authentication.

    Attributes
    ----------
    type : Literal["basic", "bearer"]
        The type of authentication.
    username : Optional[str]
        Username for basic auth (required if type is "basic").
    password : Optional[str]
        Password for basic auth (required if type is "basic").
    token : Optional[str]
        Bearer token (required if type is "bearer").
    """
    type: Literal["basic", "bearer"]
    username: Optional[str]
    password: Optional[str]
    token: Optional[str]