fluentlog 0.1.0__py3-none-any.whl

fluentlog/__init__.py

@@ -0,0 +1,11 @@
+from .context import context, context_logger
+from .logger import Logger
+from .typing import Event, Level
+
+__all__ = [
+    "context",
+    "context_logger",
+    "Event",
+    "Level",
+    "Logger",
+]

fluentlog/context.py

@@ -0,0 +1,36 @@
+from collections.abc import Generator
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+from .logger import Logger
+
+_context_logger: ContextVar[Logger | None] = ContextVar("_context_logger", default=None)
+
+
+def context() -> Logger:
+    """
+    Get the logger for the current context.
+    If no logger has been set for the current context, a new logger will be returned and set as
+    the context logger.
+    """
+    logger = _context_logger.get()
+    if logger is None:
+        logger = Logger()
+        _context_logger.set(logger)
+    return logger
+
+
+@contextmanager
+def context_logger(logger: Logger) -> Generator[Logger, None, None]:
+    """
+    Context manager to set the logger for the current context.
+    This allows you to pass the logger across functions using a with statement.
+    """
+    # TODO when we support only python 3.14+ we can replace this with
+    # with _context_logger.set(logger) as token:
+    #     yield logger
+    token = _context_logger.set(logger)
+    try:
+        yield logger
+    finally:
+        _context_logger.reset(token)

fluentlog/events.py

@@ -0,0 +1,172 @@
+import copy
+import traceback
+import typing
+from datetime import date, datetime, timedelta, timezone
+
+from .helper import find_caller_frame
+from .typing import (
+    Event,
+    Level,
+    hook_function,
+    log_fields,
+    output_function,
+    ts_function,
+)
+
+
+class _DummyEvent(Event):  # pragma: no cover
+    def msg(self, message: str) -> None:
+        pass
+
+    def send(self) -> None:
+        pass
+
+    def any(self, name: str, value: typing.Any) -> typing.Self:
+        return self
+
+    def bool(self, name: str, value: bool) -> typing.Self:
+        return self
+
+    def bytes(self, name: str, value: bytes) -> typing.Self:
+        return self
+
+    def caller(self, skip: int = 0) -> typing.Self:
+        return self
+
+    def dict(self, name: str, value: dict) -> typing.Self:
+        return self
+
+    def exception(self, exc: BaseException) -> typing.Self:
+        return self
+
+    def float(self, name: str, value: float) -> typing.Self:
+        return self
+
+    def func(self, callable: hook_function) -> typing.Self:
+        return self
+
+    def int(self, name: str, value: int) -> typing.Self:
+        return self
+
+    def list(self, name: str, value: list) -> typing.Self:
+        return self
+
+    def time(self, name: str, value: typing.Union[date, datetime]) -> typing.Self:
+        return self
+
+    def timedelta(self, name: str, value: timedelta) -> typing.Self:
+        return self
+
+    def timestamp(self) -> typing.Self:
+        return self
+
+    def str(self, name: str, value: str) -> typing.Self:
+        return self
+
+
+_DUMMY_EVENT: Event = _DummyEvent()
+
+
+class _ConcreteEvent(Event):
+    __slots__ = ("_fields", "_output_fn", "_time_fn", "_hooks")
+
+    def __init__(
+        self,
+        *,
+        level: Level,
+        parent_fields: log_fields,
+        output_fn: output_function,
+        time_fn: ts_function = lambda: datetime.now(timezone.utc),
+        hooks: list[hook_function] = [],
+    ) -> None:
+        self._fields: log_fields = {"level": str(level), **parent_fields}
+        self._output_fn: output_function = output_fn
+        self._time_fn: ts_function = time_fn
+        self._hooks: list[hook_function] = hooks
+
+    def msg(self, message: str) -> None:
+        if message:
+            self._fields["message"] = message
+        for hook in self._hooks:
+            hook(self)
+        self._output_fn(self._fields)
+
+    def send(self):
+        self.msg("")
+
+    def any(self, name: str, value: typing.Any) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def bool(self, name: str, value: bool) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def bytes(self, name: str, value: bytes) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def caller(self, skip: int = 0) -> typing.Self:
+        tb = find_caller_frame(skip=skip)
+        self._fields["code.file.path"] = tb.filename
+        self._fields["code.function.name"] = tb.function
+        self._fields["code.line.number"] = tb.lineno
+        return self
+
+    def dict(self, name: str, value: dict) -> typing.Self:
+        """
+        Add a dict field to the event.
+        The dict is deep-copied to prevent mutations after the event is sent from affecting the logged data.
+        """
+        self._fields[name] = copy.deepcopy(value)
+        return self
+
+    def exception(self, exc: BaseException) -> typing.Self:
+        """
+        Stores the exception details in the event fields:
+
+        - exception.type: the type of the exception (e.g. ValueError)
+        - exception.message: the string representation of the exception (e.g. "invalid value")
+        - exception.stacktrace: the stack trace of the exception formatted using traceback.format_exception, which
+        """
+        self._fields["exception.type"] = type(exc).__name__
+        self._fields["exception.message"] = str(exc)
+        self._fields["exception.stacktrace"] = "".join(
+            traceback.format_exception(None, exc, exc.__traceback__)
+        )
+        return self
+
+    def float(self, name: str, value: float) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def func(self, callable: hook_function) -> typing.Self:
+        return typing.cast(typing.Self, callable(self))
+
+    def int(self, name: str, value: int) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def list(self, name: str, value: list) -> typing.Self:
+        """
+        Add a list field to the event.
+        The list is deep-copied to prevent mutations after the event is sent from affecting the logged data.
+        """
+        self._fields[name] = copy.deepcopy(value)
+        return self
+
+    def time(self, name: str, value: typing.Union[datetime, date]) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def timedelta(self, name: str, value: timedelta) -> typing.Self:
+        self._fields[name] = value
+        return self
+
+    def timestamp(self) -> typing.Self:
+        self._fields["time"] = self._time_fn()
+        return self
+
+    def str(self, name: str, value: str) -> typing.Self:
+        self._fields[name] = value
+        return self

