mermaid-trace 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

mermaid_trace/handlers/async_handler.py

@@ -1,3 +1,11 @@
+"""
+Asynchronous Mermaid Handler Module
+
+This module provides a non-blocking logging handler that uses a background thread
+for writing logs. It's designed to improve performance in high-throughput applications
+by decoupling the logging I/O from the main execution thread.
+"""
+
 import logging
 import logging.handlers
 import queue
@@ -12,41 +20,86 @@ class AsyncMermaidHandler(logging.handlers.QueueHandler):
     This handler pushes log records to a queue, which are then picked up by a
     QueueListener running in a separate thread and dispatched to the actual
     handlers (e.g., MermaidFileHandler).
+
+    This architecture provides several benefits:
+    - Main thread doesn't block waiting for disk I/O
+    - Logs are processed in the background
+    - Better performance in high-throughput applications
+    - Smooth handling of burst traffic
     """
 
-    def __init__(self, handlers: List[logging.Handler], queue_size: int = -1):
+    def __init__(self, handlers: List[logging.Handler], queue_size: int = 1000):
         """
         Initialize the async handler.
-        
+
         Args:
             handlers: A list of handlers that should receive the logs from the queue.
-                      (e.g., [MermaidFileHandler(...)])
-            queue_size: The maximum size of the queue. -1 means infinite.
+                      These are typically MermaidFileHandler instances.
+            queue_size: The maximum size of the queue. Default is 1000.
+                       If the queue fills up, new log records may be dropped.
         """
+        # Create a bounded queue with the specified size
         self._log_queue: queue.Queue[logging.LogRecord] = queue.Queue(queue_size)
+        self._queue_size = queue_size
+
+        # Initialize parent QueueHandler with our queue
         super().__init__(self._log_queue)
-        
-        # Initialize QueueListener
+
+        # Initialize QueueListener to process records from the queue
         # It starts an internal thread to monitor the queue
         # respect_handler_level=True ensures the target handlers' log levels are respected
-        self._listener: Optional[logging.handlers.QueueListener] = logging.handlers.QueueListener(
-            self._log_queue, 
-            *handlers, 
-            respect_handler_level=True
+        self._listener: Optional[logging.handlers.QueueListener] = (
+            logging.handlers.QueueListener(
+                self._log_queue, *handlers, respect_handler_level=True
+            )
         )
+
+        # Start the listener thread
         self._listener.start()
-        
-        # Ensure the listener is stopped and queue is flushed upon exit
-        # This prevents lost logs at program termination
+
+        # Register stop method to be called on program exit
+        # This ensures all pending logs are written to disk before termination
         atexit.register(self.stop)
 
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Emit a log record to the queue with a timeout and drop policy.
+
+        If the queue is full, this method will attempt to put the record with
+        a short timeout. If that fails, it will drop the record and print a warning.
+
+        Args:
+            record: The log record to emit
+        """
+        from typing import cast
+
+        try:
+            # Try to put the record in the queue with a short timeout (0.1 seconds)
+            # This prevents the main thread from blocking indefinitely if the queue is full
+            # Use cast to tell Mypy this is a queue.Queue instance
+            queue_instance = cast(queue.Queue[logging.LogRecord], self.queue)
+            queue_instance.put(record, block=True, timeout=0.1)
+        except queue.Full:
+            # If queue is full, log a warning and drop the record
+            if record.levelno >= logging.WARNING:
+                # Avoid infinite recursion by not using self.logger
+                print(
+                    f"WARNING: AsyncMermaidHandler queue is full (size: {self._queue_size}), dropping log record: {record.msg}"
+                )
+
     def stop(self) -> None:
         """
-        Stops the listener and flushes the queue.
+        Stops the listener and flushes all pending logs from the queue.
 
-        This is registered with `atexit` to ensure that all pending logs
+        This method is registered with `atexit` to ensure that all pending logs
         are written to disk before the application terminates.
         """
         if self._listener:
-            self._listener.stop()
-            self._listener = None
+            try:
+                # Stop the listener - this will process all remaining records in the queue
+                self._listener.stop()
+                self._listener = None
+            except queue.Full:
+                # Handle case where queue is full when trying to put sentinel value
+                # The listener thread may still be processing, but we can safely exit
+                pass

