mojentic 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

_examples/tracer_qt_viewer.py

@@ -0,0 +1,394 @@
+"""
+Real-time Tracer Event Viewer with Qt GUI.
+
+This example demonstrates how to use the tracer system with a Qt GUI that displays
+tracer events in real-time as they occur. Users can click on events to see detailed
+information.
+
+Requirements:
+    pip install PyQt6
+
+Usage:
+    python tracer_qt_viewer.py
+"""
+import sys
+import uuid
+from datetime import datetime
+from typing import Optional
+
+try:
+    from PyQt6.QtWidgets import (
+        QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+        QTableWidget, QTableWidgetItem, QTextEdit, QPushButton, QLabel,
+        QHeaderView, QSplitter
+    )
+    from PyQt6.QtCore import Qt, QTimer, pyqtSignal, QObject, QThread
+    from PyQt6.QtGui import QColor, QFont
+except ImportError:
+    print("Error: PyQt6 is required for this example.")
+    print("Install it with: pip install PyQt6")
+    sys.exit(1)
+
+from mojentic.tracer import TracerSystem, EventStore
+from mojentic.tracer.tracer_events import (
+    TracerEvent, LLMCallTracerEvent, LLMResponseTracerEvent,
+    ToolCallTracerEvent, AgentInteractionTracerEvent
+)
+from mojentic.llm import LLMBroker
+from mojentic.llm.tools.date_resolver import ResolveDateTool
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+
+
+class EventSignaler(QObject):
+    """Qt signal emitter for tracer events (needed for thread safety)."""
+    event_occurred = pyqtSignal(object)
+
+
+class LLMWorker(QThread):
+    """Worker thread for running LLM queries without blocking the UI."""
+
+    finished = pyqtSignal(str)  # Emits response when complete
+    error = pyqtSignal(str)  # Emits error message if something goes wrong
+
+    def __init__(self, tracer: TracerSystem):
+        super().__init__()
+        self.tracer = tracer
+
+    def run(self):
+        """Execute the LLM query in a background thread."""
+        try:
+            # Create LLM broker with our tracer
+            llm_broker = LLMBroker(model="qwen3:32b", tracer=self.tracer)
+
+            # Create a date resolver tool
+            date_tool = ResolveDateTool(tracer=self.tracer)
+
+            # Generate a correlation ID for this request
+            correlation_id = str(uuid.uuid4())
+
+            # Create a test query
+            messages = [
+                LLMMessage(role=MessageRole.User, content="What is the date next Friday?")
+            ]
+
+            # Execute the query (this will generate tracer events)
+            response = llm_broker.generate(
+                messages,
+                tools=[date_tool],
+                correlation_id=correlation_id
+            )
+
+            self.finished.emit(response)
+
+        except Exception as e:
+            self.error.emit(str(e))
+
+
+class TracerViewer(QMainWindow):
+    """Qt window that displays tracer events in real-time."""
+    
+    def __init__(self):
+        super().__init__()
+        self.events = []
+        self.event_signaler = EventSignaler()
+        self.event_signaler.event_occurred.connect(self.add_event_to_table)
+        self.worker = None  # Track the worker thread
+
+        self.setWindowTitle("Mojentic Tracer - Real-time Event Viewer")
+        self.setGeometry(100, 100, 1200, 700)
+
+        self._setup_ui()
+        self._setup_tracer()
+        
+    def _setup_ui(self):
+        """Setup the user interface."""
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QVBoxLayout(central_widget)
+        
+        # Title and controls
+        header_layout = QHBoxLayout()
+        title_label = QLabel("Real-time Tracer Events")
+        title_font = QFont()
+        title_font.setPointSize(14)
+        title_font.setBold(True)
+        title_label.setFont(title_font)
+        header_layout.addWidget(title_label)
+        
+        header_layout.addStretch()
+        
+        self.clear_button = QPushButton("Clear Events")
+        self.clear_button.clicked.connect(self.clear_events)
+        header_layout.addWidget(self.clear_button)
+        
+        self.test_button = QPushButton("Run Test Query")
+        self.test_button.clicked.connect(self.run_test_query)
+        header_layout.addWidget(self.test_button)
+        
+        main_layout.addLayout(header_layout)
+        
+        # Event counter
+        self.event_count_label = QLabel("Events: 0")
+        main_layout.addWidget(self.event_count_label)
+        
+        # Splitter for table and details
+        splitter = QSplitter(Qt.Orientation.Vertical)
+        
+        # Events table
+        self.events_table = QTableWidget()
+        self.events_table.setColumnCount(5)
+        self.events_table.setHorizontalHeaderLabels([
+            "Time", "Type", "Correlation ID", "Summary", "Duration (ms)"
+        ])
+        self.events_table.horizontalHeader().setSectionResizeMode(
+            3, QHeaderView.ResizeMode.Stretch
+        )
+        self.events_table.setSelectionBehavior(
+            QTableWidget.SelectionBehavior.SelectRows
+        )
+        self.events_table.setEditTriggers(
+            QTableWidget.EditTrigger.NoEditTriggers
+        )
+        self.events_table.itemSelectionChanged.connect(self.show_event_details)
+        splitter.addWidget(self.events_table)
+        
+        # Event details panel
+        details_widget = QWidget()
+        details_layout = QVBoxLayout(details_widget)
+        details_label = QLabel("Event Details (click an event to see details)")
+        details_label.setFont(QFont("", 10, QFont.Weight.Bold))
+        details_layout.addWidget(details_label)
+        
+        self.details_text = QTextEdit()
+        self.details_text.setReadOnly(True)
+        self.details_text.setFont(QFont("Courier", 9))
+        details_layout.addWidget(self.details_text)
+        
+        splitter.addWidget(details_widget)
+        splitter.setSizes([400, 300])
+        
+        main_layout.addWidget(splitter)
+        
+        # Status bar
+        self.statusBar().showMessage("Ready. Waiting for tracer events...")
+        
+    def _setup_tracer(self):
+        """Setup the tracer system with callback."""
+        def on_event_stored(event):
+            """Callback when an event is stored."""
+            if isinstance(event, TracerEvent):
+                self.event_signaler.event_occurred.emit(event)
+        
+        event_store = EventStore(on_store_callback=on_event_stored)
+        self.tracer = TracerSystem(event_store=event_store)
+        
+    def add_event_to_table(self, event: TracerEvent):
+        """Add a new event to the table."""
+        self.events.append(event)
+        
+        row = self.events_table.rowCount()
+        self.events_table.insertRow(row)
+        
+        # Time
+        time_str = datetime.fromtimestamp(event.timestamp).strftime("%H:%M:%S.%f")[:-3]
+        time_item = QTableWidgetItem(time_str)
+        self.events_table.setItem(row, 0, time_item)
+        
+        # Type
+        event_type = type(event).__name__.replace("TracerEvent", "")
+        type_item = QTableWidgetItem(event_type)
+        
+        # Color code by type
+        if isinstance(event, LLMCallTracerEvent):
+            type_item.setBackground(QColor(107, 182, 96, 50))  # Mojility green
+        elif isinstance(event, LLMResponseTracerEvent):
+            type_item.setBackground(QColor(107, 182, 96, 100))
+        elif isinstance(event, ToolCallTracerEvent):
+            type_item.setBackground(QColor(102, 103, 103, 50))  # Mojility grey
+        elif isinstance(event, AgentInteractionTracerEvent):
+            type_item.setBackground(QColor(100, 149, 237, 50))  # Blue
+        
+        self.events_table.setItem(row, 1, type_item)
+        
+        # Correlation ID (shortened)
+        corr_id_short = event.correlation_id[:8] if event.correlation_id else "N/A"
+        corr_item = QTableWidgetItem(corr_id_short)
+        corr_item.setToolTip(event.correlation_id)
+        self.events_table.setItem(row, 2, corr_item)
+        
+        # Summary
+        summary = self._get_event_summary(event)
+        summary_item = QTableWidgetItem(summary)
+        self.events_table.setItem(row, 3, summary_item)
+        
+        # Duration
+        duration = ""
+        if isinstance(event, (LLMResponseTracerEvent, ToolCallTracerEvent)) and event.call_duration_ms:
+            duration = f"{event.call_duration_ms:.0f}"
+        duration_item = QTableWidgetItem(duration)
+        self.events_table.setItem(row, 4, duration_item)
+        
+        # Scroll to bottom and update counter
+        self.events_table.scrollToBottom()
+        self.event_count_label.setText(f"Events: {len(self.events)}")
+        self.statusBar().showMessage(f"New event: {event_type}")
+        
+    def _get_event_summary(self, event: TracerEvent) -> str:
+        """Get a brief summary of the event."""
+        if isinstance(event, LLMCallTracerEvent):
+            return f"Model: {event.model}, Messages: {len(event.messages)}"
+        elif isinstance(event, LLMResponseTracerEvent):
+            content_preview = event.content[:50] + "..." if len(event.content) > 50 else event.content
+            return f"Model: {event.model}, Response: {content_preview}"
+        elif isinstance(event, ToolCallTracerEvent):
+            return f"Tool: {event.tool_name}, Caller: {event.caller or 'N/A'}"
+        elif isinstance(event, AgentInteractionTracerEvent):
+            return f"From: {event.from_agent} → To: {event.to_agent}"
+        return "Unknown event type"
+    
+    def show_event_details(self):
+        """Show detailed information about the selected event."""
+        selected_rows = self.events_table.selectedIndexes()
+        if not selected_rows:
+            return
+        
+        row = selected_rows[0].row()
+        if row >= len(self.events):
+            return
+        
+        event = self.events[row]
+        details = self._format_event_details(event)
+        self.details_text.setPlainText(details)
+        
+    def _format_event_details(self, event: TracerEvent) -> str:
+        """Format detailed event information."""
+        details = []
+        details.append(f"Event Type: {type(event).__name__}")
+        details.append(f"Timestamp: {datetime.fromtimestamp(event.timestamp)}")
+        details.append(f"Correlation ID: {event.correlation_id}")
+        details.append(f"Source: {event.source}")
+        details.append("")
+        
+        if isinstance(event, LLMCallTracerEvent):
+            details.append("=== LLM Call Details ===")
+            details.append(f"Model: {event.model}")
+            details.append(f"Temperature: {event.temperature}")
+            details.append(f"Number of Messages: {len(event.messages)}")
+            details.append("")
+            details.append("Messages:")
+            for i, msg in enumerate(event.messages, 1):
+                details.append(f"  {i}. Role: {msg.get('role', 'N/A')}")
+                content = msg.get('content', 'N/A')
+                if len(str(content)) > 200:
+                    content = str(content)[:200] + "..."
+                details.append(f"     Content: {content}")
+            if event.tools:
+                details.append("")
+                details.append(f"Available Tools: {[t.get('name') for t in event.tools]}")
+        
+        elif isinstance(event, LLMResponseTracerEvent):
+            details.append("=== LLM Response Details ===")
+            details.append(f"Model: {event.model}")
+            details.append(f"Call Duration: {event.call_duration_ms:.2f} ms" if event.call_duration_ms else "N/A")
+            details.append("")
+            details.append("Response Content:")
+            details.append(event.content)
+            if event.tool_calls:
+                details.append("")
+                details.append(f"Tool Calls Made: {len(event.tool_calls)}")
+                for i, tc in enumerate(event.tool_calls, 1):
+                    details.append(f"  {i}. {tc}")
+        
+        elif isinstance(event, ToolCallTracerEvent):
+            details.append("=== Tool Call Details ===")
+            details.append(f"Tool Name: {event.tool_name}")
+            details.append(f"Caller: {event.caller or 'N/A'}")
+            details.append(f"Call Duration: {event.call_duration_ms:.2f} ms" if event.call_duration_ms else "Duration: N/A")
+            details.append("")
+            details.append("Arguments:")
+            details.append(f"  {event.arguments}")
+            details.append("")
+            details.append("Result:")
+            details.append(f"  {event.result}")
+        
+        elif isinstance(event, AgentInteractionTracerEvent):
+            details.append("=== Agent Interaction Details ===")
+            details.append(f"From Agent: {event.from_agent}")
+            details.append(f"To Agent: {event.to_agent}")
+            details.append(f"Event Type: {event.event_type}")
+            if event.event_id:
+                details.append(f"Event ID: {event.event_id}")
+        
+        return "\n".join(details)
+    
+    def clear_events(self):
+        """Clear all events from the display."""
+        self.events.clear()
+        self.events_table.setRowCount(0)
+        self.details_text.clear()
+        self.event_count_label.setText("Events: 0")
+        self.tracer.clear()
+        self.statusBar().showMessage("Events cleared")
+    
+    def run_test_query(self):
+        """Run a test query to demonstrate the tracer."""
+        # Don't start a new query if one is already running
+        if self.worker and self.worker.isRunning():
+            self.statusBar().showMessage("Query already running, please wait...")
+            return
+
+        self.statusBar().showMessage("Running test query in background...")
+        self.test_button.setEnabled(False)
+
+        # Create and configure worker thread
+        self.worker = LLMWorker(self.tracer)
+        self.worker.finished.connect(self._on_query_finished)
+        self.worker.error.connect(self._on_query_error)
+
+        # Start the worker thread
+        self.worker.start()
+
+    def _on_query_finished(self, response: str):
+        """Handle successful query completion."""
+        self.statusBar().showMessage(f"Test query completed. Response: {response[:50]}...")
+        self.test_button.setEnabled(True)
+
+    def _on_query_error(self, error_msg: str):
+        """Handle query error."""
+        self.statusBar().showMessage(f"Error during test query: {error_msg}")
+        self.test_button.setEnabled(True)
+
+    def closeEvent(self, event):
+        """Clean up worker thread when window closes."""
+        if self.worker and self.worker.isRunning():
+            self.worker.quit()
+            self.worker.wait()
+        event.accept()
+
+
+def main():
+    """Main entry point for the tracer viewer application."""
+    app = QApplication(sys.argv)
+    
+    # Set application style
+    app.setStyle('Fusion')
+    
+    window = TracerViewer()
+    window.show()
+    
+    print("\n" + "="*80)
+    print("Mojentic Tracer - Real-time Event Viewer")
+    print("="*80)
+    print("\nThe Qt window is now open. You can:")
+    print("  1. Click 'Run Test Query' to generate sample tracer events")
+    print("  2. Click on any event row to see detailed information")
+    print("  3. Click 'Clear Events' to reset the display")
+    print("\nThe viewer will show events in real-time as they occur.")
+    print("Close the window to exit.")
+    print("="*80 + "\n")
+    
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