fluentlog/helper.py

@@ -0,0 +1,43 @@
+import inspect
+from pathlib import Path
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+_DUMMY_TRACEBACK = inspect.Traceback(
+    filename="<unknown>",
+    lineno=0,
+    function="<unknown>",
+    code_context=None,
+    index=0,
+)
+
+
+def _is_internal_frame(filename: str) -> bool:
+    try:
+        file_path = Path(filename).resolve()
+    except (OSError, RuntimeError):  # pragma: no cover
+        return False
+    return file_path == _PACKAGE_DIR or _PACKAGE_DIR in file_path.parents
+
+
+def find_caller_frame(skip: int = 0) -> inspect.Traceback:
+    """
+    Returns the first frame outside the fluentlog package.
+
+    The ``skip`` parameter can be used to skip additional non-internal frames,
+    which is useful when logs are emitted through wrapper functions.
+
+    If no caller frame is found, returns a dummy traceback with placeholder values.
+    """
+    frame = inspect.currentframe()
+    if frame is None:  # pragma: no cover
+        # this should never happen in reality
+        return _DUMMY_TRACEBACK
+
+    frame = frame.f_back
+    while frame is not None:
+        if not _is_internal_frame(frame.f_code.co_filename):
+            if skip == 0:
+                return inspect.getframeinfo(frame)
+            skip -= 1
+        frame = frame.f_back
+    return _DUMMY_TRACEBACK  # pragma: no cover

fluentlog/logger.py

