jaf-py 2.5.2__py3-none-any.whl → 2.5.3__py3-none-any.whl

jaf/__init__.py

@@ -191,7 +191,7 @@ def generate_run_id() -> RunId:
     """Generate a new run ID."""
     return create_run_id(str(uuid.uuid4()))
 
-__version__ = "2.5.2"
+__version__ = "2.5.3"
 __all__ = [
     # Core types and functions
     "TraceId", "RunId", "ValidationResult", "Message", "ModelConfig",

jaf/core/tracing.py

@@ -443,10 +443,18 @@ class LangfuseTraceCollector:
             public_key=public_key,
             secret_key=secret_key,
             host=host,
-            release="jaf-py-v2.5.2",
+            release="jaf-py-v2.5.3",
             httpx_client=client
         )
         self._httpx_client = client
+
+        # Detect Langfuse version (v2 has trace() method, v3 does not)
+        self._is_langfuse_v3 = not hasattr(self.langfuse, 'trace')
+        if self._is_langfuse_v3:
+            print("[LANGFUSE] Detected Langfuse v3.x - using OpenTelemetry-based API")
+        else:
+            print("[LANGFUSE] Detected Langfuse v2.x - using legacy API")
+
         self.active_spans: Dict[str, Any] = {}
         self.trace_spans: Dict[TraceId, Any] = {}
         # Track tool calls and results for each trace
@@ -465,6 +473,113 @@ class LangfuseTraceCollector:
             except Exception as e:
                 print(f"[LANGFUSE] Warning: Failed to close httpx client: {e}")
 
+    def _get_event_data(self, event: TraceEvent, key: str, default: Any = None) -> Any:
+        """Extract data from event, handling both dict and dataclass."""
+        if not hasattr(event, 'data'):
+            return default
+
+        # Handle dict
+        if isinstance(event.data, dict):
+            return event.data.get(key, default)
+
+        # Handle dataclass/object with attributes
+        return getattr(event.data, key, default)
+
+    def _create_trace(self, trace_id: TraceId, **kwargs) -> Any:
+        """Create a trace using the appropriate API for the Langfuse version."""
+        if self._is_langfuse_v3:
+            # Langfuse v3: Use start_span() to create a root span (creates trace implicitly)
+            # Extract parameters for v3 API
+            name = kwargs.get('name', 'trace')
+            input_data = kwargs.get('input')
+            metadata = kwargs.get('metadata', {})
+            user_id = kwargs.get('user_id')
+            session_id = kwargs.get('session_id')
+            tags = kwargs.get('tags', [])
+
+            # Add user_id, session_id, and tags to metadata for v3
+            if user_id:
+                metadata['user_id'] = user_id
+            if session_id:
+                metadata['session_id'] = session_id
+            if tags:
+                metadata['tags'] = tags
+
+            # Create root span
+            trace = self.langfuse.start_span(
+                name=name,
+                input=input_data,
+                metadata=metadata
+            )
+
+            # Update trace properties using update_trace()
+            update_params = {}
+            if user_id:
+                update_params['user_id'] = user_id
+            if session_id:
+                update_params['session_id'] = session_id
+            if tags:
+                update_params['tags'] = tags
+
+            if update_params:
+                trace.update_trace(**update_params)
+
+            return trace
+        else:
+            # Langfuse v2: Use trace() method
+            return self.langfuse.trace(**kwargs)
+
+    def _create_generation(self, parent_span: Any, **kwargs) -> Any:
+        """Create a generation using the appropriate API for the Langfuse version."""
+        if self._is_langfuse_v3:
+            # Langfuse v3: Use start_generation() method
+            return parent_span.start_generation(**kwargs)
+        else:
+            # Langfuse v2: Use generation() method
+            return parent_span.generation(**kwargs)
+
+    def _create_span(self, parent_span: Any, **kwargs) -> Any:
+        """Create a span using the appropriate API for the Langfuse version."""
+        if self._is_langfuse_v3:
+            # Langfuse v3: Use start_span() method
+            return parent_span.start_span(**kwargs)
+        else:
+            # Langfuse v2: Use span() method
+            return parent_span.span(**kwargs)
+
+    def _create_event(self, parent_span: Any, **kwargs) -> Any:
+        """Create an event using the appropriate API for the Langfuse version."""
+        if self._is_langfuse_v3:
+            # Langfuse v3: Use create_event() method
+            return parent_span.create_event(**kwargs)
+        else:
+            # Langfuse v2: Use event() method
+            return parent_span.event(**kwargs)
+
+    def _end_span(self, span: Any, **kwargs) -> None:
+        """End a span/generation using the appropriate API for the Langfuse version."""
+        if self._is_langfuse_v3:
+            # Langfuse v3: Call update() first with output/metadata, then end()
+            update_params = {}
+            end_params = {}
+
+            # Separate parameters for update() vs end()
+            for key, value in kwargs.items():
+                if key in ['output', 'metadata', 'model', 'usage']:
+                    update_params[key] = value
+                elif key == 'end_time':
+                    end_params[key] = value
+
+            # Update first if there are parameters
+            if update_params:
+                span.update(**update_params)
+
+            # Then end
+            span.end(**end_params)
+        else:
+            # Langfuse v2: Call end() directly with all parameters
+            span.end(**kwargs)
+
     def collect(self, event: TraceEvent) -> None:
         """Collect a trace event and send it to Langfuse."""
         try:
@@ -489,15 +604,15 @@ class LangfuseTraceCollector:
                 conversation_history = []
                 
                 # Debug: Print the event data structure to understand what we're working with
-                if event.data.get("context"):
-                    context = event.data["context"]
+                if self._get_event_data(event, "context"):
+                    context = self._get_event_data(event, "context")
                     print(f"[LANGFUSE DEBUG] Context type: {type(context)}")
                     print(f"[LANGFUSE DEBUG] Context attributes: {dir(context) if hasattr(context, '__dict__') else 'Not an object'}")
                     if hasattr(context, '__dict__'):
                         print(f"[LANGFUSE DEBUG] Context dict: {context.__dict__}")
                 
                 # Try to extract from context first
-                context = event.data.get("context")
+                context = self._get_event_data(event, "context")
                 if context:
                     # Try direct attribute access
                     if hasattr(context, 'query'):
@@ -527,7 +642,7 @@ class LangfuseTraceCollector:
                             print(f"[LANGFUSE DEBUG] Extracted user_id from attr: {user_id}")
                 
                 # Extract conversation history and current user query from messages
-                messages = event.data.get("messages", [])
+                messages = self._get_event_data(event, "messages", [])
                 if messages:
                     print(f"[LANGFUSE DEBUG] Processing {len(messages)} messages")
                     
@@ -619,20 +734,22 @@ class LangfuseTraceCollector:
                 trace_input = {
                     "user_query": user_query,
                     "run_id": str(trace_id),
-                    "agent_name": event.data.get("agent_name", "analytics_agent_jaf"),
+                    "agent_name": self._get_event_data(event, "agent_name", "analytics_agent_jaf"),
                     "session_info": {
-                        "session_id": event.data.get("session_id"),
-                        "user_id": user_id or event.data.get("user_id")
+                        "session_id": self._get_event_data(event, "session_id"),
+                        "user_id": user_id or self._get_event_data(event, "user_id")
                     }
                 }
 
                 # Extract agent_name for tagging
-                agent_name = event.data.get("agent_name") or "analytics_agent_jaf"
+                agent_name = self._get_event_data(event, "agent_name") or "analytics_agent_jaf"
 