mojentic/llm/chat_session.py

@@ -73,7 +73,7 @@ class ChatSession:
             The response from the LLM.
         """
         self.insert_message(LLMMessage(role=MessageRole.User, content=query))
-        response = self.llm.generate(self.messages, tools=self.tools, temperature=0.1)
+        response = self.llm.generate(self.messages, tools=self.tools, temperature=self.temperature)
         self._ensure_all_messages_are_sized()
         self.insert_message(LLMMessage(role=MessageRole.Assistant, content=response))
         return response

mojentic/llm/llm_broker.py

@@ -43,7 +43,7 @@ class LLMBroker():
         tokenizer
             The gateway to use for tokenization. This is used to log approximate token counts for
             the LLM calls. If
-            None, `mxbai-embed-large` is used on a local Ollama server.
+            None, tiktoken's `cl100k_base` tokenizer is used.
         tracer
             Optional tracer system to record LLM calls and responses.
         """
@@ -146,15 +146,21 @@ class LLMBroker():
                     # Get the arguments before calling the tool
                     tool_arguments = tool_call.arguments
 
+                    # Measure tool execution time
+                    tool_start_time = time.time()
+
                     # Call the tool
                     output = tool.run(**tool_call.arguments)
 
+                    tool_duration_ms = (time.time() - tool_start_time) * 1000
+
                     # Record tool call in tracer
                     self.tracer.record_tool_call(
                         tool_call.name,
                         tool_arguments,
                         output,
                         caller="LLMBroker",
+                        call_duration_ms=tool_duration_ms,
                         source=type(self),
                         correlation_id=correlation_id
                     )