@@ -0,0 +1,196 @@
+import copy
+import traceback
+import typing
+from datetime import date, datetime, timedelta, timezone
+
+from .events import _DUMMY_EVENT, _ConcreteEvent
+from .output import json_output
+from .typing import (
+    Event,
+    Level,
+    LogFieldsBuilder,
+    hook_function,
+    log_fields,
+    output_function,
+    ts_function,
+)
+
+
+class Logger:
+    __slots__ = ("_level", "_fields", "_output_fn", "_hooks", "_time_fn")
+
+    def __init__(
+        self,
+        *,
+        level: Level = Level.INFO,
+        fields: log_fields | None = None,
+        output_fn: output_function | None = None,
+        hooks: list[hook_function] | None = None,
+        time_fn: ts_function | None = None,
+    ) -> None:
+        self._level: Level = level
+        self._fields: log_fields = fields or {}
+        self._output_fn: output_function = output_fn or json_output
+        self._hooks: list[hook_function] = hooks or []
+        self._time_fn: ts_function = time_fn or (lambda: datetime.now(timezone.utc))
+
+    def set_level(self, level: Level) -> None:
+        self._level = level
+
+    def set_output(self, output_fn: output_function) -> "Logger":
+        self._output_fn = output_fn
+        return self
+
+    def _handle_event(self, level: Level) -> Event:
+        if self._level > level:
+            return _DUMMY_EVENT
+        return _ConcreteEvent(
+            level=level,
+            parent_fields=self._fields,
+            output_fn=self._output_fn,
+            hooks=self._hooks,
+            time_fn=self._time_fn,
+        )
+
+    def trace(self) -> Event:
+        return self._handle_event(Level.TRACE)
+
+    def debug(self) -> Event:
+        return self._handle_event(Level.DEBUG)
+
+    def info(self) -> Event:
+        return self._handle_event(Level.INFO)
+
+    def warning(self) -> Event:
+        return self._handle_event(Level.WARNING)
+
+    def error(self) -> Event:
+        return self._handle_event(Level.ERROR)
+
+    def fatal(self) -> Event:
+        return self._handle_event(Level.FATAL)
+
+    def bind(self) -> "LoggerBuilder":
+        """
+        Creates a new context that inherits the log level and fields of the logger.
+        The context can be used to build a new logger with additional fields using the logger() method
+        """
+        return LoggerBuilder(parent_logger=self)
+
+
+class LoggerBuilder(LogFieldsBuilder):
+    __slots__ = ("_parent", "_fields", "_hooks")
+
+    def __init__(
+        self,
+        *,
+        parent_logger: Logger,
+    ) -> None:
+        """
+        Creates a new context that inherits the log level and fields of the logger.
+        The context can be used to build a new logger with additional fields using the logger() method.
+
+        The parent fields are shallowed copied to prevent mutations, and event methods
+        that accept dicts or lists will deep copy the data to prevent mutations after the fact
+        from affecting the log output.
+
+        The parent hooks are shallowed copied so modifying the parent logger will not modify
+        the child logger.
+        """
+        self._parent = parent_logger
+        self._fields: log_fields = {**parent_logger._fields}
+        self._hooks: list[hook_function] = [*parent_logger._hooks]
+
+    def any(self, name: str, value: typing.Any) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def bool(self, name: str, value: bool) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def bytes(self, name: str, value: bytes) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def caller(self, skip: int = 0) -> "LoggerBuilder":
+        """
+        Adds a hook that captures the caller's file, function, and line number for every event.
+        The ``skip`` parameter skips additional non-internal frames (useful for wrapper functions).
+        """
+        caller_hook: hook_function = lambda e: e.caller(skip=skip)
+        self._hooks.append(caller_hook)
+        return self
+
+    def dict(self, name: str, value: dict) -> "LoggerBuilder":
+        """
+        Adds a dict field to the context.
+        The dict is deep-copied to prevent mutations after the fact from affecting the log output.
+        """
+        self._fields[name] = copy.deepcopy(value)
+        return self
+
+    def exception(self, exc: BaseException) -> "LoggerBuilder":
+        """
+        Stores the exception details in the event fields:
+
+        - exception.type: the type of the exception (e.g. ValueError)
+        - exception.message: the string representation of the exception (e.g. "invalid value")
+        - exception.stacktrace: the stack trace of the exception formatted using traceback.format_exception, which
+        """
+        self._fields["exception.type"] = type(exc).__name__
+        self._fields["exception.message"] = str(exc)
+        self._fields["exception.stacktrace"] = "".join(
+            traceback.format_exception(None, exc, exc.__traceback__)
+        )
+        return self
+
+    def float(self, name: str, value: float) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def func(self, callable: hook_function) -> "LoggerBuilder":
+        """
+        Adds a hook function to the context that will be called with the event as an argument when
+        an event is finalized.
+        """
+        self._hooks.append(callable)
+        return self
+
+    def int(self, name: str, value: int) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def list(self, name: str, value: list) -> "LoggerBuilder":
+        """
+        Adds a list field to the context.
+        The list is deep-copied to prevent mutations after the fact from affecting the log output.
+        """
+        self._fields[name] = copy.deepcopy(value)
+        return self
+
+    def time(self, name: str, value: typing.Union[datetime, date]) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def timedelta(self, name: str, value: timedelta) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def str(self, name: str, value: str) -> "LoggerBuilder":
+        self._fields[name] = value
+        return self
+
+    def timestamp(self) -> "LoggerBuilder":
+        ts_hook = lambda e: e.time("time", self._parent._time_fn())
+        self._hooks.append(ts_hook)
+        return self
+
+    def logger(self) -> Logger:
+        return Logger(
+            level=self._parent._level,
+            fields=self._fields,
+            output_fn=self._parent._output_fn,
+            hooks=self._hooks,
+            time_fn=self._parent._time_fn,
+        )

