chuk-tool-processor 0.4.1__py3-none-any.whl → 0.5__py3-none-any.whl

chuk_tool_processor/registry/decorators.py

@@ -1,6 +1,10 @@
-# chuk_tool_processor/registry/decorators.py
+#!/usr/bin/env python
 """
-Decorators for registering tools with the registry asynchronously.
+Decorator that handles Pydantic models (StreamingTool) properly.
+
+The issue was that Pydantic models have strict field validation and reject
+arbitrary attribute assignment. This fix detects Pydantic models and handles
+them appropriately.
 """
 
 import asyncio
@@ -17,35 +21,221 @@ from chuk_tool_processor.registry.provider import ToolRegistryProvider
 T = TypeVar('T')
 
 # Global tracking of classes to be registered
-# Store coroutines rather than awaitables to avoid warnings
 _PENDING_REGISTRATIONS: List[Callable[[], Awaitable]] = []
 _REGISTERED_CLASSES = weakref.WeakSet()
-
-# Keep track of whether we're shutting down
 _SHUTTING_DOWN = False
 
 
-def register_tool(name: Optional[str] = None, namespace: str = "default", **metadata):
+def _is_pydantic_model(cls: Type) -> bool:
+    """Check if a class is a Pydantic model."""
+    try:
+        # Check for Pydantic v2
+        return hasattr(cls, 'model_fields') or hasattr(cls, '__pydantic_core_schema__')
+    except:
+        try:
+            # Check for Pydantic v1
+            return hasattr(cls, '__fields__')
+        except:
+            return False
+
+
+def _add_subprocess_serialization_support(cls: Type, tool_name: str) -> Type:
     """
-    Decorator for registering tools with the global registry.
+    Add subprocess serialization support to a tool class.
+    
+    FIXED: Now properly handles Pydantic models by using class attributes
+    instead of instance attributes where necessary.
+    """
+    # Store the tool name for serialization at class level
+    cls._tool_name = tool_name
     
