structlog-config 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

structlog_config/__init__.py

@@ -11,9 +11,10 @@ from structlog.typing import FilteringBoundLogger
 
 from structlog_config.formatters import (
     PathPrettifier,
+    WheneverFormatter,
     add_fastapi_context,
+    beautiful_traceback_exception_formatter,
     logger_name,
-    pretty_traceback_exception_formatter,
     simplify_activemodel_objects,
 )
 
@@ -45,8 +46,7 @@ def log_processors_for_mode(json_logger: bool) -> list[structlog.types.Processor
             )
 
         return [
-            # add exc_info=True to a log and get a full stack trace attached to it
-            structlog.processors.format_exc_info,
+            # omit `structlog.processors.format_exc_info` so we can use structured logging for exceptions
             # simple, short exception rendering in prod since sentry is in place
             # https://www.structlog.org/en/stable/exceptions.html this is a customized version of dict_tracebacks
             ExceptionRenderer(
@@ -65,8 +65,8 @@ def log_processors_for_mode(json_logger: bool) -> list[structlog.types.Processor
     return [
         structlog.dev.ConsoleRenderer(
             colors=not NO_COLOR,
-            exception_formatter=pretty_traceback_exception_formatter
-            if packages.pretty_traceback
+            exception_formatter=beautiful_traceback_exception_formatter
+            if packages.beautiful_traceback
             else structlog.dev.default_exception_formatter,
         )
     ]
@@ -86,6 +86,7 @@ def get_default_processors(json_logger) -> list[structlog.types.Processor]:
         if packages.activemodel and packages.typeid
         else None,
         PathPrettifier(),
+        WheneverFormatter() if packages.whenever else None,
         structlog.processors.TimeStamper(fmt="iso", utc=True),
         # add `stack_info=True` to a log and get a `stack` attached to the log
         structlog.processors.StackInfoRenderer(),

structlog_config/fastapi_access_logger.py

@@ -7,7 +7,7 @@ from urllib.parse import quote
 
 import structlog
 from fastapi import FastAPI
-from python_ipware import IpWare
+from fastapi_ipware import FastAPIIpWare
 from starlette.middleware.base import RequestResponseEndpoint
 from starlette.requests import Request
 from starlette.responses import Response
@@ -15,9 +15,8 @@ from starlette.routing import Match, Mount
 from starlette.types import Scope
 from starlette.websockets import WebSocket
 
-# should name this access "access_log" or something
 log = structlog.get_logger()
-ipw = IpWare()
+ipware = FastAPIIpWare()
 
 
 def get_route_name(app: FastAPI, scope: Scope, prefix: str = "") -> str:
@@ -59,35 +58,17 @@ def client_ip_from_request(request: Request | WebSocket) -> str | None:
     """
     Get the client IP address from the request.
 
-    Headers are not case-sensitive.
-
-    Uses ipware library to properly extract client IP from various proxy headers.
+    Uses fastapi-ipware library to properly extract client IP from various proxy headers.
     Fallback to direct client connection if no proxy headers found.
     """
-    headers = request.headers
-
-    # TODO this seems really inefficient, we should just rewrite the ipware into this repo :/
-    # Convert Starlette headers to format expected by ipware (HTTP_ prefixed)
-    # ipware expects headers in WSGI/Django-style meta format where HTTP headers
-    # are prefixed with "HTTP_" and dashes become underscores.
-    # See: https://github.com/un33k/python-ipware/blob/main/python_ipware/python_ipware.py#L33-L40
-    meta_dict = {}
-    for name, value in headers.items():
-        # Convert header name to HTTP_ prefixed format
-        meta_key = f"HTTP_{name.upper().replace('-', '_')}"
-        meta_dict[meta_key] = value
-
-    # Use ipware to extract IP from headers
-    ip, trusted_route = ipw.get_client_ip(meta=meta_dict)
+    ip, trusted_route = ipware.get_client_ip_from_request(request)
     if ip:
         log.debug(
             "extracted client IP from headers", ip=ip, trusted_route=trusted_route
         )
         return str(ip)
 
-    # Fallback to direct client connection
     host = request.client.host if request.client else None
-
     return host
 
 
@@ -101,16 +82,8 @@ def is_static_assets_request(scope: Scope) -> bool:
     Returns:
         bool: True if the request is for static assets, False otherwise.
     """
-    return (
-        scope["path"].endswith(".css")
-        or scope["path"].endswith(".js")
-        # .map files are attempted when devtools are enabled
-        or scope["path"].endswith(".js.map")
-        or scope["path"].endswith(".ico")
-        or scope["path"].endswith(".png")
-        or scope["path"].endswith(".jpg")
-        or scope["path"].endswith(".jpeg")
-        or scope["path"].endswith(".gif")
+    return scope["path"].endswith(
+        (".css", ".js", ".js.map", ".ico", ".png", ".jpg", ".jpeg", ".gif", ".webp")
     )
 
 

structlog_config/formatters.py

@@ -64,17 +64,17 @@ def logger_name(logger: Any, method_name: Any, event_dict: EventDict) -> EventDi
     return event_dict
 
 
-def pretty_traceback_exception_formatter(sio: TextIO, exc_info: ExcInfo) -> None:
+def beautiful_traceback_exception_formatter(sio: TextIO, exc_info: ExcInfo) -> None:
     """
     By default, rich and then better-exceptions is used to render exceptions when a ConsoleRenderer is used.
 
-    I prefer pretty-traceback, so I've added a custom processor to use it.
+    I prefer beautiful-traceback, so I've added a custom processor to use it.
 
     https://github.com/hynek/structlog/blob/66e22d261bf493ad2084009ec97c51832fdbb0b9/src/structlog/dev.py#L412
     """
 
     # only available in dev
-    from pretty_traceback.formatting import exc_to_traceback_str
+    from beautiful_traceback.formatting import exc_to_traceback_str
 
     _, exc_value, traceback = exc_info
     # TODO support local_stack_only env var support
@@ -150,6 +150,26 @@ class RenameField:
         return event_dict
 
 
+class WheneverFormatter:
+    """A processor for formatting whenever datetime objects.
+
+    Changes all whenever datetime objects (ZonedDateTime, Instant, PlainDateTime, etc.)
+    from their repr() format (e.g., ZonedDateTime("2025-11-02 00:00:00+00:00[UTC]"))
+    to their string format (e.g., 2025-11-02 00:00:00+00:00[UTC]).
+
+    This provides cleaner log output without the class wrapper.
+    """
+
+    def __call__(self, _, __, event_dict):
+        for key, value in event_dict.items():
+            # Check if the value has the _pywhenever module attribute
+            # This is a reliable way to detect whenever types without importing them
+            if hasattr(value, "__module__") and value.__module__.startswith("whenever"):
+                event_dict[key] = str(value)
+
+        return event_dict
+
+
 def add_fastapi_context(
     logger: logging.Logger,
     method_name: str,

structlog_config/packages.py

@@ -23,11 +23,16 @@ except ImportError:
     typeid = None
 
 try:
-    import pretty_traceback
+    import beautiful_traceback
 except ImportError:
-    pretty_traceback = None
+    beautiful_traceback = None
 
 try:
     import starlette_context
 except ImportError:
     starlette_context = None
+
+try:
+    import whenever
+except ImportError:
+    whenever = None

structlog_config/pytest_plugin.py

@@ -0,0 +1,222 @@
+"""
+Pytest plugin for capturing and displaying logs only on test failures.
+
+This plugin integrates with structlog-config's file logging to capture logs per-test
+and display them only when tests fail, keeping output clean for passing tests.
+
+Usage:
+    1. Install the plugin (automatically registered via entry point):
+       pip install structlog-config[fastapi]
+
+    2. Enable in pytest.ini or pyproject.toml:
+       [tool.pytest.ini_options]
+       addopts = ["--capture-logs-on-fail"]
+
+    Or enable for a single test run:
+       pytest --capture-logs-on-fail
+
+    3. Optional: Persist all logs to a directory:
+       pytest --capture-logs-dir=/path/to/logs
+
+How it works:
+    - Sets PYTHON_LOG_PATH to a unique temp file for each test
+    - Logs are written to /tmp/<project-name>-pytest-logs-*/test_name.log
+    - On test failure, prints captured logs to stdout
+    - Cleans up temp files after each test (unless --capture-logs-dir is set)
+    - Automatically disabled if PYTHON_LOG_PATH is already set
+
+Example output on failure:
+    --- Captured logs for failed test: tests/test_foo.py::test_bar ---
+    2025-10-31 23:30:00 [info] Starting test
+    2025-10-31 23:30:01 [error] Something went wrong
+"""
+
+import logging
+import os
+import re
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Generator
+
+import pytest
+
+logger = logging.getLogger(__name__)
+
+PLUGIN_KEY = pytest.StashKey[dict]()
+SESSION_TMPDIR_KEY = "session_tmpdir"
+
+
+def sanitize_filename(name: str) -> str:
+    """Replace non-filename-safe characters with underscores.
+
+    Args:
+        name: The filename to sanitize (typically a pytest nodeid).
+
+    Returns:
+        A filesystem-safe filename string.
+    """
+    return re.sub(r"[^A-Za-z0-9_.-]", "_", name)
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Register the --capture-logs-on-fail command line option.
+
+    Args:
+        parser: The pytest parser to add options to.
+    """
+    parser.addoption(
+        "--capture-logs-on-fail",
+        action="store_true",
+        default=False,
+        help="Capture logs to a temp file and dump them to stdout on test failure.",
+    )
+    parser.addoption(
+        "--capture-logs-dir",
+        action="store",
+        default=None,
+        help="Directory to persist all test logs (disables automatic cleanup).",
+    )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_configure(config: pytest.Config) -> None:
+    """Configure the plugin at pytest startup.
+
+    Stores configuration state on the config object for use by fixtures and hooks.
+
+    Args:
+        config: The pytest config object.
+    """
+    logs_dir = config.getoption("--capture-logs-dir")
+    enabled = config.getoption("--capture-logs-on-fail") or logs_dir is not None
+    
+    plugin_config = {
+        "enabled": enabled,
+        "logs_dir": logs_dir,
+        "project_name": os.path.basename(str(config.rootdir)),
+    }
+    config.stash[PLUGIN_KEY] = plugin_config
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_sessionstart(session: pytest.Session) -> None:
+    """Create a session-level temp directory for log files.
+
+    Args:
+        session: The pytest session object.
+    """
+    config = session.config
+    plugin_config = config.stash.get(PLUGIN_KEY, {})
+    
+    if not plugin_config.get("enabled"):
+        return
+    
+    logs_dir = plugin_config.get("logs_dir")
+    if logs_dir:
+        tmpdir = Path(logs_dir)
+        tmpdir.mkdir(parents=True, exist_ok=True)
+    else:
+        project_name = plugin_config.get("project_name", "pytest")
+        tmpdir = Path(tempfile.mkdtemp(prefix=f"{project_name}-pytest-logs-"))
+    
+    plugin_config[SESSION_TMPDIR_KEY] = tmpdir
+    config.stash[PLUGIN_KEY] = plugin_config
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_sessionfinish(session: pytest.Session) -> None:
+    """Clean up session-level temp directory unless --capture-logs-dir was used.
+
+    Args:
+        session: The pytest session object.
+    """
+    config = session.config
+    plugin_config = config.stash.get(PLUGIN_KEY, {})
+    
+    if not plugin_config.get("enabled"):
+        return
+    
+    logs_dir = plugin_config.get("logs_dir")
+    tmpdir = plugin_config.get(SESSION_TMPDIR_KEY)
+    
+    if tmpdir and not logs_dir:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+@pytest.fixture(autouse=True)
+def capture_logs_on_fail(request: pytest.FixtureRequest) -> Generator[None, None, None]:
+    """Set up per-test log capture to a temporary file.
+
+    This fixture runs automatically for every test when --capture-logs-on-fail is enabled.
+    It sets PYTHON_LOG_PATH to redirect logs to a unique temp file, then cleans up after.
+
+    Args:
+        request: The pytest request fixture providing test context.
+
+    Yields:
+        Control back to the test, then handles cleanup after test completion.
+    """
+    config = request.config
+    plugin_config = config.stash.get(PLUGIN_KEY, {})
+    
+    if not plugin_config.get("enabled"):
+        yield
+        return
+
+    if "PYTHON_LOG_PATH" in os.environ:
+        logger.warning(
+            "PYTHON_LOG_PATH is already set; pytest-capture-logs-on-fail plugin is disabled for this test."
+        )
+        yield
+        return
+
+    tmpdir = plugin_config.get(SESSION_TMPDIR_KEY)
+    if not tmpdir:
+        logger.warning("Session temp directory not initialized")
+        yield
+        return
+
+    test_name = sanitize_filename(request.node.nodeid)
+    log_file = tmpdir / f"{test_name}.log"
+    
+    original_log_path = os.environ.get("PYTHON_LOG_PATH")
+    os.environ["PYTHON_LOG_PATH"] = str(log_file)
+
+    logger.info(f"Logs for test '{request.node.nodeid}' will be stored at: {log_file}")
+
+    yield
+
+    setattr(request.node, "_pytest_log_file", str(log_file))
+    
+    if original_log_path is not None:
+        os.environ["PYTHON_LOG_PATH"] = original_log_path
+    else:
+        del os.environ["PYTHON_LOG_PATH"]
+
+
+def pytest_runtest_makereport(item: pytest.Item, call: pytest.CallInfo) -> None:
+    """Hook called after each test phase to create test reports.
+
+    On test failure, reads and prints the captured log file to stdout.
+    Handles failures in setup, call, and teardown phases.
+
+    Args:
+        item: The test item being reported on.
+        call: The call object containing execution info and any exception.
+    """
+    config = item.config
+    plugin_config = config.stash.get(PLUGIN_KEY, {})
+    
+    if not plugin_config.get("enabled"):
+        return
+
+    if call.excinfo is not None:
+        log_file = getattr(item, "_pytest_log_file", None)
+        if log_file and os.path.exists(log_file):
+            with open(log_file, "r") as f:
+                logs = f.read()
+            
+            if logs.strip():
+                phase = call.when
+                print(f"\n--- Captured logs for failed test ({phase}): {item.nodeid} ---\n{logs}\n")

structlog_config/stdlib_logging.py

@@ -11,7 +11,6 @@ from decouple import config
 
 from .constants import PYTHONASYNCIODEBUG
 from .env_config import get_custom_logger_config
-from .environments import is_production, is_staging
 from .levels import (
     compare_log_levels,
     get_environment_log_level_as_string,
@@ -49,14 +48,18 @@ def redirect_stdlib_loggers(json_logger: bool):
 
     default_processors = get_default_processors(json_logger=json_logger)
 
+    if json_logger:
+        # don't use ORJSON here, as the stdlib formatter chain expects a str not a bytes
+        final_renderer = structlog.processors.JSONRenderer(sort_keys=True)
+    else:
+        # use the default renderer, which is the last processor
+        final_renderer = default_processors[-1]
+
     formatter = ProcessorFormatter(
         processors=[
             # required to strip extra keys that the structlog stdlib bindings add in
             structlog.stdlib.ProcessorFormatter.remove_processors_meta,
-            default_processors[-1]
-            if not is_production() and not is_staging()
-            # don't use ORJSON here, as the stdlib formatter chain expects a str not a bytes
-            else structlog.processors.JSONRenderer(sort_keys=True),
+            final_renderer,
         ],
         # processors unique to stdlib logging
         foreign_pre_chain=[

structlog_config/trace.py

@@ -1,9 +1,11 @@
 """
+Adds a TRACE log level to the standard logging module and structlog.
+
+Some people believe that the standard log levels are not enough, and I'm with them.
+
 Adapted from:
 - https://github.com/willmcgugan/httpx/blob/973d1ed4e06577d928061092affe8f94def03331/httpx/_utils.py#L231
 - https://github.com/vladmandic/sdnext/blob/d5d857aa961edbc46c9e77e7698f2e60011e7439/installer.py#L154
-
-TODO this is not fully integrated into the codebase
 """
 
 import logging

{structlog_config-0.5.0.dist-info → structlog_config-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: structlog-config
-Version: 0.5.0
+Version: 0.7.0
 Summary: A comprehensive structlog configuration with sensible defaults for development and production environments, featuring context management, exception formatting, and path prettification.
 Keywords: logging,structlog,json-logging,structured-logging
 Author: Michael Bianco
@@ -9,8 +9,10 @@ Requires-Dist: orjson>=3.10.15
 Requires-Dist: python-decouple-typed>=3.11.0
 Requires-Dist: python-ipware>=3.0.0
 Requires-Dist: structlog>=25.2.0
-Requires-Python: >=3.10
+Requires-Dist: fastapi-ipware>=0.1.0 ; extra == 'fastapi'
+Requires-Python: >=3.11
 Project-URL: Repository, https://github.com/iloveitaly/structlog-config
+Provides-Extra: fastapi
 Description-Content-Type: text/markdown
 
 # Opinionated Defaults for Structlog
@@ -29,6 +31,18 @@ Here are the main goals:
 * Ability to log level and output (i.e. file path) *by logger* for easy development debugging
 * If you are using fastapi, structured logging for access logs
 
+## Installation
+
+```bash
+pip install structlog-config
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add structlog-config
+```
+
 ## Usage
 
 ```python
@@ -106,8 +120,68 @@ For example, if you wanted to [mimic `OPENAI_LOG` functionality](https://github.
 * `LOG_LEVEL_HTTPX=DEBUG`
 * `LOG_PATH_HTTPX=tmp/openai.log`
 
+## Custom Formatters
+
+This package includes several custom formatters that automatically clean up log output:
+
+### Path Prettifier
+
+Automatically formats `pathlib.Path` and `PosixPath` objects to show relative paths when possible, removing the wrapper class names:
+
+```python
+from pathlib import Path
+log.info("Processing file", file_path=Path.cwd() / "data" / "users.csv")
+# Output: file_path=data/users.csv (instead of PosixPath('/home/user/data/users.csv'))
+```
+
+### Whenever Datetime Formatter
+
+**Note:** Requires `pip install whenever` to be installed.
+
+Formats [whenever](https://github.com/ariebovenberg/whenever) datetime objects without their class wrappers for cleaner output:
+
+```python
+from whenever import ZonedDateTime
+
+log.info("Event scheduled", event_time=ZonedDateTime(2025, 11, 2, 0, 0, 0, tz="UTC"))
+# Output: event_time=2025-11-02T00:00:00+00:00[UTC]
+# Instead of: event_time=ZonedDateTime("2025-11-02T00:00:00+00:00[UTC]")
+```
+
+Supports all whenever datetime types: `ZonedDateTime`, `Instant`, `LocalDateTime`, `PlainDateTime`, etc.
+
+### ActiveModel Object Formatter
+
+**Note:** Requires `pip install activemodel` and `pip install typeid-python` to be installed.
+
+Automatically converts [ActiveModel](https://github.com/iloveitaly/activemodel) BaseModel instances to their ID representation and TypeID objects to strings:
+
+```python
+from activemodel import BaseModel
+
+user = User(id="user_123", name="Alice")
+log.info("User action", user=user)
+# Output: user_id=user_123 (instead of full object representation)
+```
+
+### FastAPI Context
+
+**Note:** Requires `pip install starlette-context` to be installed.
+
+Automatically includes all context data from [starlette-context](https://github.com/tomwojcik/starlette-context) in your logs, useful for request tracing:
+
+```python
+# Context data (request_id, correlation_id, etc.) automatically included in all logs
+log.info("Processing request")
+# Output includes: request_id=abc-123 correlation_id=xyz-789 ...
+```
+
+All formatters are optional and automatically enabled when their respective dependencies are installed. They work seamlessly in both development (console) and production (JSON) logging modes.
+
 ## FastAPI Access Logger
 
+**Note:** Requires `pip install structlog-config[fastapi]` for FastAPI dependencies.
+
 Structured, simple access log with request timing to replace the default fastapi access log. Why?
 
 1. It's less verbose
@@ -119,6 +193,74 @@ Here's how to use it:
 1. [Disable fastapi's default logging.](https://github.com/iloveitaly/python-starter-template/blob/f54cb47d8d104987f2e4a668f9045a62e0d6818a/main.py#L55-L56)
 2. [Add the middleware to your FastAPI app.](https://github.com/iloveitaly/python-starter-template/blob/f54cb47d8d104987f2e4a668f9045a62e0d6818a/app/routes/middleware/__init__.py#L63-L65)
 
+## Pytest Plugin: Capture Logs on Failure
+
+A pytest plugin that captures logs per-test and displays them only when tests fail. This keeps your test output clean while ensuring you have all the debugging information you need when something goes wrong.
+
+### Features
+
+- Only shows logs for failing tests (keeps output clean)
+- Captures logs from all test phases (setup, call, teardown)
+- Unique log file per test
+- Optional persistent log storage for debugging
+- Automatically handles `PYTHON_LOG_PATH` environment variable
+
+### Usage
+
+Enable the plugin with the `--capture-logs-on-fail` flag:
+
+```bash
+pytest --capture-logs-on-fail
+```
+
+Or enable it permanently in `pytest.ini` or `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+addopts = ["--capture-logs-on-fail"]
+```
+
+### Persist Logs to Directory
+
+To keep all test logs for later inspection (useful for CI/CD debugging):
+
+```bash
+pytest --capture-logs-dir=./test-logs
+```
+
+This creates a log file for each test and disables automatic cleanup.
+
+### How It Works
+
+1. Sets `PYTHON_LOG_PATH` environment variable to a unique temp file for each test
+2. Your application logs (via `configure_logger()`) write to this file
+3. On test failure, the plugin prints the captured logs to stdout
+4. Log files are cleaned up after the test session (unless `--capture-logs-dir` is used)
+
+### Example Output
+
+When a test fails, you'll see:
+
+```
+FAILED tests/test_user.py::test_user_login
+
+--- Captured logs for failed test (call): tests/test_user.py::test_user_login ---
+2025-11-01 18:30:00 [info] User login started user_id=123
+2025-11-01 18:30:01 [error] Database connection failed timeout=5.0
+```
+
+For passing tests, no log output is shown, keeping your test output clean and focused.
+
+## Beautiful Traceback Support
+
+Optional support for [beautiful-traceback](https://github.com/iloveitaly/beautiful-traceback) provides enhanced exception formatting with improved readability, smart coloring, path aliasing (e.g., `<pwd>`, `<site>`), and better alignment. Automatically activates when installed:
+
+```bash
+uv add beautiful-traceback --group dev
+```
+
+No configuration needed - just install and `configure_logger()` will use it automatically.
+
 ## iPython
 
 Often it's helpful to update logging level within an iPython session. You can do this and make sure all loggers pick up on it.

structlog_config-0.7.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+structlog_config/__init__.py,sha256=wTIMChYHwuzzgqoahCyF6YkJxjIYb-Gpyx8LkPkUpGk,6798
+structlog_config/constants.py,sha256=O1nPnB29yZdqqaI7aeTUrimA3LOtA5WpP6BGPLWJvj8,510
+structlog_config/env_config.py,sha256=_EJO0rgAKndRPSh4wuBaH3bui9F3nIpn8FaEkjAjZso,1737
+structlog_config/environments.py,sha256=JpZYVVDGxEf1EaKdPdn6Jo-4wJK6SqF0ueFl7e2TBvI,612
+structlog_config/fastapi_access_logger.py,sha256=CYZsww0AIcdfrU5Wgr6POwdJxJ5vMB96ttsYqoE30BU,4363
+structlog_config/formatters.py,sha256=KJ3PlkrFva1RKz5SmFmEwVCqJuHxq3Qsqhd9ezB983I,6715
+structlog_config/levels.py,sha256=LqXG4l01mIpxS2qI7PF_Vp9K7IrO0D5qU_x-Uo3LNuM,2372
+structlog_config/packages.py,sha256=xO4wHPIhAwGG6jv0kHdCr9NHpoIFx4VUeRzmztXp2is,591
+structlog_config/pytest_plugin.py,sha256=XBtef1KpuGV_RmXoWf13b0EUy69iAKMAk4-e5ZZnAuM,6819
+structlog_config/stdlib_logging.py,sha256=iHApYdsAs_ZC7Y8NpbKs23AHAJB1qLUCZPvFd-Nf_4I,7381
+structlog_config/trace.py,sha256=esSzTulaVr63H3iOYpHlU-NXPSwpEGS7GEYbv6Iq-3A,2118
+structlog_config/warnings.py,sha256=gKEcuHWqH0BaKitJtQkv-uJ0Z3uCH5nn6k8qpqjR-RM,998
+structlog_config-0.7.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+structlog_config-0.7.0.dist-info/METADATA,sha256=yjnflk2btwm0xBy-0xRjhe8lwXPmsdToMx2Kn2doylU,10994
+structlog_config-0.7.0.dist-info/RECORD,,

structlog_config-0.5.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-structlog_config/__init__.py,sha256=DyY4x3_dY_hPNbS1aM7JRCGadTa1dYDIPzgrHu3AP68,6733
-structlog_config/constants.py,sha256=O1nPnB29yZdqqaI7aeTUrimA3LOtA5WpP6BGPLWJvj8,510
-structlog_config/env_config.py,sha256=_EJO0rgAKndRPSh4wuBaH3bui9F3nIpn8FaEkjAjZso,1737
-structlog_config/environments.py,sha256=JpZYVVDGxEf1EaKdPdn6Jo-4wJK6SqF0ueFl7e2TBvI,612
-structlog_config/fastapi_access_logger.py,sha256=QuvteKBZGsEiVaPEpdpsK1jjCYEPKnhmsQDC89M2JKc,5452
-structlog_config/formatters.py,sha256=ll0Y0QeRs1DMmD-ft1n1zA4Vn2STRSK-mOrczYB2OjE,5898
-structlog_config/levels.py,sha256=LqXG4l01mIpxS2qI7PF_Vp9K7IrO0D5qU_x-Uo3LNuM,2372
-structlog_config/packages.py,sha256=asxrzLR-iRYAbkoSYutyTdIRcruTjHgkzfe2pjm2VFM,519
-structlog_config/stdlib_logging.py,sha256=Wnn59oRBIqn708CpR-akqVcG9ccSfCMLh56_7wxZRH0,7350
-structlog_config/trace.py,sha256=dBaSynxmw4Wg79wSHqYEMoByvv--v_oQw61dRdg4xUI,2016
-structlog_config/warnings.py,sha256=gKEcuHWqH0BaKitJtQkv-uJ0Z3uCH5nn6k8qpqjR-RM,998
-structlog_config-0.5.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
-structlog_config-0.5.0.dist-info/METADATA,sha256=d1CeOq9mFTIcBP80JKqnGZ_mEHud_5ooaI-6KDn51mM,6329
-structlog_config-0.5.0.dist-info/RECORD,,