-                trace = self.langfuse.trace(
+                # Use compatibility layer to create trace (works with both v2 and v3)
+                trace = self._create_trace(
+                    trace_id=trace_id,
                     name=agent_name,
-                    user_id=user_id or event.data.get("user_id"),
-                    session_id=event.data.get("session_id"),
+                    user_id=user_id or self._get_event_data(event, "user_id"),
+                    session_id=self._get_event_data(event, "session_id"),
                     input=trace_input,
                     tags=[agent_name],  # Add agent_name as a tag for dashboard filtering
                     metadata={
@@ -640,17 +757,17 @@ class LangfuseTraceCollector:
                         "event_type": "run_start",
                         "trace_id": str(trace_id),
                         "user_query": user_query,
-                        "user_id": user_id or event.data.get("user_id"),
+                        "user_id": user_id or self._get_event_data(event, "user_id"),
                         "agent_name": agent_name,
                         "conversation_history": conversation_history,
                         "tool_calls": [],
                         "tool_results": [],
-                        "user_info": event.data.get("context").user_info if event.data.get("context") and hasattr(event.data.get("context"), 'user_info') else None
+                        "user_info": self._get_event_data(event, "context").user_info if self._get_event_data(event, "context") and hasattr(self._get_event_data(event, "context"), 'user_info') else None
                     }
                 )
                 self.trace_spans[trace_id] = trace
                 # Store user_id, user_query, and conversation_history for later use
-                trace._user_id = user_id or event.data.get("user_id")
+                trace._user_id = user_id or self._get_event_data(event, "user_id")
                 trace._user_query = user_query
                 trace._conversation_history = conversation_history
                 print(f"[LANGFUSE] Created trace with user query: {user_query[:100] if user_query else 'None'}...")
@@ -667,7 +784,7 @@ class LangfuseTraceCollector:
                         "trace_id": str(trace_id),
                         "user_query": getattr(self.trace_spans[trace_id], '_user_query', None),
                         "user_id": getattr(self.trace_spans[trace_id], '_user_id', None),
-                        "agent_name": event.data.get("agent_name", "analytics_agent_jaf"),
+                        "agent_name": self._get_event_data(event, "agent_name", "analytics_agent_jaf"),
                         "conversation_history": conversation_history,
                         "tool_calls": self.trace_tool_calls.get(trace_id, []),
                         "tool_results": self.trace_tool_results.get(trace_id, [])
@@ -695,7 +812,7 @@ class LangfuseTraceCollector:
                     
             elif event.type == "llm_call_start":
                 # Start a generation for LLM calls
-                model = event.data.get("model", "unknown")
+                model = self._get_event_data(event, "model", "unknown")
                 print(f"[LANGFUSE] Starting generation for LLM call with model: {model}")
                 
                 # Get stored user information from the trace
@@ -703,11 +820,13 @@ class LangfuseTraceCollector:
                 user_id = getattr(trace, '_user_id', None)
                 user_query = getattr(trace, '_user_query', None)
                 
-                generation = trace.generation(
+                # Use compatibility layer to create generation (works with both v2 and v3)
+                generation = self._create_generation(
+                    parent_span=trace,
                     name=f"llm-call-{model}",
-                    input=event.data.get("messages"),
+                    input=self._get_event_data(event, "messages"),
                     metadata={
-                        "agent_name": event.data.get("agent_name"), 
+                        "agent_name": self._get_event_data(event, "agent_name"),
                         "model": model,
                         "user_id": user_id,
                         "user_query": user_query
@@ -723,10 +842,10 @@ class LangfuseTraceCollector:
                     print(f"[LANGFUSE] Ending generation for LLM call")
                     # End the generation
                     generation = self.active_spans[span_id]
-                    choice = event.data.get("choice", {})
-                    
+                    choice = self._get_event_data(event, "choice", {})
+
                     # Extract usage from the event data
-                    usage = event.data.get("usage", {})
+                    usage = self._get_event_data(event, "usage", {})
                     
                     # Extract model information from choice data or event data
                     model = choice.get("model", "unknown")
@@ -752,8 +871,10 @@ class LangfuseTraceCollector:
                         print(f"[LANGFUSE] Usage data for automatic cost calculation: {langfuse_usage}")
 
                     # Include model information in the generation end - Langfuse will calculate costs automatically
-                    generation.end(
-                        output=choice, 
+                    # Use compatibility wrapper for ending spans/generations
+                    self._end_span(
+                        span=generation,
+                        output=choice,
                         usage=langfuse_usage,
                         model=model,  # Pass model directly for automatic cost calculation
                         metadata={
@@ -772,9 +893,9 @@ class LangfuseTraceCollector:
                     
             elif event.type == "tool_call_start":
                 # Start a span for tool calls with detailed input information
-                tool_name = event.data.get('tool_name', 'unknown')
-                tool_args = event.data.get("args", {})
-                call_id = event.data.get("call_id")
+                tool_name = self._get_event_data(event, 'tool_name', 'unknown')
+                tool_args = self._get_event_data(event, "args", {})
+                call_id = self._get_event_data(event, "call_id")
                 if not call_id:
                     call_id = f"{tool_name}-{uuid.uuid4().hex[:8]}"
                     try:
@@ -807,7 +928,9 @@ class LangfuseTraceCollector:
                     "timestamp": datetime.now().isoformat()
                 }
                 
-                span = self.trace_spans[trace_id].span(
+                # Use compatibility layer to create span (works with both v2 and v3)
+                span = self._create_span(
+                    parent_span=self.trace_spans[trace_id],
                     name=f"tool-{tool_name}",
                     input=tool_input,
                     metadata={
@@ -824,9 +947,9 @@ class LangfuseTraceCollector:
             elif event.type == "tool_call_end":
                 span_id = self._get_span_id(event)
                 if span_id in self.active_spans:
-                    tool_name = event.data.get('tool_name', 'unknown')
-                    tool_result = event.data.get("result")
-                    call_id = event.data.get("call_id")
+                    tool_name = self._get_event_data(event, 'tool_name', 'unknown')
+                    tool_result = self._get_event_data(event, "result")
+                    call_id = self._get_event_data(event, "call_id")
                     
                     print(f"[LANGFUSE] Ending span for tool call: {tool_name} ({call_id})")
                     
@@ -836,9 +959,9 @@ class LangfuseTraceCollector:
                         "result": tool_result,
                         "call_id": call_id,
                         "timestamp": datetime.now().isoformat(),
-                        "execution_status": event.data.get("execution_status", "completed"),
-                        "status": event.data.get("execution_status", "completed"),  # DEPRECATED: backward compatibility
-                        "tool_result": event.data.get("tool_result")
+                        "execution_status": self._get_event_data(event, "execution_status", "completed"),
+                        "status": self._get_event_data(event, "execution_status", "completed"),  # DEPRECATED: backward compatibility
+                        "tool_result": self._get_event_data(event, "tool_result")
                     }
                     
                     if trace_id not in self.trace_tool_results:
@@ -852,13 +975,15 @@ class LangfuseTraceCollector:
                         "result": tool_result,
                         "call_id": call_id,
                         "timestamp": datetime.now().isoformat(),
-                        "execution_status": event.data.get("execution_status", "completed"),
-                        "status": event.data.get("execution_status", "completed")  # DEPRECATED: backward compatibility
+                        "execution_status": self._get_event_data(event, "execution_status", "completed"),
+                        "status": self._get_event_data(event, "execution_status", "completed")  # DEPRECATED: backward compatibility
                     }
                     
                     # End the span with detailed output
+                    # Use compatibility wrapper for ending spans/generations
                     span = self.active_spans[span_id]
-                    span.end(
+                    self._end_span(
+                        span=span,
                         output=tool_output,
                         metadata={
                             "tool_name": tool_name,
@@ -878,17 +1003,21 @@ class LangfuseTraceCollector:
             elif event.type == "handoff":
                 # Create an event for handoffs
                 print(f"[LANGFUSE] Creating event for handoff")
-                self.trace_spans[trace_id].event(
+                # Use compatibility layer to create event (works with both v2 and v3)
+                self._create_event(
+                    parent_span=self.trace_spans[trace_id],
                     name="agent-handoff",
-                    input={"from": event.data.get("from"), "to": event.data.get("to")},
+                    input={"from": self._get_event_data(event, "from"), "to": self._get_event_data(event, "to")},
                     metadata=event.data
                 )
                 print(f"[LANGFUSE] Handoff event created")
-                    
+
             else:
                 # Create a generic event for other event types
                 print(f"[LANGFUSE] Creating generic event for: {event.type}")
-                self.trace_spans[trace_id].event(
+                # Use compatibility layer to create event (works with both v2 and v3)
+                self._create_event(
+                    parent_span=self.trace_spans[trace_id],
                     name=event.type,
                     input=event.data,
                     metadata={"framework": "jaf", "event_type": event.type}
@@ -902,20 +1031,28 @@ class LangfuseTraceCollector:
             traceback.print_exc()
 
     def _get_trace_id(self, event: TraceEvent) -> Optional[TraceId]:
-        """Extract trace ID from event data."""
-        if hasattr(event, 'data') and isinstance(event.data, dict):
-            # Try snake_case first (Python convention)
-            if 'trace_id' in event.data:
-                return event.data['trace_id']
-            elif 'run_id' in event.data:
-                return TraceId(event.data['run_id'])
-            # Fallback to camelCase (for compatibility)
-            elif 'traceId' in event.data:
-                return event.data['traceId']
-            elif 'runId' in event.data:
-                return TraceId(event.data['runId'])
-        
-        # Debug: print what's actually in the event data
+        """Extract trace ID from event data, handling both dict and dataclass."""
+        if not hasattr(event, 'data'):
+            return None
+
+        # Try snake_case first (Python convention)
+        trace_id = self._get_event_data(event, 'trace_id')
+        if trace_id:
+            return trace_id
+
+        run_id = self._get_event_data(event, 'run_id')
+        if run_id:
+            return TraceId(run_id)
+
+        # Fallback to camelCase (for compatibility)
+        trace_id = self._get_event_data(event, 'traceId')
+        if trace_id:
+            return trace_id
+
+        run_id = self._get_event_data(event, 'runId')
+        if run_id:
+            return TraceId(run_id)
+
         return None
 
     def _get_span_id(self, event: TraceEvent) -> str:
@@ -924,15 +1061,15 @@ class LangfuseTraceCollector:
         
         # Use consistent identifiers that don't depend on timestamp
         if event.type.startswith('tool_call'):
-            call_id = event.data.get('call_id') or event.data.get('tool_call_id')
+            call_id = self._get_event_data(event, 'call_id') or self._get_event_data(event, 'tool_call_id')
             if call_id:
                 return f"tool-{trace_id}-{call_id}"
-            tool_name = event.data.get('tool_name') or event.data.get('toolName', 'unknown')
+            tool_name = self._get_event_data(event, 'tool_name') or self._get_event_data(event, 'toolName', 'unknown')
             return f"tool-{tool_name}-{trace_id}"
         elif event.type.startswith('llm_call'):
             # For LLM calls, use a simpler consistent ID that matches between start and end
             # Get run_id for more consistent matching
-            run_id = event.data.get('run_id') or event.data.get('runId', trace_id)
+            run_id = self._get_event_data(event, 'run_id') or self._get_event_data(event, 'runId', trace_id)
             return f"llm-{run_id}"
         else:
             return f"{event.type}-{trace_id}"

{jaf_py-2.5.2.dist-info → jaf_py-2.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.5.2
+Version: 2.5.3
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -42,13 +42,13 @@ Requires-Dist: fastmcp>=0.1.0
 Requires-Dist: opentelemetry-api>=1.22.0
 Requires-Dist: opentelemetry-sdk>=1.22.0
 Requires-Dist: opentelemetry-exporter-otlp>=1.22.0
-Requires-Dist: langfuse<4.0.0,>=3.6.1
+Requires-Dist: langfuse<3.0.0
 Requires-Dist: litellm>=1.76.3
 Provides-Extra: tracing
 Requires-Dist: opentelemetry-api>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-sdk>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-exporter-otlp>=1.22.0; extra == "tracing"
-Requires-Dist: langfuse<4.0.0,>=3.6.1; extra == "tracing"
+Requires-Dist: langfuse<3.0.0; extra == "tracing"
 Provides-Extra: attachments
 Requires-Dist: PyPDF2>=3.0.0; extra == "attachments"
 Requires-Dist: python-docx>=1.1.0; extra == "attachments"
@@ -82,7 +82,7 @@ Dynamic: license-file
 
 <!-- ![JAF Banner](docs/cover.png) -->
 
-[![Version](https://img.shields.io/badge/version-2.5.2-blue.svg)](https://github.com/xynehq/jaf-py)
+[![Version](https://img.shields.io/badge/version-2.5.3-blue.svg)](https://github.com/xynehq/jaf-py)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
 [![Docs](https://img.shields.io/badge/Docs-Live-brightgreen)](https://xynehq.github.io/jaf-py/)
 

{jaf_py-2.5.2.dist-info → jaf_py-2.5.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-jaf/__init__.py,sha256=SbhsrrcWZmeOfOlOOpIzmd1jCGYs3T4ckoJYr15Q3sQ,8260
+jaf/__init__.py,sha256=M7o--eb6Yp44HXoxq03cz650o8gY0ehAicf5J7d7nzg,8260
 jaf/cli.py,sha256=Af4di_NZ7rZ4wFl0R4EZh611NgJ--TL03vNyZ2M1_FY,8477
 jaf/exceptions.py,sha256=nl8JY355u7oTXB3PmC_LhnUaL8fzk2K4EaWM4fVpMPE,9196
 jaf/a2a/__init__.py,sha256=p4YVthZH0ow1ZECqWTQ0aQl8JWySYZb25jlzZJ09na4,7662
@@ -54,7 +54,7 @@ jaf/core/state.py,sha256=oNCVXPWLkqnBQObdQX10TcmZ0eOF3wKG6DtL3kF6ohw,9649
 jaf/core/streaming.py,sha256=h_lYHQA9ee_D5QsDO9-Vhevgi7rFXPslPzd9605AJGo,17034
 jaf/core/tool_results.py,sha256=-bTOqOX02lMyslp5Z4Dmuhx0cLd5o7kgR88qK2HO_sw,11323
 jaf/core/tools.py,sha256=84N9A7QQ3xxcOs2eUUot3nmCnt5i7iZT9VwkuzuFBxQ,16274
-jaf/core/tracing.py,sha256=2YF266jIwRHjDd5C-D5l_9T_Ts0jfY5md20odc5ygQw,47464
+jaf/core/tracing.py,sha256=kY6qCVY2YQWWcbjU82icEdysdOEwYdoYfyM5I2YcSu4,53367
 jaf/core/types.py,sha256=GE7Q2s6jglAFfkpc1MIgVkC9XWaWT46OOQd7L17ACxw,27955
 jaf/core/workflows.py,sha256=Ul-82gzjIXtkhnSMSPv-8igikjkMtW1EBo9yrfodtvI,26294
 jaf/memory/__init__.py,sha256=-L98xlvihurGAzF0DnXtkueDVvO_wV2XxxEwAWdAj50,1400
@@ -87,9 +87,9 @@ jaf/visualization/functional_core.py,sha256=zedMDZbvjuOugWwnh6SJ2stvRNQX1Hlkb9Ab
 jaf/visualization/graphviz.py,sha256=WTOM6UP72-lVKwI4_SAr5-GCC3ouckxHv88ypCDQWJ0,12056
 jaf/visualization/imperative_shell.py,sha256=GpMrAlMnLo2IQgyB2nardCz09vMvAzaYI46MyrvJ0i4,2593
 jaf/visualization/types.py,sha256=QQcbVeQJLuAOXk8ynd08DXIS-PVCnv3R-XVE9iAcglw,1389
-jaf_py-2.5.2.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
-jaf_py-2.5.2.dist-info/METADATA,sha256=bpMawyewNtufu4o4eQWuPRCwiqhLqKqw0ZZNbeEMtl8,27759
-jaf_py-2.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jaf_py-2.5.2.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
-jaf_py-2.5.2.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
-jaf_py-2.5.2.dist-info/RECORD,,
+jaf_py-2.5.3.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
+jaf_py-2.5.3.dist-info/METADATA,sha256=tKpfginwaYb7zT0aUGt8a-cJ3mm8E5KfvWCLnWhYGGY,27743
+jaf_py-2.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaf_py-2.5.3.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
+jaf_py-2.5.3.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
+jaf_py-2.5.3.dist-info/RECORD,,