-    This decorator will queue the registration to happen asynchronously.
-    You must call `await ensure_registrations()` in your application startup
-    to complete all registrations.
+    # Check if this is a Pydantic model
+    is_pydantic = _is_pydantic_model(cls)
+    
+    # Check if the class already has custom serialization methods
+    has_custom_getstate = '__getstate__' in cls.__dict__ and callable(cls.__dict__['__getstate__'])
+    has_custom_setstate = '__setstate__' in cls.__dict__ and callable(cls.__dict__['__setstate__'])
+    
+    if has_custom_getstate and has_custom_setstate:
+        # Class already has both custom serialization methods
+        original_getstate = cls.__getstate__
+        original_setstate = cls.__setstate__
+        
+        def enhanced_getstate(self):
+            """Enhanced __getstate__ that ensures tool_name is included."""
+            state = original_getstate(self)
+            if isinstance(state, dict):
+                state['tool_name'] = getattr(self, 'tool_name', tool_name)
+                return state
+            else:
+                return {
+                    '_custom_state': state,
+                    'tool_name': getattr(self, 'tool_name', tool_name)
+                }
+        
+        def enhanced_setstate(self, state):
+            """Enhanced __setstate__ that handles tool_name."""
+            if isinstance(state, dict) and '_custom_state' in state:
+                # FIXED: For Pydantic models, set as class attribute
+                if is_pydantic:
+                    self.__class__._tool_name = state.get('tool_name', tool_name)
+                else:
+                    self.tool_name = state.get('tool_name', tool_name)
+                original_setstate(self, state['_custom_state'])
+            else:
+                if isinstance(state, dict):
+                    if is_pydantic:
+                        self.__class__._tool_name = state.get('tool_name', tool_name)
+                    else:
+                        self.tool_name = state.get('tool_name', tool_name)
+                original_setstate(self, state)
+        
+        cls.__getstate__ = enhanced_getstate
+        cls.__setstate__ = enhanced_setstate
+        
+    elif not has_custom_getstate and not has_custom_setstate:
+        # No custom serialization methods - add default implementation
+        
+        if is_pydantic:
+            # FIXED: Special handling for Pydantic models
+            def __getstate__(self):
+                """Pydantic-compatible serialization method."""
+                try:
+                    # Try Pydantic v2 first
+                    if hasattr(self, 'model_dump'):
+                        state = self.model_dump()
+                    elif hasattr(self, 'dict'):
+                        # Pydantic v1
+                        state = self.dict()
+                    else:
+                        # Fallback to __dict__
+                        state = self.__dict__.copy()
+                except Exception:
+                    # Fallback to __dict__
+                    state = self.__dict__.copy()
+                
+                # Always include tool_name
+                state['tool_name'] = getattr(self, 'tool_name', getattr(self.__class__, '_tool_name', tool_name))
+                return state
+            
+            def __setstate__(self, state):
+                """Pydantic-compatible deserialization method."""
+                if isinstance(state, dict):
+                    # Extract tool_name and store at class level for Pydantic
+                    tool_name_value = state.get('tool_name', tool_name)
+                    self.__class__._tool_name = tool_name_value
+                    
+                    # For Pydantic models, we need to be careful about restoration
+                    try:
+                        # Remove tool_name from state since it's not a Pydantic field
+                        state_copy = state.copy()
+                        state_copy.pop('tool_name', None)
+                        
+                        # Update the object's fields
+                        if hasattr(self, '__dict__'):
+                            self.__dict__.update(state_copy)
+                    except Exception:
+                        # Fallback - just update __dict__
+                        if hasattr(self, '__dict__'):
+                            self.__dict__.update(state)
+                else:
+                    # Non-dict state
+                    self.__class__._tool_name = tool_name
+        
+        else:
+            # Regular class handling (same as before)
+            def __getstate__(self):
+                """Default serialization method for subprocess execution."""
+                state = self.__dict__.copy()
+                state['tool_name'] = getattr(self, 'tool_name', tool_name)
+                
+                # Remove non-serializable attributes
+                non_serializable_attrs = []
+                for key, value in list(state.items()):
+                    if key == 'tool_name':
+                        continue
+                    try:
+                        import pickle
+                        pickle.dumps(value)
+                    except (TypeError, AttributeError, pickle.PicklingError):
+                        non_serializable_attrs.append(key)
+                
+                for key in non_serializable_attrs:
+                    if key in state:
+                        del state[key]
+                
+                return state
+            
+            def __setstate__(self, state):
+                """Default deserialization method for subprocess execution."""
+                if isinstance(state, dict):
+                    self.__dict__.update(state)
+                    if not hasattr(self, 'tool_name') or not self.tool_name:
+                        self.tool_name = state.get('tool_name', tool_name)
+                else:
+                    self.tool_name = tool_name
+        
+        cls.__getstate__ = __getstate__
+        cls.__setstate__ = __setstate__
+    
+    # FIXED: Enhanced __init__ wrapper that handles Pydantic models
+    if hasattr(cls, '__init__'):
+        original_init = cls.__init__
+        
+        @functools.wraps(original_init)
+        def enhanced_init(self, *args, **kwargs):
+            # Call original __init__
+            original_init(self, *args, **kwargs)
+            
+            # FIXED: Handle tool_name setting based on model type
+            if is_pydantic:
+                # For Pydantic models, store at class level and add property
+                self.__class__._tool_name = tool_name
+                
+                # Add a property to access tool_name if it doesn't exist
+                if not hasattr(self.__class__, 'tool_name'):
+                    def tool_name_property(self):
+                        return getattr(self.__class__, '_tool_name', tool_name)
+                    
+                    # Add as a property
+                    setattr(self.__class__, 'tool_name', property(tool_name_property))
+            else:
+                # For regular classes, set as instance attribute
+                if not hasattr(self, 'tool_name'):
+                    self.tool_name = tool_name
+        
+        cls.__init__ = enhanced_init
+    else:
+        # FIXED: Add appropriate __init__ based on model type
+        if is_pydantic:
+            def __init__(self, *args, **kwargs):
+                super(cls, self).__init__(*args, **kwargs)
+                self.__class__._tool_name = tool_name
+        else:
+            def __init__(self):
+                self.tool_name = tool_name
+        
+        cls.__init__ = __init__
+    
+    # FIXED: Add tool_name property for Pydantic models
+    if is_pydantic and not hasattr(cls, 'tool_name'):
+        def tool_name_property(self):
+            return getattr(self.__class__, '_tool_name', tool_name)
+        
+        # Add as a property so it can be accessed but not set directly
+        setattr(cls, 'tool_name', property(tool_name_property))
     
