dasein-core 0.2.9__py3-none-any.whl → 0.2.12__py3-none-any.whl

dasein/api.py

@@ -173,10 +173,8 @@ class DaseinLLMWrapper(BaseChatModel):
         self._vprint(f"[DASEIN][TRACE] LLM result: {result_text[:100]}...")
         self._vprint(f"[DASEIN][METRICS] Tokens: {step['tokens_input']}->{output_tokens} | Time: {duration_ms}ms | Success: {'OK' if success else 'FAIL'}")
         
-        # 🚨 MICROTURN ENFORCEMENT - RUN 1 ONLY
-        run_number = getattr(self._callback_handler, '_run_number', 1) if self._callback_handler else 1
-        print(f"[DASEIN][MICROTURN_DEBUG] run_number={run_number}, callback_handler={self._callback_handler is not None}")
-        if run_number == 1 and self._callback_handler:
+        # 🚨 MICROTURN ENFORCEMENT - DISABLED (can interfere with tool execution)
+        if False:  # Disabled
             try:
                 proposed_func_name = None
                 print(f"[DASEIN][MICROTURN_DEBUG] Checking result for function call...")
@@ -883,28 +881,12 @@ class CognateProxy:
         # Initialize KPI tracking
         self._last_run_kpis = None
         
+        # Initialize wrapped LLM (will be set by _wrap_agent_llm if applicable)
+        self._wrapped_llm = None
+        
         # Wrap the agent's LLM with our trace capture wrapper
         self._wrap_agent_llm()
         
-        # Wrap the agent's tools for pipecleaner deduplication
-        print(f"\n{'='*70}")
-        print(f"[DASEIN] Patching tool execution for pipecleaner...")
-        print(f"{'='*70}")
-        try:
-            from .wrappers import wrap_tools_for_pipecleaner
-            verbose = getattr(self._callback_handler, '_verbose', False)
-            success = wrap_tools_for_pipecleaner(self._agent, self._callback_handler, verbose=verbose)
-            if success:
-                print(f"[DASEIN] ✅ Tool execution patched successfully")
-            else:
-                print(f"[DASEIN] ⚠️  Tool execution patching failed")
-            print(f"{'='*70}\n")
-        except Exception as e:
-            print(f"[DASEIN] ❌ ERROR patching tool execution: {e}")
-            import traceback
-            traceback.print_exc()
-            print(f"{'='*70}\n")
-        
         # Inject universal dead-letter tool
         self._inject_deadletter_tool()
     
@@ -1238,6 +1220,10 @@ class CognateProxy:
                     tool = tool_tuple
                     node_name = None
                 