mermaid_trace/handlers/mermaid_handler.py

@@ -1,3 +1,11 @@
+"""
+Mermaid File Handler Module
+
+This module provides a custom logging handler that writes FlowEvent objects to
+Mermaid (.mmd) files. It handles the Mermaid syntax formatting, file headers, and
+ensures thread-safe file writing.
+"""
+
 import logging
 import os
 
@@ -26,24 +34,23 @@ class MermaidFileHandler(logging.FileHandler):
         delay: bool = False,
     ):
         """
-        Initialize the handler.
+        Initialize the Mermaid file handler.
 
         Args:
             filename (str): The path to the output .mmd file.
-            title (str): The title of the Mermaid diagram (written in the header).
-            mode (str): File open mode. 'w' (overwrite) or 'a' (append).
-            encoding (str): File encoding. Defaults to 'utf-8'.
-            delay (bool): If True, file opening is deferred until the first call to emit.
-                          Useful to avoid creating empty files if no logs occur.
+            title (str, optional): The title of the Mermaid diagram. Defaults to "Log Flow".
+            mode (str, optional): File open mode. 'w' (overwrite) or 'a' (append). Defaults to "a".
+            encoding (str, optional): File encoding. Defaults to "utf-8".
+            delay (bool, optional): If True, file opening is deferred until the first call to emit.
+                                   Useful to avoid creating empty files if no logs occur. Defaults to False.
         """
-        # Ensure directory exists to prevent FileNotFoundError on open
+        # Ensure the directory exists to prevent FileNotFoundError when opening the file
         os.makedirs(os.path.dirname(os.path.abspath(filename)) or ".", exist_ok=True)
 
-        # Header Strategy:
-        # We need to write the "sequenceDiagram" preamble ONLY if:
-        # 1. We are overwriting the file (mode='w').
-        # 2. We are appending (mode='a'), but the file doesn't exist or is empty.
-        # This prevents invalid Mermaid files (e.g., multiple "sequenceDiagram" lines).
+        # Determine if we need to write a header
+        # Header is written only if:
+        # 1. We are overwriting the file (mode='w'), or
+        # 2. We are appending (mode='a') but the file doesn't exist or is empty
         should_write_header = False
         if mode == "w":
             should_write_header = True
@@ -51,49 +58,62 @@ class MermaidFileHandler(logging.FileHandler):
             if not os.path.exists(filename) or os.path.getsize(filename) == 0:
                 should_write_header = True
 
-        # Initialize standard FileHandler (opens the file unless delay=True)
+        # Initialize the parent FileHandler (opens the file unless delay=True)
         super().__init__(filename, mode, encoding, delay)
         self.title = title
 
-        # Write header immediately if needed.
+        # Write the header immediately if needed
         if should_write_header:
             self._write_header()
 
     def _write_header(self) -> None:
         """
-        Writes the initial Mermaid syntax lines.
+        Writes the initial Mermaid syntax lines to the file.
+
+        This setup is required for Mermaid JS or Live Editor to render the diagram correctly.
+        It defines:
+        - Diagram type (sequenceDiagram)
+        - Title of the diagram
+        - Autonumbering of steps
 
-        This setup is required for Mermaid JS or Live Editor to render the diagram.
-        It defines the diagram type (sequenceDiagram), title, and enables autonumbering.
+        Thread Safety: Uses the handler's internal lock to prevent concurrent writes
+        when delay=True, ensuring the header is written only once.
         """
