logbook-stubs 0.1.0__tar.gz

logbook_stubs-0.1.0/.gitignore

@@ -0,0 +1,134 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+.vscode
+.helix
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+examples/*.service

logbook_stubs-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: logbook-stubs
+Version: 0.1.0
+Summary: Type stubs for logbook
+Requires-Python: >=3.12

logbook_stubs-0.1.0/logbook/__init__.pyi

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from logbook.base import (
+    CRITICAL as CRITICAL,
+    DEBUG as DEBUG,
+    ERROR as ERROR,
+    INFO as INFO,
+    NOTICE as NOTICE,
+    NOTSET as NOTSET,
+    TRACE as TRACE,
+    WARNING as WARNING,
+    Logger as Logger,
+    LoggerGroup as LoggerGroup,
+    LogLevel as LogLevel,
+    LogRecord as LogRecord,
+    Processor as Processor,
+)

logbook_stubs-0.1.0/logbook/base.pyi

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from datetime import datetime
+from types import FrameType, TracebackType
+from typing import TYPE_CHECKING, Callable, Literal, TypeAlias
+
+if TYPE_CHECKING:
+    from logbook.handlers import Handler
+
+from _typeshed import Incomplete
+
+StringLevel: TypeAlias = Literal['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'NOTICE', 'TRACE', 'NOTSET']
+# Need to keep in sync with the constansts from logbook.base
+NumericLevel: TypeAlias = Literal[15, 14, 13, 12, 11, 10, 9, 0]
+LogLevel: TypeAlias = StringLevel | NumericLevel
+
+# Level constants
+CRITICAL: Literal[15] = 15
+ERROR: Literal[14] = 14
+WARNING: Literal[13] = 13
+INFO: Literal[12] = 12
+DEBUG: Literal[11] = 11
+NOTICE: Literal[10] = 10
+TRACE: Literal[9] = 9
+NOTSET: Literal[0] = 0
+
+_ExcInfo = tuple[type[BaseException], BaseException, TracebackType] | tuple[None, None, None]
+
+class LogRecord:
+    channel: str
+    msg: str
+    args: tuple[Incomplete, ...]
+    kwargs: dict[str, Incomplete]
+    level: LogLevel
+    exc_info: _ExcInfo | Literal[True] | None
+    extra: defaultdict[str, Incomplete]
+    frame: FrameType | None
+    frame_correction: int
+    process: int | None
+    time: datetime | None
+    keep_open: bool
+    heavy_initialized: bool
+    late: bool
+    information_pulled: bool
+
+    def __init__(
+        self,
+        channel: str,
+        level: int | StringLevel,
+        msg: str,
+        args: tuple[Incomplete, ...] | None = ...,
+        kwargs: dict[str, Incomplete] | None = ...,
+        exc_info: _ExcInfo | Literal[True] | BaseException | None = ...,
+        extra: dict[str, Incomplete] | None = ...,
+        frame: FrameType | None = ...,
+        dispatcher: Incomplete = ...,
+        frame_correction: int = ...,
+    ) -> None: ...
+    @property
+    def message(self) -> str: ...
+    @property
+    def level_name(self) -> str: ...
+    @property
+    def calling_frame(self) -> FrameType | None: ...
+    @property
+    def func_name(self) -> str | None: ...
+    @property
+    def module(self) -> str | None: ...
+    @property
+    def filename(self) -> str | None: ...
+    @property
+    def lineno(self) -> int | None: ...
+    @property
+    def greenlet(self) -> int | None: ...
+    @property
+    def thread(self) -> int | None: ...
+    @property
+    def thread_name(self) -> str | None: ...
+    @property
+    def process_name(self) -> str | None: ...
+    @property
+    def formatted_exception(self) -> str | None: ...
+    @property
+    def exception_name(self) -> str | None: ...
+    @property
+    def exception_shortname(self) -> str | None: ...
+    @property
+    def exception_message(self) -> str | None: ...
+    @property
+    def dispatcher(self) -> Incomplete: ...
+    def heavy_init(self) -> None: ...
+    def pull_information(self) -> None: ...
+    def close(self) -> None: ...
+    def to_dict(self, json_safe: bool = ...) -> dict[str, Incomplete]: ...
+    @classmethod
+    def from_dict(cls, d: dict[str, Incomplete]) -> LogRecord: ...
+    def update_from_dict(self, d: dict[str, Incomplete]) -> LogRecord: ...
+
+class RecordDispatcher:
+    """A record dispatcher is the internal base class that implements
+    the logic used by the :class:`~logbook.Logger`.
+    """
+
+    suppress_dispatcher: bool
+    name: str | None
+    handlers: list['Handler']
+    group: LoggerGroup | None
+    level: int
+    disabled: bool
+
+    def __init__(self, name: str | None = None, level: int = ...) -> None: ...
+    def handle(self, record: LogRecord) -> None: ...
+    def make_record_and_handle(
+        self,
+        level: int,
+        msg: str,
+        args: tuple[Incomplete, ...],
+        kwargs: dict[str, Incomplete],
+        exc_info: _ExcInfo | Literal[True] | BaseException | None,
+        extra: dict[str, Incomplete] | None,
+        frame_correction: int,
+    ) -> None: ...
+    def call_handlers(self, record: LogRecord) -> None: ...
+
+class LoggerMixin:
+    """This mixin class defines and implements the "usual" logger
+    interface (i.e. the descriptive logging functions).
+    """
+
+    level_name: str
+
+    def trace(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def debug(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def info(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def notice(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def warning(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def error(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def critical(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def exception(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+    def log(self, level: int, *args: Incomplete, **kwargs: Incomplete) -> None: ...
+
+class Logger(RecordDispatcher, LoggerMixin):
+    """Instances of the Logger class represent a single logging channel."""
+
+    def __init__(self, name: str | None = None, level: int = ...) -> None: ...
+
+class LoggerGroup:
+    """A LoggerGroup represents a group of loggers."""
+
+    loggers: list[Logger]
+    level: int
+    disabled: bool
+    processor: Incomplete | None
+
+    def __init__(
+        self,
+        loggers: list[Logger] | None = None,
+        level: int = ...,
+        processor: Incomplete | None = None,
+    ) -> None: ...
+    def add_logger(self, logger: Logger) -> None: ...
+    def remove_logger(self, logger: Logger) -> None: ...
+    def process_record(self, record: LogRecord) -> None: ...
+
+class Processor:
+    """A context manager that processes log records with a given function."""
+
+    def __init__(self, callback: Callable[[LogRecord], None]) -> None: ...
+    def __enter__(self) -> Processor: ...
+    def __exit__(self, exc_type: object, exc_value: object, tb: object) -> None: ...

logbook_stubs-0.1.0/logbook/handlers.pyi

@@ -0,0 +1,52 @@
+from typing import IO, TYPE_CHECKING, Callable, Literal, Self
+
+if TYPE_CHECKING:
+    from threading import RLock
+
+from _typeshed import Incomplete
+from logbook.base import LogRecord
+
+class Handler:
+    def emit(self, record: LogRecord) -> None: ...
+    def format(self, record: LogRecord) -> str: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, exc_type: object, exc_value: object, tb: object) -> None: ...
+
+class Formatter:
+    def __call__(self, record: LogRecord, handler: Handler) -> str: ...
+
+class StringFormatterHandlerMixin: ...
+
+class StreamHandler(Handler, StringFormatterHandlerMixin):
+    stream: IO[str]
+    lock: RLock
+    def __init__(
+        self,
+        stream: Incomplete = ...,
+        level: int | str = 0,
+        format_string: str = '',
+        encoding: str | None = None,
+        filter: 'LogFilter | None' = None,
+        bubble: bool = False,
+    ) -> None: ...
+    def ensure_stream_is_open(self) -> None: ...
+    def encode(self, msg: str) -> str: ...
+    def write(self, item: str) -> None: ...
+    def should_flush(self) -> Literal[True]: ...
+    def flush(self) -> None: ...
+
+type LogFilter = Callable[[LogRecord, Handler], bool]
+
+class StderrHandler(StreamHandler):
+    def __init__(
+        self, level: int | str = 0, format_string: str = '', filter: LogFilter | None = None, bubble: bool = False
+    ) -> None: ...
+
+__all__ = [
+    'Handler',
+    'Formatter',
+    'StringFormatterHandlerMixin',
+    'StreamHandler',
+    'StderrHandler',
+    'LogFilter',
+]

logbook_stubs-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "logbook-stubs"
+description = "Type stubs for logbook"
+version = "0.1.0"
+requires-python = ">=3.12"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["logbook"]  # Package is at ./logbook/ relative to this pyproject.toml