fluentlog/output.py

@@ -0,0 +1,39 @@
+import sys
+import typing
+from datetime import timedelta
+
+import orjson
+
+from .typing import log_fields
+
+
+def orjson_fallback_default(obj: object) -> typing.Any:
+    """
+    Fallback default function for orjson that handles unserializable objects.
+
+    Bytes are decoded to UTF-8 strings with backslash replacement for errors.
+    Timedelta objects are converted to their string representation (e.g. "0:10:05").
+
+    For other unserializable objects, their repr() is used as a fallback.
+    """
+
+    if isinstance(obj, bytes):
+        return obj.decode("utf-8", errors="backslashreplace")
+
+    if isinstance(obj, timedelta):
+        return str(obj)
+
+    return repr(obj)
+
+
+def json_output(payload: log_fields) -> None:
+    """
+    Outputs the given object as JSON to stdout using orjson with the fallback default function.
+    """
+    sys.stdout.buffer.write(
+        orjson.dumps(
+            payload,
+            default=orjson_fallback_default,
+            option=orjson.OPT_APPEND_NEWLINE,
+        )
+    )

fluentlog/typing.py

@@ -0,0 +1,117 @@
+import enum
+import typing
+from datetime import date, datetime, timedelta
+from logging import CRITICAL
+
+# output_function is a function that takes a dictionary of log fields and outputs it (e.g. to stdout or a file)
+type output_function = typing.Callable[[dict[str, typing.Any]], None]
+# hook_function is a function that takes an Event as an argument and can modify it before it is finalized
+type hook_function = typing.Callable[["Event"], "Event"]
+# ts_function is a function to generate the current timestamp for an event
+type ts_function = typing.Callable[[], datetime]
+
+type log_fields = dict[str, typing.Any]
+
+
+class Level(enum.IntEnum):
+    TRACE = enum.auto()
+    DEBUG = enum.auto()
+    INFO = enum.auto()
+    WARNING = enum.auto()
+    ERROR = enum.auto()
+    FATAL = enum.auto()
+
+    def __str__(self) -> str:
+        return self.name
+
+
+class LogFieldsBuilder(typing.Protocol):
+    """
+    LogFieldsBuilder is the fluent interface for building loggers and events including the context.
+
+    This protocol ensures both LoggerBuilder and Event support adding the same field types to the context.
+    """
+
+    def any(self, name: str, value: typing.Any) -> typing.Self: ...
+
+    def bool(self, name: str, value: bool) -> typing.Self: ...
+
+    def bytes(self, name: str, value: bytes) -> typing.Self: ...
+
+    def caller(self, skip: int = 0) -> typing.Self:
+        """
+        Identifies the caller of the log method and adds it to the log fields, with the following fields:
+
+        - `code.file.path`: The full path of the file containing the caller.
+        - `code.function.name`: The name of the function containing the caller.
+        - `code.line.number`: The line number of the caller in the source code.
+
+        The optional `skip` parameter can be used to skip additional stack frames
+        if the caller is wrapped in helper functions.
+        """
+        ...
+
+    def dict(self, name: str, value: dict) -> typing.Self: ...
+
+    def exception(self, exc: BaseException) -> typing.Self:
+        """
+        Stores the exception details in the event fields:
+        - `exception.type`: the type of the exception (e.g. ValueError)
+        - `exception.message`: the message of the exception
+        - `exception.stacktrace`: the stack trace of the exception
+        """
+        ...
+
+    def float(self, name: str, value: float) -> typing.Self: ...
+
+    def func(self, callable: hook_function) -> typing.Self:
+        """
+        Runs the function if the log level is enabled.
+        The function receives the event as an argument and can add fields to it.
+        """
+        ...
+
+    def int(self, name: str, value: int) -> typing.Self: ...
+
+    def list(self, name: str, value: list) -> typing.Self: ...
+
+    def time(self, name: str, value: typing.Union[date, datetime]) -> typing.Self:
+        """
+        Adds a time field to the event
+        """
+        ...
+
+    def timedelta(self, name: str, value: timedelta) -> typing.Self:
+        """
+        Adds a timedelta field to the event
+        """
+        ...
+
+    def timestamp(self) -> typing.Self:
+        """Adds a timestamp field to the event with the current time in ISO 8601 format."""
+        ...
+
+    # str needs to come last because it redefines what str means in the context of the class creation
+    # (i.e. name: str would be interpreted Event.str instead of a string type annotation)
+    def str(self, name: str, value: str) -> typing.Self: ...
+
+
+class Event(LogFieldsBuilder, typing.Protocol):
+    """
+    Event represents a log event. It includes the context building methods plus the msg() and send()
+    method to finalize and output the event.
+    """
+
+    def msg(self, message: str) -> None:
+        """
+        Finalizes the event and outputs it.
+        The message is a human-readable string that describes the event.
+        """
+        ...
+
+    def send(self) -> None:
+        """
+        Finalizes the event and outputs it without a message.
+        This is a convenience method that calls msg("").
+        """
+        ...