-        # We use the stream directly if available, or open momentarily if delayed
-        if self.stream:
-            self.stream.write("sequenceDiagram\n")
-            self.stream.write(f"    title {self.title}\n")
-            self.stream.write("    autonumber\n")
-            # Flush ensures the header is written to disk immediately,
-            # so it appears even if the program crashes right after.
-            self.flush()
-        else:
-            # Handling 'delay=True' case:
-            # If the file isn't open yet, we temporarily open it just to write the header.
-            # This ensures the file is valid even if the application crashes before the first log.
-            with open(self.baseFilename, self.mode, encoding=self.encoding) as f:
-                f.write("sequenceDiagram\n")
-                f.write(f"    title {self.title}\n")
-                f.write("    autonumber\n")
+        # Use the handler's internal lock to ensure thread safety
+        assert self.lock is not None, "Handler lock should always be initialized"
+        with self.lock:
+            # Write to the existing stream if available, otherwise open temporarily
+            if self.stream:
+                # Stream is already open (delay=False or emit() has been called)
+                self.stream.write("sequenceDiagram\n")
+                self.stream.write(f"    title {self.title}\n")
+                self.stream.write("    autonumber\n")
+                # Flush ensures the header is written to disk immediately
+                self.flush()
+            else:
+                # Handle delay=True case: file not yet opened
+                # Temporarily open the file just to write the header
+                with open(self.baseFilename, self.mode, encoding=self.encoding) as f:
+                    f.write("sequenceDiagram\n")
+                    f.write(f"    title {self.title}\n")
+                    f.write("    autonumber\n")
 
     def emit(self, record: logging.LogRecord) -> None:
         """
-        Process a log record.
+        Process a log record and write it to the Mermaid file.
+
+        This method overrides the parent's emit method to filter out non-FlowEvent records.
 
         Optimization:
-        - Checks for `flow_event` attribute first. This allows this handler
-          to be attached to the root logger without processing irrelevant system logs.
-          It acts as a high-performance filter before formatting.
-        - Delegates the actual writing to `super().emit()`, which handles
-          thread locking and stream flushing safely.
+        - Checks for `flow_event` attribute first, acting as a high-performance filter
+        - Only processes records containing structured FlowEvent data
+        - Delegates actual writing to parent's emit() method, which handles locking and flushing
+
+        Args:
+            record (logging.LogRecord): The log record to process
         """
         # Only process records that contain our structured FlowEvent data
+        # This allows the handler to be attached to the root logger without processing
+        # irrelevant system logs
         if hasattr(record, "flow_event"):
             super().emit(record)

mermaid_trace/integrations/fastapi.py

@@ -1,3 +1,11 @@
+"""
+FastAPI Integration Module
+
+This module provides middleware for integrating MermaidTrace with FastAPI applications.
+It automatically traces HTTP requests and responses, converting them into Mermaid
+sequence diagram events.
+"""
+
 from typing import Any, TYPE_CHECKING
 import time
 import uuid
@@ -6,20 +14,23 @@ from ..core.events import FlowEvent
 from ..core.context import LogContext
 from ..core.decorators import get_flow_logger
 
+# Conditional imports to support optional FastAPI dependency
 if TYPE_CHECKING:
+    # For type checking only, import the actual FastAPI/Starlette types
     from fastapi import Request, Response
     from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 else:
     try:
+        # Try to import FastAPI/Starlette at runtime
         from fastapi import Request, Response
         from starlette.middleware.base import (
             BaseHTTPMiddleware,
             RequestResponseEndpoint,
         )
     except ImportError:
-        # Handle the case where FastAPI/Starlette are not installed.
-        # We define dummy types to prevent NameErrors at import time,
-        # but instantiation will fail explicitly in __init__.
+        # Handle the case where FastAPI/Starlette are not installed
+        # Define dummy types to prevent NameErrors at import time
+        # Instantiation will fail explicitly in __init__
         BaseHTTPMiddleware = object  # type: ignore[misc,assignment]
         Request = Any  # type: ignore[assignment]
         Response = Any  # type: ignore[assignment]
@@ -30,11 +41,12 @@ class MermaidTraceMiddleware(BaseHTTPMiddleware):
     """
     FastAPI Middleware to trace HTTP requests as interactions in the sequence diagram.
 
-    This middleware acts as the entry point for tracing a web request. It:
-    1. Identifies the client (Source).
-    2. Logs the incoming request.
-    3. Initializes the `LogContext` for the request lifecycle.
-    4. Logs the response or error.
+    This middleware acts as the entry point for tracing web requests, handling:
+    1. Identification of the client (Source participant)
+    2. Logging of incoming requests
+    3. Initialization of the `LogContext` for the request lifecycle
+    4. Logging of responses or errors
+    5. Cleanup of context after request completion
     """
 
     def __init__(self, app: Any, app_name: str = "FastAPI"):
@@ -42,13 +54,19 @@ class MermaidTraceMiddleware(BaseHTTPMiddleware):
         Initialize the middleware.
 
         Args:
-            app: The FastAPI application instance.
-            app_name: The name of this service to appear in the diagram (e.g., "UserAPI").
+            app: The FastAPI application instance
+            app_name: The name of this service to appear in the diagram (e.g., "UserAPI")
+
+        Raises:
+            ImportError: If FastAPI/Starlette are not installed
         """
+        # Check if FastAPI is installed by verifying BaseHTTPMiddleware is not our dummy object
         if BaseHTTPMiddleware is object:  # type: ignore[comparison-overlap]
             raise ImportError(
                 "FastAPI/Starlette is required to use MermaidTraceMiddleware"
             )
+
+        # Initialize the parent BaseHTTPMiddleware
         super().__init__(app)
         self.app_name = app_name
 
@@ -56,31 +74,35 @@ class MermaidTraceMiddleware(BaseHTTPMiddleware):
         self, request: Request, call_next: RequestResponseEndpoint
     ) -> Response:
         """
-        Intercepts the incoming request.
+        Intercepts and processes incoming HTTP requests.
+
+        This method is called for each incoming request and handles the full
+        request-response cycle tracing.
 
         Args:
-            request (Request): The incoming HTTP request.
-            call_next (Callable): The function to call the next middleware or endpoint.
+            request (Request): The incoming HTTP request object
+            call_next (RequestResponseEndpoint): Function to call the next middleware or endpoint
 
         Returns:
-            Response: The HTTP response.
+            Response: The HTTP response object
         """
-        # 1. Determine Source (Client)
-        # Try to get a specific ID from headers (useful for distributed tracing),
-        # otherwise fallback to "Client".
+        # 1. Determine Source (Client participant)
+        # Try to get a specific ID from X-Source header (useful for distributed tracing),
+        # otherwise fallback to "Client"
         source = request.headers.get("X-Source", "Client")
 
-        # Determine Trace ID
-        # Check X-Trace-ID header or generate new UUID
+        # 2. Determine Trace ID
+        # Check for X-Trace-ID header (for distributed tracing) or generate new UUID
         trace_id = request.headers.get("X-Trace-ID") or str(uuid.uuid4())
 
-        # 2. Determine Action
-        # Format: "METHOD /path" (e.g., "GET /users")
+        # 3. Determine Action name
+        # Format: "METHOD /path" (e.g., "GET /users", "POST /items")
         action = f"{request.method} {request.url.path}"
 
         logger = get_flow_logger()
 
-        # 3. Log Request (Source -> App)
+        # 4. Log Request (Source -> App)
+        # Create and log the initial request event
         req_event = FlowEvent(
             source=source,
             target=self.app_name,
@@ -93,21 +115,20 @@ class MermaidTraceMiddleware(BaseHTTPMiddleware):
             f"{source}->{self.app_name}: {action}", extra={"flow_event": req_event}
         )
 
-        # 4. Set Context and Process Request
-        # We set the current participant to the app name.
-        # `ascope` ensures this context applies to all code running within `call_next`.
-        # This includes route handlers, dependencies, and other middlewares called after this one.
+        # 5. Set Context and Process Request
+        # Use async context manager to set the current participant to the app name
+        # This context will be inherited by all code called within call_next()
         async with LogContext.ascope(
             {"participant": self.app_name, "trace_id": trace_id}
         ):
             start_time = time.time()
             try:
-                # Pass control to the application
-                # This executes the actual route logic
+                # Pass control to the next middleware or endpoint
+                # This executes the actual route logic and returns the response
                 response = await call_next(request)
 
-                # 5. Log Response (App -> Source)
-                # Calculate execution duration for the response label
+                # 6. Log Success Response (App -> Source)
+                # Calculate execution duration in milliseconds
                 duration = (time.time() - start_time) * 1000
                 resp_event = FlowEvent(
                     source=self.app_name,
@@ -125,10 +146,9 @@ class MermaidTraceMiddleware(BaseHTTPMiddleware):
                 return response
 
             except Exception as e:
-                # 6. Log Error (App --x Source)
+                # 7. Log Error Response (App --x Source)
                 # This captures unhandled exceptions that bubble up to the middleware
-                # Note: FastAPI's ExceptionHandlers might catch this before it reaches here.
-                # If so, you might see a successful return with 500 status instead.
+                # Note: FastAPI's ExceptionHandlers might catch some exceptions before they reach here
                 err_event = FlowEvent(
                     source=self.app_name,
                     target=source,
@@ -142,4 +162,5 @@ class MermaidTraceMiddleware(BaseHTTPMiddleware):
                 logger.error(
                     f"{self.app_name}-x{source}: Error", extra={"flow_event": err_event}
                 )
+                # Re-raise the exception to maintain normal error handling flow
                 raise

{mermaid_trace-0.4.0.dist-info → mermaid_trace-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mermaid-trace
-Version: 0.4.0
+Version: 0.4.1
 Summary: Visualize your Python code execution flow as Mermaid Sequence Diagrams.
 Project-URL: Documentation, https://github.com/xt765/mermaid-trace#readme
 Project-URL: Changelog, https://github.com/xt765/mermaid-trace/blob/main/docs/en/CHANGELOG.md
@@ -63,17 +63,31 @@ Description-Content-Type: text/markdown
 
 # MermaidTrace: The Python Logger That Draws Diagrams
 
-[![PyPI version](https://img.shields.io/pypi/v/mermaid-trace.svg?style=flat-square)](https://pypi.org/project/mermaid-trace/)
-[![Python Versions](https://img.shields.io/pypi/pyversions/mermaid-trace.svg?style=flat-square)](https://pypi.org/project/mermaid-trace/)
+🌐 **Language**: [English](README.md) | [中文](README_CN.md)
+
+[![PyPI version](https://img.shields.io/pypi/v/mermaid-trace.svg?style=flat-square&color=blue)](https://pypi.org/project/mermaid-trace/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/mermaid-trace.svg?style=flat-square&color=blue)](https://pypi.org/project/mermaid-trace/)
 [![License](https://img.shields.io/github/license/xt765/mermaid-trace?style=flat-square)](LICENSE)
 [![CI Status](https://img.shields.io/github/actions/workflow/status/xt765/mermaid-trace/ci.yml?style=flat-square&label=CI)](https://github.com/xt765/mermaid-trace/actions/workflows/ci.yml)
 [![Codecov](https://img.shields.io/codecov/c/github/xt765/mermaid-trace?style=flat-square&logo=codecov)](https://codecov.io/gh/xt765/mermaid-trace)
 
+---
+
+## 📋 Overview
+
 **Stop reading logs. Start watching them.**
 
 MermaidTrace is a specialized logging tool that automatically generates [Mermaid JS](https://mermaid.js.org/) sequence diagrams from your code execution. It's perfect for visualizing complex business logic, microservice interactions, or asynchronous flows.
 
-## ✨ Features
+---
+
+## 📚 Documentation
+
+[User Guide](docs/en/USER_GUIDE.md) · [API Reference](docs/en/API.md) · [Contributing Guidelines](docs/en/CONTRIBUTING.md) · [Changelog](docs/en/CHANGELOG.md) · [License](docs/en/LICENSE)
+
+---
+
+## ✨ Key Features
 
 - **Decorator-Driven**: Just add `@trace` or `@trace_interaction` to your functions.
 - **Auto-Diagramming**: Generates `.mmd` files that can be viewed in VS Code, GitHub, or Mermaid Live Editor.
@@ -82,6 +96,8 @@ MermaidTrace is a specialized logging tool that automatically generates [Mermaid
 - **FastAPI Integration**: Includes middleware for zero-config HTTP request tracing.
 - **CLI Tool**: Built-in viewer to preview diagrams in your browser.
 
+---
+
 ## 🚀 Quick Start
 
 ### Installation
@@ -151,15 +167,14 @@ Visualize your generated `.mmd` files instantly:
 mermaid-trace serve my_flow.mmd
 ```
 
-## 📂 Documentation
-
-- [English Documentation](docs/en/USER_GUIDE.md)
-- [中文文档](README_CN.md)
+---
 
 ## 🤝 Contributing
 
 We welcome contributions! Please see [CONTRIBUTING.md](docs/en/CONTRIBUTING.md) for details.
 
+---
+
 ## 📄 License
 
 MIT

mermaid_trace-0.4.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+mermaid_trace/__init__.py,sha256=ZXviz2KlX0eER7FPZJG2edsXfyDewt5iXpfGMifBoyE,5323
+mermaid_trace/cli.py,sha256=w7xh9kvyaokcUcuwIsBAtgwcl9zW8mosXesp5e0CtHg,11224
+mermaid_trace/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mermaid_trace/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mermaid_trace/core/context.py,sha256=wr-Ys3c6PsYCtbPUsQTrnaciSkP-fofxOewo4oZ27QM,8556
+mermaid_trace/core/decorators.py,sha256=lNNx_Qj2cDJkPX67qPl3NBH946ofoJ8osqxq3oBoCgU,16164
+mermaid_trace/core/events.py,sha256=h1g8uk1SGUj_NzefuJXYrkWO8ZuezeFjfU8IpYILnB8,5977
+mermaid_trace/core/formatter.py,sha256=A9ULgcu3xHiG3iD6k54sQ7nm9kHceMvplVCHw_nu09I,5259
+mermaid_trace/handlers/async_handler.py,sha256=Cbs6ZuKywf2VWwSIPNRXFOtoPArIhoYl-QHeW05hhWg,4272
+mermaid_trace/handlers/mermaid_handler.py,sha256=rF-S3IXsMvTS-6kgGN7By-_2kqlCyMwcNgaorlci1Q8,5137
+mermaid_trace/integrations/fastapi.py,sha256=H9Hl2pFxdbM3NwqONyJ7kAP-oGdOOnuoG3hEEbpoOjE,6487
+mermaid_trace-0.4.1.dist-info/METADATA,sha256=JLDyn-TuDnehsO34g6GAArjIl-XN4izSVZIVulmiu6c,6539
+mermaid_trace-0.4.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mermaid_trace-0.4.1.dist-info/entry_points.txt,sha256=WS57KT_870v0A4B87QDjQUqJcddMQxbCQyYeczDAX34,57
+mermaid_trace-0.4.1.dist-info/licenses/LICENSE,sha256=BrBog1Etiq9PdWy0SVQNVByIMD9ss4Edz-R0oXt49zA,1062
+mermaid_trace-0.4.1.dist-info/RECORD,,

mermaid_trace-0.4.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-mermaid_trace/__init__.py,sha256=yhc-shETKioVEQEfqmCGFyVelRR3_ypeClbMR_D2oBQ,5267
-mermaid_trace/cli.py,sha256=F5-QfnKp_Et719IKWvU5IAWZTpq9ft01ow62DqNpHdA,9477
-mermaid_trace/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mermaid_trace/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mermaid_trace/core/context.py,sha256=WyTKbC_I1ge802VUj9PdUiqa-VgL1r3DQUW_y8PlG8M,6618
-mermaid_trace/core/decorators.py,sha256=13-n6qsmWnInpKgQ0Bgnnn5aQIWkRZ7raTD2xVtKVmU,12303
-mermaid_trace/core/events.py,sha256=TVtarp7IwfTR_C404ZWoyqBZmTtScROz5hWL0uel3G4,2857
-mermaid_trace/core/formatter.py,sha256=6k79eBU09TSCEUcDJN1mfn-_KMld0xXfKtQTKZb8Ogw,3178
-mermaid_trace/handlers/async_handler.py,sha256=uGC27TCgfxyvQQEiJ_7Ir1EFJdsLHBUzHEsLktEaFtM,1893
-mermaid_trace/handlers/mermaid_handler.py,sha256=JUq5gSQepNISreUYkyucS_rk27zGIiwSYFw_Lb8lL28,4314
-mermaid_trace/integrations/fastapi.py,sha256=GJL2H0Ypi4HqiAR-kkV4kSUTitdOj4RkhPi26GGNORM,5515
-mermaid_trace-0.4.0.dist-info/METADATA,sha256=4oszQifzCHhgCEI0Ly1nKAUuvcF-Bs-ejCReGUOsTbo,6287
-mermaid_trace-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mermaid_trace-0.4.0.dist-info/entry_points.txt,sha256=WS57KT_870v0A4B87QDjQUqJcddMQxbCQyYeczDAX34,57
-mermaid_trace-0.4.0.dist-info/licenses/LICENSE,sha256=BrBog1Etiq9PdWy0SVQNVByIMD9ss4Edz-R0oXt49zA,1062
-mermaid_trace-0.4.0.dist-info/RECORD,,