mojentic/tracer/null_tracer.py

@@ -95,6 +95,7 @@ class NullTracer:
                        arguments: Dict[str, Any],
                        result: Any,
                        caller: Optional[str] = None,
+                       call_duration_ms: Optional[float] = None,
                        source: Any = None,
                        correlation_id: str = None) -> None:
         """
@@ -110,6 +111,8 @@ class NullTracer:
             The result returned by the tool.
         caller : str, optional
             The name of the agent or component calling the tool.
+        call_duration_ms : float, optional
+            The duration of the tool call in milliseconds.
         source : Any, optional
             The source of the event.
         correlation_id : str, optional

mojentic/tracer/tracer_events.py

@@ -97,6 +97,7 @@ class ToolCallTracerEvent(TracerEvent):
     arguments: Dict[str, Any] = Field(..., description="Arguments provided to the tool")
     result: Any = Field(..., description="Result returned by the tool")
     caller: Optional[str] = Field(None, description="Name of the agent or component that called the tool")
+    call_duration_ms: Optional[float] = Field(None, description="Duration of the tool call in milliseconds")
 
     def printable_summary(self) -> str:
         """Return a formatted summary of the tool call event."""
@@ -114,6 +115,9 @@ class ToolCallTracerEvent(TracerEvent):
         if self.caller:
             summary += f"\n   Caller: {self.caller}"
 
+        if self.call_duration_ms is not None:
+            summary += f"\n   Duration: {self.call_duration_ms:.2f}ms"
+
         return summary
 
 

mojentic/tracer/tracer_system.py

@@ -141,6 +141,7 @@ class TracerSystem:
                        arguments: Dict[str, Any],
                        result: Any,
                        caller: Optional[str] = None,
+                       call_duration_ms: Optional[float] = None,
                        source: Any = None,
                        correlation_id: str = None) -> None:
         """