fluentlog-0.1.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: fluentlog
+Version: 0.1.0
+Summary: Opinionated structured logging library for Python with a fluent interface
+License: Apache-2.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: orjson>=3.11.7
+Dynamic: license-file
+
+# Fluentlog
+
+Opinionated structured logging for Python with a fluent API.
+
+- API inspired by zerolog
+- JSON output format
+- OpenTelemetry naming conventions when relevant
+- Near zero-cost for disabled log levels
+
+## Installation
+
+```bash
+pip install fluentlog
+```
+
+## Getting Started
+
+### Simple example
+
+```python
+import fluentlog
+
+log = fluentlog.Logger().bind().int("request_id", 1).logger()
+
+log.info().str("user", "jmcs").int("uid", 42).msg("user logged in")
+# {"level":"INFO","request_id":1,"user":"jmcs","uid":42,"message":"user logged in"}
+
+# Disabled levels have near-zero overhead
+log.debug().func( expensive_func).msg("debug info")  # expensive_func is never called
+```
+
+### Log Levels
+
+fluentlog supports the following log levels, from more to less critical:
+
+- `FATAL`: Errors the application can't recover from
+- `ERROR`: Errors that make the current context fail, but not the entire application
+- `WARNING`: Recoverable errors
+- `INFO`: Expected lifecycle events and relevant business signals
+- `DEBUG`: Internal details useful while diagnosing behavior during development
+- `TRACE`: Very fine-grained execution details, usually only useful for deep debugging
+
+You can set the log level for your logger either in the constructor or using a fluent method:
+
+```python
+import fluentlog
+
+log = fluentlog.Logger(level=fluentlog.Level.DEBUG)
+
+# or 
+
+log = fluentlog.Logger().set_level(fluentlog.Level.DEBUG)
+```
+
+### Logging context
+
+```python
+import fluentlog
+
+def some_func():
+    log = fluentlog.context()
+    log.info().msg("From func")
+
+def main():
+    log = fluentlog.context().bind().str("context", "example").logger()
+    some_func()
+    # {"level":"INFO", "message": "From func"}
+    with fluentlog.context_logger(log):
+        some_func()
+        # {"level":"INFO", "context": "example", "message": "From func"}
+
+main()
+```
+
+## Performance
+
+Benchmarks show ~2-3x faster than stdlib logging with formatted output, with greater advantages
+when log levels are filtered.
+
+## Design decisions
+
+### Why use different methods for different types?
+Using different methods for different types allows for optimising serialization strategies for
+mutable and immutable types. For example, `dict()` and `list()` deep-copy their arguments to prevent
+mutations after the event is logged from affecting the output, while `int()` and `str()` can safely
+reference immutable values directly without copying.
+
+### Why dummy events for disabled log levels?
+Having dummy events achieves near-zero overhead, as we can avoid unnecessary processing without
+having to check the log level everywhere.
+
+### Why OpenTelemetry naming conventions?
+I use OpenTelemetry for distributed tracing, and like consistent and precise naming, even when it
+comes at the cost of verbosity.
+
+### Why no formatted messages?
+Formatted messages are familiar because that's how traditional logging usually works. But for
+structured logs they are a trap, as important data gets buried in strings instead of proper fields,
+which makes filtering and querying harder.
+
+### Why context-based logger passing?
+Preserving logging context across boundaries is essential in complex applications, but having
+bound context inside a function is useful too. Context-based logger passing allows for both
+options and keeps things purposeful while avoiding cluttering application APIs.

