Config class about latexify_py HOT 9 CLOSED

inner_config = copy(config if config is not None else Config.defaults())
for each kwarg:
    inner_config.update(kwarg)

inner_process(fn, inner_config)

from __future__ import annotations

from latexify.constants import CONFIGURATION
from typing import Callable

class Config:
    def __init__(self,
        identifiers: dict[str, str] | None = None,
        reduce_assignments: bool = False,
        use_math_symbols: bool = False,
        use_raw_function_name: bool = False,
        use_signature: bool = True,) -> None:

        self.flag: int = reduce_assignments * CONFIGURATION['reduce_assignments'] \
                    + use_math_symbols * CONFIGURATION["use_math_symbols"] \
                    + use_raw_function_name * CONFIGURATION["use_raw_function_name"] \
                    + use_signature * CONFIGURATION["use_signature"]
        self.identifiers: dict[str, str] = identifiers
        self.expanded_function: set[str] = set()

        for _config in CONFIGURATION:
            setattr(self, _config, self.__make_method_change_flag(_config))
            setattr(self, f"is_{_config}", self.__make_method_use_flag(_config))

    @staticmethod
    def defaults() -> Config:
        return Config()

    def expand_function(self, function: str | list[str]) -> None:
        if type(function) == str:
            self.expanded_function.add(function)
        elif type(function) == list:
            self.expand_function.update(function)

    def __make_method_change_flag(self, config_name: str) -> Callable:
        def _method(enabled: bool | None = True) -> None:
            if enabled:
                self.flag += CONFIGURATION[config_name]
            else:
                self.flag -= CONFIGURATION[config_name]
        return _method

    def __make_method_use_flag(self, config_name: str) -> Callable:
        @property
        def _method() -> bool:
            return (self.flag & CONFIGURATION[config_name]) != 0
        return _method

CONFIGURATION = {
    "reduce_assignments": 0,
    "use_math_symbols": 2,
    "use_raw_function_name": 4,
    "use_signature": 8
}

def get_latex(
    fn: Callable[..., Any],
    *,
    identifiers: dict[str, str] | None = None,
    reduce_assignments: bool = False,
    use_math_symbols: bool = False,
    use_raw_function_name: bool = False,
    use_signature: bool = True,
    configuration: Config | None = None,
) -> str:

@dataclasses.dataclass
class Config(frozen=True):
    some_flag: SomeType | None
    ...

    def merge(self, *, config: Config | None = None, **kwargs) -> Config:
        def merge_field(name: str) -> Any:
            # Precedence: kwargs -> config -> self
            arg = kwargs.get(name)
            if arg is None and config is not None:
                arg = getattr(config, name)
            if arg is None:
                arg = getattr(self, name)
            return arg

        return Config(
            **{f.name: merge_field(f.name) for f in dataclasses.fields(self)}
        )

_DEFAULT_CONFIG = Config(
    some_flag=some_value,
    ...
)

def get_latex(fn: Callable[..., Any], *, config: Config | None, **kwargs):
    merged_config = _DEFAULT_CONFIG.merge(config=config, **kwargs)