@@ -156,6 +157,8 @@ class TracerSystem:
             The result returned by the tool.
         caller : str, optional
             The name of the agent or component calling the tool.
+        call_duration_ms : float, optional
+            The duration of the tool call in milliseconds.
         source : Any, optional
             The source of the event. If None, the TracerSystem class will be used.
         correlation_id : str, required
@@ -171,6 +174,7 @@ class TracerSystem:
             arguments=arguments,
             result=result,
             caller=caller,
+            call_duration_ms=call_duration_ms,
             correlation_id=correlation_id
         )
         self.event_store.store(event)

{mojentic-0.8.1.dist-info → mojentic-0.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.8.1
+Version: 0.8.3
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/svetzal/mojentic

{mojentic-0.8.1.dist-info → mojentic-0.8.3.dist-info}/RECORD

@@ -37,6 +37,7 @@ _examples/solver_chat_session.py,sha256=4mTsgQVJWwujDFX6NUIK6kKr45E09Q4yIkZF-Fdo
 _examples/streaming.py,sha256=P1CGvm11yi_tojnha2Qmp_OFB5A3T-F5dWIzxEclNhM,1137
 _examples/tell_user_example.py,sha256=gPGS_3KAHUIFsnvkDXX6u1mVqlsB67zsyNdGuEho60o,1274
 _examples/tracer_demo.py,sha256=X4nZtMX4yPDLF0i-pb0gXDHvjUwgCDJ6Q6RS7lNRlVs,7101
+_examples/tracer_qt_viewer.py,sha256=kaU61Gcjq9BwFgJjGjx56pq6HdaqF5QqTrB8PBFB-lI,15251
 _examples/working_memory.py,sha256=xbCHb6Y0Um6ai5T9fWAX4oQOcCQJDinsn902qm8q48E,1935
 _examples/react/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _examples/react/formatters.py,sha256=nbgWve0YGKaRY6P4tXV84PYw8YDN4neefiq7mR2I_tI,1065
@@ -70,9 +71,9 @@ mojentic/agents/simple_recursive_agent.py,sha256=B3QcOeIuamoLp0MsAwCjJLgVCaODsEi
 mojentic/context/__init__.py,sha256=PZwMnDnn_ziGniAI6murl4dkkbBp_agkUps5EPGTFN4,136
 mojentic/context/shared_working_memory.py,sha256=Zt9MNGErEkDIUAaHvyhEOiTaEobI9l0MV4Z59lQFBr0,396
 mojentic/llm/__init__.py,sha256=rTUTMjAe524evcH09wKSpL5ymnwHFlM1fWvGKd3mSis,414
-mojentic/llm/chat_session.py,sha256=H2gY0mZYVym8jC69VHsmKaRZ9T87Suyw0-TW5r850nA,3992
+mojentic/llm/chat_session.py,sha256=0lhCZDxGfq3ma4m-SmJqfQYdyxPQElSFPQOcqAacFlQ,4005
 mojentic/llm/chat_session_spec.py,sha256=8-jj-EHV2WwWuvo3t8I75kSEAYiG1nR-OEwkkLTi_z0,3872
-mojentic/llm/llm_broker.py,sha256=wNBGQD9GwuZoj3liZZEfCFN4sb2_TN8HDHZvZc7-PMQ,9726
+mojentic/llm/llm_broker.py,sha256=j6WMrvg1643lxUKqK9UYQruAFT72DHP92JWsgW_w0c0,9955
 mojentic/llm/llm_broker_spec.py,sha256=40lzmYm_6Zje6z5MQ7_o3gSBThLsNW_l_1mZTUVll6A,5342
 mojentic/llm/message_composers.py,sha256=6_BbBGx-D77gtx97bN2sfftP8lMt0tlSs6GvT1sdVmU,12114
 mojentic/llm/message_composers_spec.py,sha256=RNW14Zb-kIBWT5Wy9cZQyxHPrcRIaBFjBYCR9N-m0kE,12109
@@ -130,15 +131,15 @@ mojentic/llm/tools/ephemeral_task_manager/start_task_tool_spec.py,sha256=oDeVPPf
 mojentic/tracer/__init__.py,sha256=N1dGv4dCgEWvFlaltnVFHmxDtg-C-p3oB8erAKRdJBU,484
 mojentic/tracer/event_store.py,sha256=eqbze4YRuiMDr8TCtMNHi-U_6-CLgstOHkLmtM5hc6Q,3691
 mojentic/tracer/event_store_spec.py,sha256=OWXWbeMCYU9dfySmbpmDA4KmwLlSaFy4ZpRt6BsTkFE,6522
-mojentic/tracer/null_tracer.py,sha256=zvNLKjQSu3na6SWoFa16k9fFyjmSD3Ihw5rTjRUXrSs,6872
-mojentic/tracer/tracer_events.py,sha256=mtONmApybFmbbt_4xN6h-wGrcZZneI3sJJ_8Z68V-tA,5405
+mojentic/tracer/null_tracer.py,sha256=vdRZJautFK9bzqH-wx9tAOWCUfl5TQBqhC2nt1Uu2mQ,7039
+mojentic/tracer/tracer_events.py,sha256=-V3aybUSL0mYINrSz46affVpwq9FhPDZ8qfAdFhqLWg,5632
 mojentic/tracer/tracer_events_spec.py,sha256=v84P3IjVr0_TGjwJD1w2SSNlTDJj0a4P8tMkDrsbOTA,3549
-mojentic/tracer/tracer_system.py,sha256=7CPy_2tlsHtXQ4DcO5oo52N9a9WS0GH-mjeINzu62ls,9989
+mojentic/tracer/tracer_system.py,sha256=PqAHvG4mxUfkdCOiT0mCrzvPAgPNqiTov5TksEBG_7U,10203
 mojentic/tracer/tracer_system_spec.py,sha256=TNm0f9LV__coBx0JGEKyzzNN9mFjCSG_SSrRISO8Xeg,8632
 mojentic/utils/__init__.py,sha256=lqECkkoFvHFttDnafRE1vvh0Dmna_lwupMToP5VvX5k,115
 mojentic/utils/formatting.py,sha256=bPrwwdluXdQ8TsFxfWtHNOeMWKNvAfABSoUnnA1g7c8,947
-mojentic-0.8.1.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
-mojentic-0.8.1.dist-info/METADATA,sha256=Lo7fKdzH3LXkdkL9d9ONoh00JxyggwF7snTIMvVSP7E,6896
-mojentic-0.8.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mojentic-0.8.1.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
-mojentic-0.8.1.dist-info/RECORD,,
+mojentic-0.8.3.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
+mojentic-0.8.3.dist-info/METADATA,sha256=wP0ag6Lsy7LCrGosAYf-j1OOjx-xC2B_hhQKOfq1CjQ,6896
+mojentic-0.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mojentic-0.8.3.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
+mojentic-0.8.3.dist-info/RECORD,,