+                # Unwrap DaseinToolWrapper to get complete metadata (especially args_schema)
+                if hasattr(tool, 'original_tool'):
+                    tool = tool.original_tool
+                
                 tool_meta = {
                     'name': getattr(tool, 'name', str(tool.__class__.__name__)),
                     'description': getattr(tool, 'description', ''),
@@ -1697,7 +1683,69 @@ Follow these rules when planning your actions."""
             self._deadletter_fn = None
     
     def _wrap_agent_llm(self):
-        """Monkey-patch ALL LLM classes found in agent + tools."""
+        """Wrap LLM instance (for SQL agent callbacks) AND monkey-patch (for Pipecleaner)."""
+        try:
+            # STEP 1: Wrap the main agent LLM with DaseinLLMWrapper (captures all _generate calls)
+            # This is critical for SQL agents where callbacks don't propagate properly
+            llm = self._find_llm_recursively(self._agent, max_depth=5)
+            if llm:
+                wrapped_llm = DaseinLLMWrapper(llm, self._callback_handler, verbose=self._verbose)
+                # Replace the original LLM with our wrapped version
+                self._replace_llm_in_structure(self._agent, llm, wrapped_llm, max_depth=5)
+                self._wrapped_llm = wrapped_llm
+                self._vprint(f"[DASEIN][WRAPPER] Successfully wrapped {type(llm).__name__} LLM")
+            else:
+                self._vprint(f"[DASEIN][WRAPPER] Could not find any LLM in agent structure")
+                self._wrapped_llm = None
+            
+            # STEP 2: Monkey-patch LLM classes for Pipecleaner deduplication
+            # This is critical for research agents with Summary calls that need deduplication
+            self._monkey_patch_llm_classes()
+            
+        except Exception as e:
+            self._vprint(f"[DASEIN][WRAPPER] Failed to wrap agent LLM: {e}")
+            import traceback
+            traceback.print_exc()
+            self._wrapped_llm = None
+    
+    def _replace_llm_in_structure(self, obj, original_llm, wrapped_llm, max_depth=5, path=""):
+        """Replace the original LLM with wrapped LLM in the structure."""
+        if max_depth <= 0:
+            return
+        
+        # Special handling for RunnableSequence - check steps
+        if hasattr(obj, 'steps') and hasattr(obj, '__iter__'):
+            for i, step in enumerate(obj.steps):
+                if step is original_llm:
+                    self._vprint(f"[DASEIN][WRAPPER] Replacing LLM at {path}.steps[{i}]")
+                    obj.steps[i] = wrapped_llm
+                    return
+                # Check if step has bound attribute (RunnableBinding)
+                if hasattr(step, 'bound') and step.bound is original_llm:
+                    self._vprint(f"[DASEIN][WRAPPER] Replacing LLM at {path}.steps[{i}].bound")
+                    step.bound = wrapped_llm
+                    return
+                # Recursively search in the step
+                self._replace_llm_in_structure(step, original_llm, wrapped_llm, max_depth - 1, f"{path}.steps[{i}]")
+        
+        # Search in attributes
+        for attr_name in dir(obj):
+            if attr_name.startswith('_'):
+                continue
+            try:
+                attr_value = getattr(obj, attr_name)
+                if attr_value is original_llm:
+                    self._vprint(f"[DASEIN][WRAPPER] Replacing LLM at {path}.{attr_name}")
+                    setattr(obj, attr_name, wrapped_llm)
+                    return
+                # Recursively search in the attribute
+                if hasattr(attr_value, '__dict__') or hasattr(attr_value, '__iter__'):
+                    self._replace_llm_in_structure(attr_value, original_llm, wrapped_llm, max_depth - 1, f"{path}.{attr_name}")
+            except:
+                continue
+    
+    def _monkey_patch_llm_classes(self):
+        """Monkey-patch ALL LLM classes found in agent + tools for Pipecleaner deduplication."""
         try:
             # Find ALL LLMs in agent structure + tools
             print(f"[DASEIN][WRAPPER] Searching for ALL LLMs in agent+tools...")
@@ -1730,10 +1778,10 @@ Follow these rules when planning your actions."""
                 print(f"[DASEIN][WRAPPER] Patching {llm_class.__name__} (found in {location})...")
                 
                 # Check what methods the LLM class has
-                # Only patch TOP-LEVEL methods to avoid double-deduplication from internal calls
+                # Patch both user-facing AND internal methods since SQL agents bypass invoke
                 print(f"[DASEIN][WRAPPER] Checking LLM methods...")
                 methods_to_patch = []
-                for method in ['invoke', 'ainvoke']:  # Only patch user-facing methods, not internal _generate
+                for method in ['invoke', 'ainvoke', '_generate', '_agenerate']:  # Include internal methods for SQL agents
                     if hasattr(llm_class, method):
                         print(f"[DASEIN][WRAPPER]   - Has {method}")
                         methods_to_patch.append(method)
@@ -1828,7 +1876,7 @@ Follow these rules when planning your actions."""
                                                     prompt_strings.append(msg.content)
                                                 elif isinstance(msg, str):
                                                     prompt_strings.append(msg)
-                                                else:
+                                            else:
                                                     prompt_strings.append(str(msg))
                                             
                                             # =============================================================
@@ -1946,6 +1994,7 @@ Follow these rules when planning your actions."""
                                                             break
                                             
                                             if should_dedupe:
+                                                try:
                                                     # Deduplicate each prompt
                                                     from .pipecleaner import get_or_create_corpus
                                                     import hashlib
@@ -1986,53 +2035,56 @@ Follow these rules when planning your actions."""
                                                         kwargs['messages'] = messages_to_dedupe
                                                     elif 'prompts' in kwargs:
                                                         kwargs['prompts'] = messages_to_dedupe
+                                                except Exception as e:
+                                                    print(f"[🔥 HOTPATH] ⚠️ Deduplication error: {e}")
+                                                    import traceback
+                                                    traceback.print_exc()
                                     except Exception as e:
-                                        print(f"[🔥 HOTPATH] ⚠️ Deduplication error: {e}")
+                                        print(f"[🔥 HOTPATH] ⚠️ Error in pipecleaner preprocessing: {e}")
                                         import traceback
                                         traceback.print_exc()
                                 
                                 try:
+                                    # CRITICAL FIX: Ensure callbacks propagate to _generate/_agenerate
+                                    # AgentExecutor doesn't pass run_manager to these internal methods
+                                    # So we need to manually inject the callback handler
+                                    if meth_name in ['_generate', '_agenerate'] and callback_handler:
+                                        if 'run_manager' not in kwargs and hasattr(callback_handler, 'on_llm_start'):
+                                            # Manually trigger on_llm_start since no run_manager
+                                            import uuid
+                                            run_id = uuid.uuid4()
+                                            # Extract messages for on_llm_start
+                                            messages = args[0] if args else []
+                                            prompts = []
+                                            for msg in (messages if isinstance(messages, list) else [messages]):
+                                                if hasattr(msg, 'content'):
+                                                    prompts.append(str(msg.content))
+                                                else:
+                                                    prompts.append(str(msg))
+                                            
+                                            # Call on_llm_start
+                                            callback_handler.on_llm_start(
+                                                serialized={'name': type(self_llm).__name__},
+                                                prompts=prompts,
+                                                run_id=run_id
+                                            )
+                                            
+                                            # Store run_id for on_llm_end
+                                            if not hasattr(self_llm, '_dasein_pending_run_ids'):
+                                                self_llm._dasein_pending_run_ids = []
+                                            self_llm._dasein_pending_run_ids.append(run_id)
+                                    
                                     result = await orig_method(self_llm, *args, **kwargs)
                                     
-                                    # 🚨 MICROTURN ENFORCEMENT - Only if tool_end rules exist
-                                    in_microturn = in_microturn_getter()
-                                    if not in_microturn:
-                                        run_number = getattr(callback_handler, '_run_number', 1) if callback_handler else 1
-                                        if run_number == 1 and callback_handler:
-                                            # GATE: Only run microturn if tool_end rules exist
-                                            from .microturn import has_tool_end_rules, extract_proposed_function_calls, extract_tool_call_signatures
-                                            
-                                            if not has_tool_end_rules(callback_handler):
-                                                # No tool_end rules - silently skip microturn
-                                                pass
-                                            else:
-                                                # Check if we've already processed these specific tool calls (prevents duplicate checks as call stack unwinds)
-                                                temp_names, temp_msg = extract_proposed_function_calls(result)
-                                                if temp_msg:
-                                                    temp_sigs = extract_tool_call_signatures(temp_msg)
-                                                    tool_calls_sig = f"{','.join(sorted(temp_sigs.values()))}" if temp_sigs else "empty"
-                                                else:
-                                                    tool_calls_sig = f"{','.join(sorted(temp_names))}" if temp_names else "empty"
-                                                
-                                                if not hasattr(_patch_depth, 'processed_tool_calls'):
-                                                    _patch_depth.processed_tool_calls = set()
-                                                
-                                                if tool_calls_sig not in _patch_depth.processed_tool_calls:
-                                                    # Mark these specific tool calls as processed
-                                                    _patch_depth.processed_tool_calls.add(tool_calls_sig)
-                                                
-                                                    # Run microturn enforcement (for tool CALLS)
-                                                    from .microturn import run_microturn_enforcement
-                                                    try:
-                                                        await run_microturn_enforcement(
-                                                            result=result,
-                                                            callback_handler=callback_handler,
-                                                            self_llm=self_llm,
-                                                            patch_depth=_patch_depth,
-                                                            use_llm_microturn=USE_LLM_MICROTURN
-                                                        )
-                                                    except Exception as e:
-                                                        print(f"[DASEIN][MICROTURN] ⚠️ Microturn error: {e}")
+                                    # Call on_llm_end if we called on_llm_start
+                                    if meth_name in ['_generate', '_agenerate'] and callback_handler:
+                                        if hasattr(self_llm, '_dasein_pending_run_ids') and self_llm._dasein_pending_run_ids:
+                                            run_id = self_llm._dasein_pending_run_ids.pop(0)
+                                            callback_handler.on_llm_end(result, run_id=run_id)
+                                    
+                                    # 🚨 MICROTURN ENFORCEMENT - DISABLED
+                                    # Microturn can interfere with tool execution, so it's disabled
+                                    # TODO: Re-enable with proper gating if needed for specific use cases
                                     
                                     return result
                                 finally:
@@ -2258,15 +2310,45 @@ Follow these rules when planning your actions."""
                                         traceback.print_exc()
                                 
                                 try:
+                                    # CRITICAL FIX: Ensure callbacks propagate to _generate/_agenerate
+                                    # AgentExecutor doesn't pass run_manager to these internal methods
+                                    # So we need to manually inject the callback handler
+                                    if meth_name in ['_generate', '_agenerate'] and callback_handler:
+                                        if 'run_manager' not in kwargs and hasattr(callback_handler, 'on_llm_start'):
+                                            # Manually trigger on_llm_start since no run_manager
+                                            import uuid
+                                            run_id = uuid.uuid4()
+                                            # Extract messages for on_llm_start
+                                            messages = args[0] if args else []
+                                            prompts = []
+                                            for msg in (messages if isinstance(messages, list) else [messages]):
+                                                if hasattr(msg, 'content'):
+                                                    prompts.append(str(msg.content))
+                                                else:
+                                                    prompts.append(str(msg))
+                                            
+                                            # Call on_llm_start
+                                            callback_handler.on_llm_start(
+                                                serialized={'name': type(self_llm).__name__},
+                                                prompts=prompts,
+                                                run_id=run_id
+                                            )
+                                            
+                                            # Store run_id for on_llm_end
+                                            if not hasattr(self_llm, '_dasein_pending_run_ids'):
+                                                self_llm._dasein_pending_run_ids = []
+                                            self_llm._dasein_pending_run_ids.append(run_id)
+                                    
                                     result = orig_method(self_llm, *args, **kwargs)
                                     
-                                    # 🚨 MICROTURN ENFORCEMENT - Only at the DEEPEST level (max depth)
-                                    if current_depth == max_depth_getter():
-                                        run_number = getattr(callback_handler, '_run_number', 1) if callback_handler else 1
-                                        if run_number == 1 and callback_handler:
-                                            print(f"[DASEIN][MICROTURN_DEBUG] 🎯 DEEPEST METHOD: {meth_name} (depth={current_depth}) - Checking result...")
-                                            print(f"[DASEIN][MICROTURN_DEBUG] Result type: {type(result)}")
-                                            # TODO: Add full microturn logic here
+                                    # Call on_llm_end if we called on_llm_start
+                                    if meth_name in ['_generate', '_agenerate'] and callback_handler:
+                                        if hasattr(self_llm, '_dasein_pending_run_ids') and self_llm._dasein_pending_run_ids:
+                                            run_id = self_llm._dasein_pending_run_ids.pop(0)
+                                            callback_handler.on_llm_end(result, run_id=run_id)
+                                    
+                                    # 🚨 MICROTURN ENFORCEMENT - DISABLED (can interfere with tool execution)
+                                    # TODO: Re-enable with proper gating if needed
                                     
                                     return result
                                 finally:
@@ -2286,7 +2368,7 @@ Follow these rules when planning your actions."""
                     # Mark and apply the patch
                     patched_method._dasein_patched = True
                     setattr(llm_class, method_name, patched_method)
-                    print(f"[DASEIN][WRAPPER] ✅ Patched {method_name}")
+                    print(f"[DASEIN][WRAPPER] Patched {method_name}")
                 
                 # Mark this class as patched
                 patched_classes.add(llm_class)

dasein/capture.py

@@ -87,9 +87,6 @@ class DaseinToolWrapper(BaseTool):
                 # Use original input
                 result = self.original_tool._run(*args, **kwargs)
             
-            # 🧹 PIPECLEANER: Apply deduplication to tool result (microturn-style interception)
-            result = self._apply_pipecleaner_to_result(result)
-            
             # Capture the tool output in the trace
             self._vprint(f"[DASEIN][TOOL_WRAPPER] About to capture tool output for {self.name}")
             self._capture_tool_output(self.name, args, kwargs, result)
@@ -144,9 +141,6 @@ class DaseinToolWrapper(BaseTool):
                 # Use original input
                 result = await self.original_tool._arun(*args, **kwargs)
             
-            # 🧹 PIPECLEANER: Apply deduplication to tool result (microturn-style interception)
-            result = self._apply_pipecleaner_to_result(result)
-            
             # Capture the tool output in the trace
             self._vprint(f"[DASEIN][TOOL_WRAPPER] About to capture tool output for {self.name}")
             self._capture_tool_output(self.name, args, kwargs, result)
@@ -180,9 +174,6 @@ class DaseinToolWrapper(BaseTool):
             # Use original input
             result = await self.original_tool.ainvoke(input_data, config, **kwargs)
         
-        # 🧹 PIPECLEANER: Apply deduplication to tool result (microturn-style interception)
-        result = self._apply_pipecleaner_to_result(result)
-        
         return result
     
     def _apply_micro_turn_injection(self, original_input: str) -> str:
@@ -308,51 +299,6 @@ Apply the rule to fix the input. Return only the corrected input, nothing else."
             self._vprint(f"[DASEIN][MICROTURN] Error executing micro-turn LLM call: {e}")
             return original_input
     
-    def _apply_pipecleaner_to_result(self, result):
-        """
-        Apply pipecleaner deduplication to tool result (microturn-style interception).
-        
-        This is called right after tool execution, before returning result to agent.
-        Similar to how microturn intercepts LLM responses.
-        """
-        try:
-            # Get callback handler's rules
-            if not self.callback_handler or not hasattr(self.callback_handler, '_selected_rules'):
-                return result
-            
-            # Convert result to string
-            result_str = str(result)
-            
-            print(f"[PIPECLEANER DEBUG] Tool wrapper intercepted: {self.name}")
-            print(f"[PIPECLEANER DEBUG] Result length: {len(result_str)} chars")
-            print(f"[PIPECLEANER DEBUG] Rules count: {len(self.callback_handler._selected_rules)}")
-            
-            # Apply pipecleaner if filter search rule exists
-            from .pipecleaner import apply_pipecleaner_if_applicable
-            
-            # Get or initialize cached model from callback handler
-            cached_model = getattr(self.callback_handler, '_pipecleaner_embedding_model', None)
-            
-            deduplicated_str, model = apply_pipecleaner_if_applicable(
-                self.name,
-                result_str,
-                self.callback_handler._selected_rules,
-                cached_model=cached_model
-            )
-            
-            # Cache model for next search
-            if model is not None:
-                self.callback_handler._pipecleaner_embedding_model = model
-            
-            # Return deduplicated result (or original if no filter applied)
-            return deduplicated_str
-            
-        except Exception as e:
-            print(f"[PIPECLEANER] Error in result interception: {e}")
-            import traceback
-            traceback.print_exc()
-            return result
-    
     def _capture_tool_output(self, tool_name, args, kwargs, result):
         """Capture tool output in the trace."""
         try:

dasein/wrappers.py

@@ -29,13 +29,14 @@ def get_pipecleaner_context():
 
 def wrap_tools_for_pipecleaner(agent: Any, callback_handler: Any, verbose: bool = False) -> bool:
     """
-    Instrument tool execution paths for pipecleaner deduplication.
-    
-    Wraps:
-    - ToolNode._run_one/_arun_one (per-invocation choke point)
-    - BaseTool.invoke/ainvoke (catches @tool/StructuredTool)
-    - ToolMessage.__init__ (message construction)
+    DISABLED: This function has been disabled to avoid interfering with tool execution.
     """
+    print(f"[WRAPPERS DISABLED] wrap_tools_for_pipecleaner called but DISABLED - no patching will occur")
+    return False  # Return False to indicate nothing was done
+    
+    # ORIGINAL CODE BELOW - COMPLETELY DISABLED
+    if False:
+        pass
     try:
         import importlib
         

{dasein_core-0.2.9.dist-info → dasein_core-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.9
+Version: 0.2.12
 Summary: Universal memory for agentic AI. Attach a brain to any LangChain/LangGraph agent in a single line.
 Author-email: Dasein Team <support@dasein.ai>
 License: MIT

{dasein_core-0.2.9.dist-info → dasein_core-0.2.12.dist-info}/RECORD

@@ -1,7 +1,7 @@
 dasein/__init__.py,sha256=RY0lhaaWB6yJ_5YMRmaHDvQ0eFbc0BGbYNe5OVyxzYE,2316
 dasein/advice_format.py,sha256=5-h4J24L_B2Y9dlmyDuIYtmPCWOGAYoinBEXqpcNg2s,5386
-dasein/api.py,sha256=Y5-n2foYja1E-1pkD5XkebmyObThXyfS0ZaFq7-j1Ss,251706
-dasein/capture.py,sha256=n-a-uQQgzXMXMwwbvbdAqqO6sD_Q4kjHiReWLozxJrE,113382
+dasein/api.py,sha256=dDOtZVXnfZ3VbiY6N_1u2m3JtiSUwmKC9AO6gxevHxY,256483
+dasein/capture.py,sha256=D4DvknI2wbmVup5WqvNcgw-zW5riEstYG81Rl98uz6o,110942
 dasein/config.py,sha256=lXO8JG4RXbodn3gT5yEnuB0VRwWdrRVwhX3Rm06IZmU,1957
 dasein/events.py,sha256=mG-lnOvQoZUhXbrPSjrG4RME6ywUcbSZ04PscoJ15GI,12896
 dasein/extractors.py,sha256=fUFBVH9u2x4cJaM-8Zw4qiIpBF2LvjcdYkMvoXQUpL8,3986
@@ -11,7 +11,7 @@ dasein/microturn.py,sha256=raFDQquEPFu5wxYPv9od0Nli9tdV55kXRn7Mvk1pyso,19081
 dasein/pipecleaner.py,sha256=Rgw-gJ6NP2k4K7hNt_Lg0Bvs1BOdr4Cf6wFCXdtM0DU,78872
 dasein/trace_buffer.py,sha256=bIyTpU8ZrNFR_TCwS43HvzUrDHpZ2F8pLVDeUE9jpwM,4117
 dasein/types.py,sha256=FjGXZowiRYZzWj5GzSnAnA_-xwYqqE7WmXFCosVyGI8,2974
-dasein/wrappers.py,sha256=oUXnY6DGUAVDOmFz-9UdB8fxgOL_fx5dOxtv6JXQ8Wo,13310
+dasein/wrappers.py,sha256=YY7Iht-0xhuMKH3bPnUerlaIyCXhHN0dgXKkEyj9OsA,13389
 dasein/models/en_core_web_sm/en_core_web_sm/__init__.py,sha256=yOtXB5wD_EFXwif2QXgfvLPp0RQ5q-G_C3LkwPp4o40,237
 dasein/models/en_core_web_sm/en_core_web_sm/meta.json,sha256=X8R1--W7Axckn9flHCLVMFI0W7I_E-rxSf9ZAiOWTRw,10085
 dasein/models/en_core_web_sm/en_core_web_sm/en_core_web_sm-3.7.1/LICENSE,sha256=OTPBdpebaLxtC8yQLH1sEw8dEn9Hbxe6XNuo2Zz9ABI,1056
@@ -45,7 +45,7 @@ dasein/services/post_run_client.py,sha256=UjK3eqf7oWGSuWkKe0vQmeMS0yUUOhYFD4-SZ7
 dasein/services/pre_run_client.py,sha256=tXmz_PQaSfq0xwypiWUAqNkXOmREZ6EwXLC4OM89J-A,4317
 dasein/services/service_adapter.py,sha256=YHk41lR3PXh8WTmxOzzwKf6hwPYGqIdApI92vQKlkAY,7350
 dasein/services/service_config.py,sha256=8_4tpV4mZvfaOc5_yyHbOyL4rYsPHzkLTEY1rtYgLs8,1629
-dasein_core-0.2.9.dist-info/licenses/LICENSE,sha256=7FHjIFEKl_3hSc3tGUVEWmufC_3oi8rh_2zVuL7jMKs,1091
+dasein_core-0.2.12.dist-info/licenses/LICENSE,sha256=7FHjIFEKl_3hSc3tGUVEWmufC_3oi8rh_2zVuL7jMKs,1091
 dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/LICENSE,sha256=OTPBdpebaLxtC8yQLH1sEw8dEn9Hbxe6XNuo2Zz9ABI,1056
 dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/LICENSES_SOURCES,sha256=INnfrNIVESJR8VNB7dGkex-Yvzk6IS8Q8ZT_3H7pipA,2347
 dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/METADATA,sha256=-vGqRxa_M2RwKtLjBhc4JlBQdJ3k7CwOnseT_ReYcic,2958
@@ -53,7 +53,7 @@ dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/RECORD,sha256=dDb6U7
 dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
 dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/entry_points.txt,sha256=OkWs-KxPJtDdpvIFCVXzDC9ECtejhPxv7pP3Tgk2cNg,47
 dasein/models/en_core_web_sm/en_core_web_sm-3.7.1.dist-info/top_level.txt,sha256=56OIuRbEuhr12HsM9XpCMnTtHRMgNC5Hje4Xeo8wF2c,15
-dasein_core-0.2.9.dist-info/METADATA,sha256=tsygy28ayMIG8axna8v1CJRTO-jWnUMHOZwbz7H1XmI,10296
-dasein_core-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dasein_core-0.2.9.dist-info/top_level.txt,sha256=6yYY9kltjvvPsg9K6KyMKRtzEr5qM7sHXN7VzmrDtp0,7
-dasein_core-0.2.9.dist-info/RECORD,,
+dasein_core-0.2.12.dist-info/METADATA,sha256=43WrPvrzNviksaZxsnZNnLh0nPU7vBO8-rdI2J9R-JM,10297
+dasein_core-0.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dasein_core-0.2.12.dist-info/top_level.txt,sha256=6yYY9kltjvvPsg9K6KyMKRtzEr5qM7sHXN7VzmrDtp0,7
+dasein_core-0.2.12.dist-info/RECORD,,