-    Example:
-        @register_tool(name="my_tool", namespace="math", description="Performs math operations")
-        class MyTool:
-            async def execute(self, x: int, y: int) -> int:
-                return x + y
+    return cls
+
+
+def register_tool(name: Optional[str] = None, namespace: str = "default", **metadata):
+    """
+    Decorator for registering tools with the global registry.
     
-    Args:
-        name: Optional explicit name; if omitted, uses class.__name__.
-        namespace: Namespace for the tool (default: "default").
-        **metadata: Additional metadata for the tool.
+    FIXED: Now properly handles Pydantic models (like StreamingTool).
     
-    Returns:
-        A decorator function that registers the class with the registry.
+    This decorator automatically adds subprocess serialization support,
+    making tools compatible with both InProcessStrategy and SubprocessStrategy.
     """
     def decorator(cls: Type[T]) -> Type[T]:
         # Skip if already registered
@@ -59,76 +249,109 @@ def register_tool(name: Optional[str] = None, namespace: str = "default", **meta
         # Ensure execute method is async
         if hasattr(cls, 'execute') and not inspect.iscoroutinefunction(cls.execute):
             raise TypeError(f"Tool {cls.__name__} must have an async execute method")
+        
+        # Determine the tool name
+        tool_name = name or cls.__name__
+        
+        # FIXED: Add subprocess serialization support with Pydantic handling
+        enhanced_cls = _add_subprocess_serialization_support(cls, tool_name)
             
-        # Create registration function (not coroutine)
+        # Create registration function
         async def do_register():
             registry = await ToolRegistryProvider.get_registry()
             await registry.register_tool(
-                cls, 
-                name=name, 
+                enhanced_cls, 
+                name=tool_name, 
                 namespace=namespace, 
                 metadata=metadata
             )
         
-        # Store the function, not the coroutine
         _PENDING_REGISTRATIONS.append(do_register)
-        _REGISTERED_CLASSES.add(cls)
+        _REGISTERED_CLASSES.add(enhanced_cls)
         
-        # Add class attribute so we can identify decorated classes
-        cls._tool_registration_info = {
-            'name': name or cls.__name__,
+        # Add class attribute for identification
+        enhanced_cls._tool_registration_info = {
+            'name': tool_name,
             'namespace': namespace,
             'metadata': metadata
         }
         
-        # Don't modify the original class
-        return cls
+        return enhanced_cls
     
     return decorator
 
 
-async def ensure_registrations() -> None:
+# Alternative approach: A helper function for Pydantic compatibility
+def make_pydantic_tool_compatible(cls: Type, tool_name: str) -> Type:
     """
-    Process all pending tool registrations.
+    Alternative helper function to make Pydantic tools subprocess-compatible.
     
-    This must be called during application startup to register
-    all tools decorated with @register_tool.
-    
-    Returns:
-        None
+    This can be used as a manual alternative if the decorator approach
+    doesn't work for your specific use case.
     """
+    # Store tool name at class level
+    cls._tool_name = tool_name
+    
+    # Add property access
+    if not hasattr(cls, 'tool_name'):
+        def tool_name_getter(self):
+            return getattr(self.__class__, '_tool_name', tool_name)
+        
+        setattr(cls, 'tool_name', property(tool_name_getter))
+    
+    # Add serialization methods
+    if not hasattr(cls, '__getstate__'):
+        def __getstate__(self):
+            try:
+                if hasattr(self, 'model_dump'):
+                    state = self.model_dump()
+                elif hasattr(self, 'dict'):
+                    state = self.dict()
+                else:
+                    state = self.__dict__.copy()
+            except:
+                state = self.__dict__.copy()
+            
+            state['tool_name'] = getattr(self.__class__, '_tool_name', tool_name)
+            return state
+        
+        cls.__getstate__ = __getstate__
+    
+    if not hasattr(cls, '__setstate__'):
+        def __setstate__(self, state):
+            if isinstance(state, dict):
+                self.__class__._tool_name = state.get('tool_name', tool_name)
+                state_copy = state.copy()
+                state_copy.pop('tool_name', None)
+                if hasattr(self, '__dict__'):
+                    self.__dict__.update(state_copy)
+        
+        cls.__setstate__ = __setstate__
+    
+    return cls
+
+
+async def ensure_registrations() -> None:
+    """Process all pending tool registrations."""
     global _PENDING_REGISTRATIONS
     
     if not _PENDING_REGISTRATIONS:
         return
         
-    # Create tasks from the stored functions
     tasks = []
     for registration_fn in _PENDING_REGISTRATIONS:
-        # Now we await the function to get the coroutine, then create a task
         tasks.append(asyncio.create_task(registration_fn()))
     
-    # Clear the pending list
     _PENDING_REGISTRATIONS.clear()
     
-    # Wait for all registrations to complete
     if tasks:
         await asyncio.gather(*tasks)
 
 
 def discover_decorated_tools() -> List[Type]:
-    """
-    Discover all tool classes decorated with @register_tool.
-    
-    This can be used to inspect what tools have been registered
-    without awaiting ensure_registrations().
-    
-    Returns:
-        List of tool classes that have been decorated
-    """
+    """Discover all tool classes decorated with @register_tool."""
     tools = []
     
-    # Search all loaded modules
     for module_name, module in list(sys.modules.items()):
         if not module_name.startswith('chuk_tool_processor'):
             continue
@@ -144,22 +367,13 @@ def discover_decorated_tools() -> List[Type]:
     return tools
 
 
-# Register atexit handler to prevent warnings at shutdown
+# Shutdown handling
 def _handle_shutdown():
-    """
-    Handle shutdown by marking shutdown flag and clearing pending registrations.
-    This prevents warnings about unawaited coroutines.
-    """
+    """Handle shutdown by clearing pending registrations."""
     global _SHUTTING_DOWN, _PENDING_REGISTRATIONS
-    
-    # Set the shutdown flag
     _SHUTTING_DOWN = True
-    
-    # Clear without creating any coroutines
     _PENDING_REGISTRATIONS = []
 
-# Register the shutdown handler
-atexit.register(_handle_shutdown)
 
-# Filter the coroutine never awaited warning
+atexit.register(_handle_shutdown)
 warnings.filterwarnings("ignore", message="coroutine.*was never awaited")

{chuk_tool_processor-0.4.1.dist-info → chuk_tool_processor-0.5.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.4.1
+Version: 0.5
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: chuk-mcp>=0.1.12
+Requires-Dist: chuk-mcp>=0.2
 Requires-Dist: dotenv>=0.9.9
-Requires-Dist: openai>=1.76.0
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: uuid>=1.30
 

{chuk_tool_processor-0.4.1.dist-info → chuk_tool_processor-0.5.dist-info}/RECORD

@@ -3,29 +3,29 @@ chuk_tool_processor/core/__init__.py,sha256=slM7pZna88tyZrF3KtN22ApYyCqGNt5Yscv-
 chuk_tool_processor/core/exceptions.py,sha256=h4zL1jpCY1Ud1wT8xDeMxZ8GR8ttmkObcv36peUHJEA,1571
 chuk_tool_processor/core/processor.py,sha256=diquzXCQax6wxK-MLfezIJIjdCm9rkRYSFsWMHXU2A4,18367
 chuk_tool_processor/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/tool_executor.py,sha256=SGnOrsQJ8b9dPD_2rYlRyp1WLcwn7pLfbrm5APOsQvo,14387
+chuk_tool_processor/execution/tool_executor.py,sha256=0kxOc6r_LOixANitCOKWX-VJbdquHskSl7fvdzPbOX4,14401
 chuk_tool_processor/execution/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=Mn4gPC9ocxUNHYUMhtALLyR2-DOZphWmBoFSx6_Aelo,22578
-chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=Rb5GTffl-4dkAQG_zz8wjggqyWznVOr9gReLGHmE2io,22469
+chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=95dP4jrCBfFCCEIC5Nld3L_yNEH2E6RZhc5LhNiaFj0,23480
+chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=i_xtKx79OwjXAerGFvrpnfG0L2W1JL98DHt9hwE3MyA,24795
 chuk_tool_processor/execution/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/wrappers/caching.py,sha256=3KDb84ARhDKjUQXrpJT1FaO2pM8ciXFuEdr5zmeLiBM,20410
 chuk_tool_processor/execution/wrappers/rate_limiting.py,sha256=CBBsI1VLosjo8dZXLeJ3IaclGvy9VdjGyqgunY089KQ,9231
 chuk_tool_processor/execution/wrappers/retry.py,sha256=UgJ1UzOGx-HOXfMYmqVfRcMQKT6Q4l2eb4nJJ6nSSps,10144
-chuk_tool_processor/logging/__init__.py,sha256=Uux0QnL6Xcd4vNjtt54rNei3yvxUZ-sOuAahlcPAez0,3382
-chuk_tool_processor/logging/context.py,sha256=vPK7Z4TgLfsSl90exIE6mCqwdrjax_aDa9P6JqnbCsA,8508
+chuk_tool_processor/logging/__init__.py,sha256=UDFPYU_bzeUUSN8qw3nMpo-FMKXetIi7OYtN3W3iPbg,3794
+chuk_tool_processor/logging/context.py,sha256=69EsAhCiya_4zyivz1uUJAhwo0rXpOoTvePWvaFYIi8,12225
 chuk_tool_processor/logging/formatter.py,sha256=RhlV6NqBYRBOtytDY49c9Y1J4l02ZjNXIgVRn03tfSQ,3061
 chuk_tool_processor/logging/helpers.py,sha256=c1mS1sb_rh4bKG0hisyvT7l7cirQfXPSyWeBqmqALRw,5941
 chuk_tool_processor/logging/metrics.py,sha256=s59Au8q0eqGGtJMDqmJBZhbJHh4BWGE1CzT0iI8lRS8,3624
 chuk_tool_processor/mcp/__init__.py,sha256=vR9HHxLpXlKTIIwJJRr3QTmZegcdedR1YKyb46j6FIM,689
-chuk_tool_processor/mcp/mcp_tool.py,sha256=VOyz8uvUGlHOtfypuuOy8qkJx8cc7IIMIjZovQHSuCw,4870
+chuk_tool_processor/mcp/mcp_tool.py,sha256=XZ83UG76TaBqiP5OUfnG78YsYUQ2B1RfncligGHu_zw,8899
 chuk_tool_processor/mcp/register_mcp_tools.py,sha256=ZqR9kikHCbD7InL5cYl9ttUkhA5e4q2S76lbPLWe98I,3636
 chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=Sja3y1uBkqKfpGS69Y90KBb9XNDxKDu3GgQsFqgFiTU,3761
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=emSL1IabdHoFdNUpEJNdzlc9-0qA51ZMuNJHpsYtw5o,2749
-chuk_tool_processor/mcp/stream_manager.py,sha256=oho45ZdxJqYhDk3V9gTDQUvdxFaiPhyj2QRr4rLw4Mw,16902
+chuk_tool_processor/mcp/stream_manager.py,sha256=FRTvvSBzBxU6-kPU1mZOjGCaqi8hHk5_F-h0jXynATg,19118
 chuk_tool_processor/mcp/transport/__init__.py,sha256=7QQqeSKVKv0N9GcyJuYF0R4FDZeooii5RjggvFFg5GY,296
 chuk_tool_processor/mcp/transport/base_transport.py,sha256=bqId34OMQMxzMXtrKq_86sot0_x0NS_ecaIllsCyy6I,3423
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=ZvPJzTJHLEOYCLs1fugyHIofhPzCvlh_3lGH7HxxM4I,19691
-chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=X9NgK_rU1Rw4DpHJ54Et8mICnRbutTZItHdP3PX3dU4,7759
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=nzzMgCgfUV_-Owga2rqJFEc5WLdgXZ922V9maLMwRBI,19408
+chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=5ocANj4wWnYxOZVuz2ttxfyMq3CHkznvIXBtCdBTJvo,7727
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=UVW35YIeMY2B3mpIKZD2rAkyOPayI6ckOOUALyf0YiQ,2115
 chuk_tool_processor/models/streaming_tool.py,sha256=0v2PSPTgZ5TS_PpVdohvVhh99fPwPQM_R_z4RU0mlLM,3541
@@ -43,7 +43,7 @@ chuk_tool_processor/plugins/parsers/openai_tool.py,sha256=O33DyXN0Llqv7AHygE9sVQ
 chuk_tool_processor/plugins/parsers/xml_tool.py,sha256=oIDSWOk38IUKBAMoGuN2hnrAhrhDuO_9L0-p77rEHJw,3182
 chuk_tool_processor/registry/__init__.py,sha256=PBv5QyzHmUJEjgFQW1zgcUmppa5xUTjXTLVsYoVnDQI,2036
 chuk_tool_processor/registry/auto_register.py,sha256=cPod3t1Gng9Dz2-ujqpZBsrpOOcLd7UBJ7L6NqXzXqU,7242
-chuk_tool_processor/registry/decorators.py,sha256=qFK-z7wd53BY7rEbqqWMrWQXbP4UaTLVTCQRI2iUhHI,5035
+chuk_tool_processor/registry/decorators.py,sha256=VBPCPgOQTDT0BT_GiXC4NaIv2Cdxu7ZCNPLoys1nLoA,14207
 chuk_tool_processor/registry/interface.py,sha256=sFacGnhcZXmeK7iF5fSm21ktecYTVzRiyGjxGWSkt-k,3463
 chuk_tool_processor/registry/metadata.py,sha256=lR9FO__lhPr-ax7PhFk8Se1bJdN_48rabiN7qegx4Ns,4582
 chuk_tool_processor/registry/provider.py,sha256=YUCGCFARNxnzV2Dm72Ur4DOrDs_ZYDtCzd6OBBzlis8,5162
@@ -52,7 +52,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=eigwG_So11j7WbDGSWaKd3
 chuk_tool_processor/registry/providers/memory.py,sha256=6cMtUwLO6zrk3pguQRgxJ2CReHAzewgZsizWZhsoStk,5184
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=V5N1dH9sJlHepFIbiI2k2MU82o7nvnh0hKyIt2jdgww,4136
-chuk_tool_processor-0.4.1.dist-info/METADATA,sha256=fk4FL20xDVBGSZEa96BLL2R0ulRbGbUGnKgCruGzWIg,24314
-chuk_tool_processor-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.4.1.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.4.1.dist-info/RECORD,,
+chuk_tool_processor-0.5.dist-info/METADATA,sha256=fo__t2M-CSnUDOPMgmibn8oGbI_zmSEfmtBSRG40OYw,24279
+chuk_tool_processor-0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.5.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.5.dist-info/RECORD,,