workercommon 0.5.2__tar.gz → 0.5.3__tar.gz

{workercommon-0.5.2 → workercommon-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workercommon
-Version: 0.5.2
+Version: 0.5.3
 Summary: Support code for various projects
 Author-email: "Neil E. Hodges" <47hasbegun@gmail.com>
 License-Expression: BSD-3-Clause

{workercommon-0.5.2 → workercommon-0.5.3}/pyproject.toml

@@ -18,7 +18,7 @@ dependencies = [
   "psycopg2",
   "pyyaml",
 ]
-version = "0.5.2"
+version = "0.5.3"
 license-files = ["LICENSE.TXT"]
 classifiers = [
   "Programming Language :: Python :: 3",
@@ -35,6 +35,7 @@ Issues = "https://gitgud.io/takeshitakenji/workercommon/issues"
 zip-safe = false
 packages = [
   "workercommon",
+  "workercommon.config",
   "workercommon.database",
 ]
 include-package-data = true

workercommon-0.5.3/workercommon/config/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+import sys
+
+if sys.version_info < (3, 8):
+    raise RuntimeError("At least Python 3.8 is required")
+
+from ._configparser import Configuration  # noqa
+try:
+    from ._yaml import (  # noqa
+        ConfigBase,
+        LogLevel,
+        Logging,
+        isoformat,
+        to_json,
+        to_yaml,
+    )
+except ImportError:
+    pass

workercommon-0.5.3/workercommon/config/_configparser.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+import sys
+
+if sys.version_info < (3, 8):
+    raise RuntimeError("At least Python 3.8 is required")
+
+from configparser import ConfigParser
+import logging
+from logging.handlers import WatchedFileHandler
+from typing import Tuple, Optional, Callable
+from pathlib import Path
+
+
+class Configuration(object):
+    def __init__(self, filename: str):
+        self.parser = self.create_parser()
+        self.set_base_config(self.parser)
+        self.parser.read(filename)
+        self.check_all_values(self.parser)
+
+    def create_parser(self) -> ConfigParser:
+        return ConfigParser()
+
+    def set_base_config(self, parser: ConfigParser) -> None:
+        pass
+
+    def check_all_values(self, parser: ConfigParser) -> None:
+        pass
+
+    @staticmethod
+    def dir_exists(s: str) -> bool:
+        return bool(s and Path(s).is_dir())
+
+    def check_value(
+        self, section: str, key: str, validator: Callable[[str], bool]
+    ) -> None:
+        value: Optional[str] = self[section, key]
+        try:
+            if value is None or not validator(value):
+                raise ValueError
+        except Exception as e:
+            raise ValueError(f"Invalid {section}/{key} value: {value}") from e
+
+    def __getitem__(self, parts: Tuple[str, str]) -> Optional[str]:
+        section, key = parts
+
+        try:
+            value = self.parser[section][key]
+            return value if value else None
+        except KeyError:
+            return None
+
+    def get_strict(self, section: str, key: str) -> str:
+        value = self[section, key]
+        if value is None:
+            raise ValueError(f"Missing {section}/{key} value")
+
+        return value
+
+    def get(self, section: str, key: str, default: str) -> str:
+        value = self[section, key]
+        return value if value is not None else default
+
+    def configure_logging(self, *handlers) -> None:
+        level = self["Logging", "level"]
+        if not level:
+            raise RuntimeError("Logging level should have already been validated")
+
+        log_format = self["Logging", "format"]
+        if not log_format:
+            log_format = "[%(asctime)s] [%(levelname)s] [%(module)s] [%(filename)s:%(lineno)d %(funcName)s] %(message)s"  # noqa
+
+        if handlers:
+            logging.basicConfig(level=level, format=log_format, handlers=handlers)
+        else:
+            fname = self["Logging", "file"]
+            if fname:
+                handler = WatchedFileHandler(fname)
+                logging.basicConfig(level=level, format=log_format, handlers=[handler])
+            else:
+                logging.basicConfig(level=level, format=log_format, stream=sys.stderr)

workercommon-0.5.3/workercommon/config/_yaml.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python
+import sys
+if sys.version_info < (3, 13):
+    raise RuntimeError("At least Python 3.13 is required")
+
+
+import immutables
+import json
+import logging
+import re
+
+from abc import ABC
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from enum import Enum
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Generic, Optional, TypeVar, cast
+from yaml import Dumper, SafeDumper, add_multi_representer, add_representer, safe_dump, safe_load
+
+
+UTC_PATTERN = re.compile(r"\+00:00$")
+YAML_MAPPING = "tag:yaml.org,2002:map"
+T = TypeVar("T")
+
+
+@lru_cache(maxsize=100)
+def isoformat(dt: datetime) -> str:
+    return UTC_PATTERN.sub("Z", dt.isoformat())
+
+
+def to_json(obj: Any) -> Any:
+    """
+    Convert the provided object to an object type suitable for JSON.  Adds support for
+    immutables.Map, ConfigBase dataclasses, datetimes, and other iterables.
+
+    Used as the default parameter to json.dump() and json.dumps().
+    """
+    if isinstance(obj, immutables.Map):
+        return dict(obj)
+
+    if hasattr(obj, "to_json"):
+        return obj.to_json()
+
+    if isinstance(obj, datetime):
+        return isoformat(obj)
+
+    if hasattr(obj, "__iter__"):
+        return list(obj)
+
+    raise TypeError(f"Unsupported type: {obj}")
+
+
+def to_yaml(dumper: Dumper | SafeDumper, obj: Any) -> Any:
+    """
+    Convert the provided object to a representation suitable for YAML via a yaml.Dumper or
+    yaml.SafeDumper.  Adds support for immutables.Map, dict, ConfigBase, Enum, datetime,
+    and other iterables.
+    """
+    if isinstance(obj, (immutables.Map, dict)):
+        return dumper.represent_mapping(YAML_MAPPING, obj)
+
+    if isinstance(obj, ConfigBase):
+        return dumper.represent_mapping(YAML_MAPPING, obj.to_json())
+
+    if isinstance(obj, Enum):
+        return dumper.represent_str(obj.name)
+
+    if isinstance(obj, datetime):
+        return dumper.represent_str(isoformat(obj))
+
+    if hasattr(obj, "__iter__"):
+        return dumper.represent_list(list(obj))
+
+    raise TypeError(f"Unsupported type: {obj}")
+
+
+class DumpFormat(str, Enum):
+    "Supported dump formats for ConfigBase."
+    json = "json"
+    yaml = "yaml"
+
+
+@dataclass(frozen=True)
+class ConfigBase(ABC, Generic[T]):
+    "Base dataclass for the various configuration dataclasses."
+    @classmethod
+    def of(cls, src: Mapping[str, Any]) -> "T":
+        """
+        Convert the provided mapping into a ConfigBase-derived dataclass by passing the mapping's
+        items in as kwargs to said dataclass.
+        """
+        return cast(T, cls(**src))
+
+    @classmethod
+    def from_file(cls, path: Path) -> "T":
+        "Convert the provided YAML file to a ConfigBase-derived dataclass via of()."
+        with path.open("rt") as inf:
+            document = safe_load(inf)
+
+        return cls.of(
+            document if document else {}
+        )
+
+    @classmethod
+    def of_many(cls, src: Mapping[str, Mapping[str, Any]]) -> Mapping[str, "T"]:
+        """
+        Convert the provided mapping of key=>mapping to an immutables mapping of
+        key=>dataclass via of().
+        """
+        return immutables.Map((
+            (name, cls.of(value))
+            for name, value in src.items()
+        ))
+
+    def to_json(self) -> Mapping[str, Any]:
+        """
+        Convert this dataclass instance to a mapping suitable for JSON serialization via
+        dataclasses.asdict().
+        """
+        return asdict(self)
+
+    def dumps(self, *args: Any, format: DumpFormat = DumpFormat.json, **kwargs: Any) -> str:
+        "Convert this dataclass instance to either a JSON string or a YAML string."
+        match format:
+            case DumpFormat.json:
+                kwargs.setdefault("default", to_json)
+                return json.dumps(self, *args, **kwargs)
+
+            case DumpFormat.yaml:
+                return safe_dump(self, *args, **kwargs)
+
+
+class LogLevel(int, Enum):
+    "Supported log levels."
+    debug = logging.DEBUG
+    info = logging.INFO
+    warning = logging.WARNING
+    error = logging.ERROR
+
+    @classmethod
+    def of(cls, value: str | int) -> "LogLevel":
+        """
+        Create a LogLevel object from either a string or an integer.
+
+        * In the string case, the valid values are "debug", "info", "warning", and "error".
+        * In the integer case, the value corresponds to the logging level constants.
+        """
+        for _key, _value in cls.__members__.items():
+            match (_key, _value, value):
+                case (_, int(x), int(y)) if x == y:
+                    return x
+                case (str(x), y, str(z)) if x == z.lower():
+                    return y
+                case _:
+                    continue
+
+        raise ValueError(f"Unknown log level: {repr(value)}")
+
+
+@dataclass(frozen=True)
+class Logging(ConfigBase["Logging"]):
+    "Logging configuration."
+    level: LogLevel = LogLevel.info
+    log_format: str = "[%(asctime)s] [%(levelname)s] [%(module)s] [%(processName)s/%(threadName)s] [%(filename)s:%(lineno)d %(funcName)s] %(message)s"  # noqa
+    log_file: Optional[Path] = None
+
+    def configure(self, level_override: Optional[int] = None) -> None:
+        "Configure the Python logging system via basicConfig()."
+        args: dict[str, Any] = {
+            "level": (
+                level_override
+                if level_override is not None
+                else self.level
+            ),
+            "format": self.log_format,
+        }
+
+        if self.log_file:
+            args["filename"] = self.log_file
+        else:
+            args["stream"] = sys.stderr
+
+        logging.basicConfig(**args)
+
+    @classmethod
+    def of(cls, src: Mapping[str, Any]) -> "Logging":
+        "Create a Logging object from a mapping."
+        args: dict[str, Any] = {}
+
+        try:
+            args["level"] = LogLevel.of(src["level"])
+        except KeyError:
+            pass
+
+        try:
+            args["log_format"] = src["format"]
+        except KeyError:
+            pass
+
+        try:
+            args["log_file"] = Path(src["file"])
+        except KeyError:
+            pass
+
+        return cls(**args)
+
+
+add_multi_representer(ConfigBase, to_yaml, Dumper=SafeDumper)
+add_multi_representer(immutables.Map, to_yaml, Dumper=SafeDumper)
+add_multi_representer(frozenset, to_yaml, Dumper=SafeDumper)

{workercommon-0.5.2 → workercommon-0.5.3}/workercommon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workercommon
-Version: 0.5.2
+Version: 0.5.3
 Summary: Support code for various projects
 Author-email: "Neil E. Hodges" <47hasbegun@gmail.com>
 License-Expression: BSD-3-Clause

{workercommon-0.5.2 → workercommon-0.5.3}/workercommon.egg-info/SOURCES.txt

@@ -16,6 +16,10 @@ workercommon.egg-info/dependency_links.txt
 workercommon.egg-info/not-zip-safe
 workercommon.egg-info/requires.txt
 workercommon.egg-info/top_level.txt
+workercommon/config/__init__.py
+workercommon/config/_configparser.py
+workercommon/config/_yaml.py
+workercommon/config/py.typed
 workercommon/database/__init__.py
 workercommon/database/base.py
 workercommon/database/pg.py