fluentlog-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+fluentlog/__init__.py,sha256=VjLzSJQ6fZ1ZDqUmnQUj8AutkGh4oaTTzwCxqh1KqO0,197
+fluentlog/context.py,sha256=neRQLfQyOtIBkrlMo0_ItGL2p3wdpE9SzfBMJUhH-2Y,1082
+fluentlog/events.py,sha256=PRbNWgBL-Tlfeo5tx47jpM0jkn7QPeg03fnMp9rlAIw,5153
+fluentlog/helper.py,sha256=8gZUFrJfODsnn_nYQazXVBC7MXzYx8WVTLopTKj9S5k,1301
+fluentlog/logger.py,sha256=DnleEPTzHFzVOpdBk-hkfEuOCPO1EBe04xv-GFMFqNQ,6573
+fluentlog/output.py,sha256=0vQHXhY6w8uxu500ajUvoAK0niwKnE9CL_fqwiEJXZY,1009
+fluentlog/typing.py,sha256=eZLXmgAp3qDEsOSqE9_Oul2ZMKITRVcqfHXn7d2jBFM,4021
+fluentlog-0.1.0.dist-info/licenses/LICENSE,sha256=IWr-GfgKdSDziBxmGJid5HRnf89uqmTTbzmSGQs2h6Y,10960
+fluentlog-0.1.0.dist-info/METADATA,sha256=0xv9c2xWcXzZOvnMC8IPyc-_FaoHt3JjSuGbAsdr-iE,3635
+fluentlog-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+fluentlog-0.1.0.dist-info/top_level.txt,sha256=5pY-UVkUnLs53dXbEOYUJ6W_Dq7JkmOwcKO2rMti7SQ,10
+fluentlog-0.1.0.dist-info/RECORD,,

fluentlog-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fluentlog-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+        Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+        stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+        that You distribute, all copyright, patent, trademark, and
+        attribution notices from the Source form of the Work,
+        excluding those notices that do not pertain to any part of
+        the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+        distribution, then any Derivative Works that You distribute must
+        include a readable copy of the attribution notices contained
+        within such NOTICE file, excluding those notices that do not
+        pertain to any part of the Derivative Works, in at least one
+        of the following places: within a NOTICE text file distributed
+        as part of the Derivative Works; within the Source form or
+        documentation, if provided along with the Derivative Works; or,
+        within a display generated by the Derivative Works, if and
+        wherever such third-party notices normally appear. The contents
+        of the NOTICE file are for informational purposes only and
+        do not modify the License. You may add Your own attribution
+        notices within Derivative Works that You distribute, alongside
+        or as an addendum to the NOTICE text from the Work, provided
+        that such additional attribution notices cannot be construed
+        as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+    file or class name and description of purpose be included on the
+    same "printed page" as the copyright notice for easier
+    identification within third-party archives.
+
+Copyright 2026 João Santos
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

fluentlog-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fluentlog