dasein-core 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

dasein/capture.py

@@ -445,27 +445,27 @@ class DaseinCallbackHandler(BaseCallbackHandler):
         Called from on_llm_start when tools are detected for a node.
         """
         try:
-            print(f"\n{'='*70}")
-            print(f"[DASEIN][TOOL_PATCH] 🔧 Patching tools for node: {node_name}")
-            print(f"{'='*70}")
+            self._vprint(f"\n{'='*70}")
+            self._vprint(f"[DASEIN][TOOL_PATCH] 🔧 Patching tools for node: {node_name}")
+            self._vprint(f"{'='*70}")
             
             from .wrappers import patch_tool_instance
             
             # Track patched tools to avoid double-patching
             if not hasattr(self, '_patched_tools'):
                 self._patched_tools = set()
-                print(f"[DASEIN][TOOL_PATCH] Initialized patched tools tracker")
+                self._vprint(f"[DASEIN][TOOL_PATCH] Initialized patched tools tracker")
             
             # Find the actual tool objects for this node in the agent graph
-            print(f"[DASEIN][TOOL_PATCH] Searching for tool objects in node '{node_name}'...")
+            self._vprint(f"[DASEIN][TOOL_PATCH] Searching for tool objects in node '{node_name}'...")
             tool_objects = self._find_tool_objects_for_node(node_name)
             
             if not tool_objects:
-                print(f"[DASEIN][TOOL_PATCH] ⚠️  No tool objects found for node '{node_name}'")
-                print(f"{'='*70}\n")
+                self._vprint(f"[DASEIN][TOOL_PATCH] ⚠️  No tool objects found for node '{node_name}'")
+                self._vprint(f"{'='*70}\n")
                 return
             
-            print(f"[DASEIN][TOOL_PATCH] ✓ Found {len(tool_objects)} tool object(s)")
+            self._vprint(f"[DASEIN][TOOL_PATCH] ✓ Found {len(tool_objects)} tool object(s)")
             
             # Patch each tool
             patched_count = 0
@@ -474,28 +474,28 @@ class DaseinCallbackHandler(BaseCallbackHandler):
                 tool_type = type(tool_obj).__name__
                 tool_id = f"{node_name}:{tool_name}"
                 
-                print(f"[DASEIN][TOOL_PATCH] [{i}/{len(tool_objects)}] Tool: '{tool_name}' (type: {tool_type})")
+                self._vprint(f"[DASEIN][TOOL_PATCH] [{i}/{len(tool_objects)}] Tool: '{tool_name}' (type: {tool_type})")
                 
                 if tool_id in self._patched_tools:
-                    print(f"[DASEIN][TOOL_PATCH]   ⏭️  Already patched, skipping")
+                    self._vprint(f"[DASEIN][TOOL_PATCH]   ⏭️  Already patched, skipping")
                 else:
-                    print(f"[DASEIN][TOOL_PATCH]   🔨 Patching...")
+                    self._vprint(f"[DASEIN][TOOL_PATCH]   🔨 Patching...")
                     if patch_tool_instance(tool_obj, self):
                         self._patched_tools.add(tool_id)
                         patched_count += 1
-                        print(f"[DASEIN][TOOL_PATCH]   ✅ Successfully patched '{tool_name}'")
+                        self._vprint(f"[DASEIN][TOOL_PATCH]   ✅ Successfully patched '{tool_name}'")
                     else:
-                        print(f"[DASEIN][TOOL_PATCH]   ❌ Failed to patch '{tool_name}'")
+                        self._vprint(f"[DASEIN][TOOL_PATCH]   ❌ Failed to patch '{tool_name}'")
             
-            print(f"[DASEIN][TOOL_PATCH] Summary: Patched {patched_count}/{len(tool_objects)} tools")
-            print(f"[DASEIN][TOOL_PATCH] Total tools patched so far: {len(self._patched_tools)}")
-            print(f"{'='*70}\n")
+            self._vprint(f"[DASEIN][TOOL_PATCH] Summary: Patched {patched_count}/{len(tool_objects)} tools")
+            self._vprint(f"[DASEIN][TOOL_PATCH] Total tools patched so far: {len(self._patched_tools)}")
+            self._vprint(f"{'='*70}\n")
         
         except Exception as e:
-            print(f"[DASEIN][TOOL_PATCH] ❌ ERROR patching tools for node {node_name}: {e}")
+            self._vprint(f"[DASEIN][TOOL_PATCH] ❌ ERROR patching tools for node {node_name}: {e}")
             import traceback
             traceback.print_exc()
-            print(f"{'='*70}\n")
+            self._vprint(f"{'='*70}\n")
     
     def _search_node_recursively(self, node_name: str, nodes: dict, depth: int = 0) -> list:
         """Recursively search for a node by name in graphs and subgraphs."""
@@ -1823,7 +1823,7 @@ Precedence: AVOID/SKIP > FIX > PREFER > HINT. On conflict, the higher rule ALWAY
 
 {state_context}Checklist (non-negotiable):
 - AVOID: no banned targets under ANY condition.
-- SKIP: bypass skipped steps/tools; NEVER retry them.
+- SKIP: bypass skipped steps/tools; NEVER retry them. All SKIP rules below provide COMPLETE and SUFFICIENT information to proceed safely. Calling skipped tools is REDUNDANT—you already have everything needed.
 - FIX: all required params/settings MUST be included.
 - PREFER: when multiple compliant options exist, choose the preferred—NO exceptions.
 - Recovery: if a banned/skipped item already failed, IMMEDIATELY switch to a compliant alternative.

dasein/events.py

@@ -159,7 +159,7 @@ class EventStore:
     
     def _safe_log_warning(self, msg: str) -> None:
         """Log warning message safely."""
-        print(f"[DASEIN][EVENTS] WARNING: {msg}")
+        # Avoid direct prints; rely on logger
         logger.warning(f"[DASEIN][EVENTS] {msg}")
     
     # Add methods for each entity type

dasein/microturn.py

@@ -411,14 +411,20 @@ async def run_microturn_enforcement(
                 if sig in seen_in_response or sig in patch_depth.seen_tool_signatures:
                     # Duplicate detected
                     duplicates.append((idx, sig))
-                    print(f"[DASEIN][MICROTURN] 🔄 Duplicate detected: {sig}")
+            # Debug duplicate detection only if env enables it
+            import os
+            if os.getenv("DASEIN_DEBUG_MICROTURN", "0") == "1":
+                print(f"[DASEIN][MICROTURN] 🔄 Duplicate detected: {sig}")
                 else:
                     # First occurrence
                     seen_in_response.add(sig)
         
         # DETERMINISTIC DUPLICATE BLOCKING (always on)
         if duplicates and msg:
-            print(f"[DASEIN][MICROTURN] Blocking {len(duplicates)} duplicate call(s)")
+            # Keep this high-signal log behind env flag
+            import os
+            if os.getenv("DASEIN_DEBUG_MICROTURN", "0") == "1":
+                print(f"[DASEIN][MICROTURN] Blocking {len(duplicates)} duplicate call(s)")
             blocked_count, blocked_calls = modify_tool_calls_with_deadletter(
                 msg,
                 [],  # No LLM-based compliant names, just mark duplicates
@@ -429,7 +435,8 @@ async def run_microturn_enforcement(
             
             if blocked_count > 0:
                 update_callback_state(callback_handler, blocked_calls)
-                print(f"[DASEIN][MICROTURN] ✅ Blocked {blocked_count} duplicate(s)")
+                if os.getenv("DASEIN_DEBUG_MICROTURN", "0") == "1":
+                    print(f"[DASEIN][MICROTURN] ✅ Blocked {blocked_count} duplicate(s)")
                 return True
         
         # LLM-BASED MICROTURN (behind flag)
@@ -461,15 +468,20 @@ async def run_microturn_enforcement(
                 
                 if blocked_count > 0:
                     update_callback_state(callback_handler, blocked_calls)
-                    print(f"[DASEIN][MICROTURN] ✅ LLM blocked {blocked_count} call(s): {blocked_calls}")
+                    if os.getenv("DASEIN_DEBUG_MICROTURN", "0") == "1":
+                        print(f"[DASEIN][MICROTURN] ✅ LLM blocked {blocked_count} call(s): {blocked_calls}")
                     return True
         
         # No enforcement applied
         return False
         
     except Exception as e:
-        print(f"[DASEIN][MICROTURN] ⚠️ Error during enforcement: {e}")
+        # Only print on debug; otherwise fail silently
+        import os
+        if os.getenv("DASEIN_DEBUG_MICROTURN", "0") == "1":
+            print(f"[DASEIN][MICROTURN] ⚠️ Error during enforcement: {e}")
         import traceback
-        traceback.print_exc()
+        if os.getenv("DASEIN_DEBUG_MICROTURN", "0") == "1":
+            traceback.print_exc()
         return False
 

dasein/pipecleaner.py

@@ -59,15 +59,15 @@ def _get_embedding_model():
             if _embedding_model is None:
                 try:
                     from sentence_transformers import SentenceTransformer
-                    print("[PIPECLEANER] Loading embedding model: all-MiniLM-L6-v2 (384-dim, ~80MB)...")
+                    _vprint("[PIPECLEANER] Loading embedding model: all-MiniLM-L6-v2 (384-dim, ~80MB)...", True)
                     # Force CPU device to avoid meta tensor issues
                     _embedding_model = SentenceTransformer('all-MiniLM-L6-v2', device='cpu')
-                    print("[PIPECLEANER] ✅ Embedding model loaded successfully (CPU)")
+                    _vprint("[PIPECLEANER] ✅ Embedding model loaded successfully (CPU)", True)
                 except ImportError:
-                    print("[PIPECLEANER] ⚠️  sentence-transformers not installed. Install: pip install sentence-transformers")
+                    _vprint("[PIPECLEANER] ⚠️  sentence-transformers not installed. Install: pip install sentence-transformers", True)
                     raise
                 except Exception as e:
-                    print(f"[PIPECLEANER] ⚠️  Failed to load embedding model: {e}")
+                    _vprint(f"[PIPECLEANER] ⚠️  Failed to load embedding model: {e}", True)
                     raise
     
     return _embedding_model
@@ -79,14 +79,14 @@ def _get_spacy_model():
     if _spacy_nlp is None:
         try:
             import spacy
-            print("[PIPECLEANER] Loading spaCy model: en_core_web_sm...")
+            _vprint("[PIPECLEANER] Loading spaCy model: en_core_web_sm...", True)
             _spacy_nlp = spacy.load("en_core_web_sm")
-            print("[PIPECLEANER] ✅ spaCy model loaded successfully")
+            _vprint("[PIPECLEANER] ✅ spaCy model loaded successfully", True)
         except ImportError:
-            print("[PIPECLEANER] ⚠️  spaCy not installed. Using regex fallback for entities.")
+            _vprint("[PIPECLEANER] ⚠️  spaCy not installed. Using regex fallback for entities.", True)
             _spacy_nlp = "fallback"
         except OSError:
-            print("[PIPECLEANER] ⚠️  spaCy model not found. Using regex fallback for entities.")
+            _vprint("[PIPECLEANER] ⚠️  spaCy model not found. Using regex fallback for entities.", True)
             _spacy_nlp = "fallback"
     return _spacy_nlp
 
@@ -394,7 +394,7 @@ class RunScopedCorpus:
                 # First prompt in batch, start timer at 5s
                 self.batch_start_time = arrival_time
                 self.barrier_duration = 5.0
-                print(f"[CORPUS] ⏱️  Starting batch barrier: 5.0s (first prompt, min wait)")
+                _vprint(f"[CORPUS] ⏱️  Starting batch barrier: 5.0s (first prompt, min wait)", self.verbose)
                 self.batch_timer = threading.Timer(self.barrier_duration, self._process_batch)
                 self.batch_timer.start()
             else:
@@ -421,7 +421,7 @@ class RunScopedCorpus:
         
         if timed_out:
             # Fail open: return original text if batch processing hangs
-            print(f"[CORPUS] ⚠️  Timeout waiting for batch processing, returning original prompt")
+            _vprint(f"[CORPUS] ⚠️  Timeout waiting for batch processing, returning original prompt", self.verbose)
             self.telemetry.chars_out += len(prompt_text)
             return prompt_text
         
@@ -430,7 +430,7 @@ class RunScopedCorpus:
         
         if not deduplicated_text:
             # Safety: if result is missing, return original
-            print(f"[CORPUS] ⚠️  Missing deduplicated result for prompt {prompt_id[:8]}, returning original")
+            _vprint(f"[CORPUS] ⚠️  Missing deduplicated result for prompt {prompt_id[:8]}, returning original", self.verbose)
             self.telemetry.chars_out += len(prompt_text)
             return prompt_text
         
@@ -456,7 +456,7 @@ class RunScopedCorpus:
                 self.telemetry.batches_processed += 1
             
                 # Always show batch summary (key metric)
-                print(f"\n[CORPUS] 🔄 Processing batch: {len(batch_prompts)} prompts, barrier={batch_duration_ms:.0f}ms")
+                _vprint(f"\n[CORPUS] 🔄 Processing batch: {len(batch_prompts)} prompts, barrier={batch_duration_ms:.0f}ms", self.verbose)
         
             # Step 0: Compute embeddings for NEW prompts in this batch (BATCHED operation!)
             # This is done ONCE for the entire batch, allowing parallel arrivals
@@ -563,7 +563,7 @@ class RunScopedCorpus:
             non_isolates = [s for s in all_sentences if degree_map[s.id] > 0]
             pct_isolates = len(isolates_before) / len(all_sentences) * 100 if all_sentences else 0
             avg_degree_non_iso = sum(degree_map[s.id] for s in non_isolates) / len(non_isolates) if non_isolates else 0
-            print(f"[CORPUS] 📊 Graph: isolates={pct_isolates:.1f}% (expect <20%), non-isolate avg degree={avg_degree_non_iso:.1f} (expect >3)")
+            _vprint(f"[CORPUS] 📊 Graph: isolates={pct_isolates:.1f}% (expect <20%), non-isolate avg degree={avg_degree_non_iso:.1f} (expect >3)", self.verbose)
         
             # Step 3: Run greedy maximum-independent-set selection
             # Start with LOCKED sentences (from previous batches, already emitted)
@@ -571,7 +571,7 @@ class RunScopedCorpus:
             selected_sentences = [s for s in all_sentences if s.id in locked_sentences]
             selected_ids = locked_sentences.copy()
         
-            print(f"[CORPUS] 🔒 Pre-seeded MIS with {len(locked_sentences)} locked sentences from previous batches")
+            _vprint(f"[CORPUS] 🔒 Pre-seeded MIS with {len(locked_sentences)} locked sentences from previous batches", self.verbose)
         
             # Now run MIS on NEW sentences only (exclude locked)
             new_sentences = [s for s in all_sentences if s.id not in locked_sentences]
@@ -748,7 +748,7 @@ class RunScopedCorpus:
             # Update telemetry
             self.telemetry.entity_coverage_avg = final_node_coverage * 100  # Now tracking NODE coverage
             # Always show final batch summary (key metric)
-            print(f"[CORPUS] ✅ Batch complete: Node coverage {final_node_coverage*100:.1f}%")
+            _vprint(f"[CORPUS] ✅ Batch complete: Node coverage {final_node_coverage*100:.1f}%", self.verbose)
         
             # Update telemetry
             if self.telemetry.barrier_times:
@@ -831,9 +831,9 @@ def cleanup_corpus(run_id: str):
     with _corpus_lock:
         if run_id in _run_corpuses:
             corpus = _run_corpuses[run_id]
-            print(corpus.get_telemetry_summary())
+            _vprint(corpus.get_telemetry_summary(), getattr(corpus, 'verbose', False))
             del _run_corpuses[run_id]
-            print(f"[CORPUS] 🗑️  Cleaned up corpus for run_id={run_id[:8]}")
+            _vprint(f"[CORPUS] 🗑️  Cleaned up corpus for run_id={run_id[:8]}", getattr(corpus, 'verbose', False))
 
 
 # ============================================================================

dasein/services/post_run_client.py

@@ -99,10 +99,11 @@ class PostRunClient:
             "performance_tracking_id": request.performance_tracking_id,
             "skip_synthesis": request.skip_synthesis,
             "wait_for_synthesis": request.wait_for_synthesis,
-            "tools_metadata": request.tools_metadata or [],  # Tool metadata for Stage 3.5 tool grounding
-            "graph_metadata": request.graph_metadata or {},  # Graph metadata for Stage 3.5 node grounding
-            "rules_applied": request.rules_applied or [],  # Rule IDs selected and applied
-            "context_hash": request.context_hash,  # Context hash for graph grouping
+            "step_id": request.step_id,
+            "tools_metadata": request.tools_metadata or [],
+            "graph_metadata": request.graph_metadata or {},
+            "rules_applied": request.rules_applied or [],
+            "context_hash": request.context_hash,
         }
         
         logger.info(f"Synthesizing rules for run: {request.run_id}")

dasein/wrappers.py

@@ -31,7 +31,9 @@ def wrap_tools_for_pipecleaner(agent: Any, callback_handler: Any, verbose: bool
     """
     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")
+    # Keep this message silent unless verbose is explicitly enabled
+    if verbose:
+        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
@@ -218,7 +220,10 @@ def _extract_text_from_search_result(result: Any, tool_name: str) -> str:
     
     # Tavily format: list of result dicts
     if isinstance(result, list):
-        print(f"[PIPECLEANER] Extracting from list of {len(result)} search results")
+        # Keep extraction log quiet unless user opts in via env
+        import os
+        if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+            print(f"[PIPECLEANER] Extracting from list of {len(result)} search results")
         for i, item in enumerate(result, 1):
             if isinstance(item, dict):
                 # Extract all text fields
@@ -238,7 +243,9 @@ def _extract_text_from_search_result(result: Any, tool_name: str) -> str:
     elif isinstance(result, dict):
         organic = result.get('organic', []) or result.get('results', [])
         if organic:
-            print(f"[PIPECLEANER] Extracting from dict with {len(organic)} organic results")
+            import os
+            if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+                print(f"[PIPECLEANER] Extracting from dict with {len(organic)} organic results")
             for i, item in enumerate(organic, 1):
                 title = item.get('title', '')
                 url = item.get('link', '') or item.get('url', '')
@@ -260,12 +267,16 @@ def _extract_text_from_search_result(result: Any, tool_name: str) -> str:
     # Fallback: convert to string (but log warning)
     if not extracted_parts:
         result_str = str(result)
-        print(f"[PIPECLEANER] ⚠️  Unknown result format, using str() - may be truncated")
-        print(f"[PIPECLEANER] Result type: {type(result).__name__}")
+        import os
+        if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+            print(f"[PIPECLEANER] ⚠️  Unknown result format, using str() - may be truncated")
+            print(f"[PIPECLEANER] Result type: {type(result).__name__}")
         return result_str
     
     full_text = "\n".join(extracted_parts)
-    print(f"[PIPECLEANER] ✅ Extracted {len(full_text)} chars from {len(extracted_parts)} parts")
+    import os
+    if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+        print(f"[PIPECLEANER] ✅ Extracted {len(full_text)} chars from {len(extracted_parts)} parts")
     return full_text
 
 
@@ -303,13 +314,18 @@ def _apply_pipecleaner_to_result(tool_name: str, result: Any, callback_handler:
         
         # Return deduplicated result (as same type as original if possible)
         if deduplicated_str != result_str:
-            print(f"[PIPECLEANER] ✅ Deduplicated: {len(result_str)} → {len(deduplicated_str)} chars")
+            import os
+            if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+                print(f"[PIPECLEANER] ✅ Deduplicated: {len(result_str)} → {len(deduplicated_str)} chars")
             return deduplicated_str
         
         return result
         
     except Exception as e:
-        print(f"[PIPECLEANER] Error applying pipecleaner: {e}")
+        import os
+        if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+            print(f"[PIPECLEANER] Error applying pipecleaner: {e}")
         import traceback
-        traceback.print_exc()
+        if os.getenv("DASEIN_DEBUG_PIPECLEANER", "0") == "1":
+            traceback.print_exc()
         return result

{dasein_core-0.2.18.dist-info → dasein_core-0.2.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.18
+Version: 0.2.20
 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.18.dist-info → dasein_core-0.2.20.dist-info}/RECORD

@@ -1,17 +1,17 @@
 dasein/__init__.py,sha256=RY0lhaaWB6yJ_5YMRmaHDvQ0eFbc0BGbYNe5OVyxzYE,2316
 dasein/advice_format.py,sha256=5-h4J24L_B2Y9dlmyDuIYtmPCWOGAYoinBEXqpcNg2s,5386
-dasein/api.py,sha256=CpEascY7lekgmrasyA7rJcz_dxbAn-MeIpCuoBXdo3Q,269648
-dasein/capture.py,sha256=MxQJgqiOwSgWYXivRE3WvxKW5wg2tfC5_XD-ywDjY7U,112151
+dasein/api.py,sha256=_eoET8IDYovQqUSzWThgMT6zuSxLkGbLP-JaHJkH6aw,265261
+dasein/capture.py,sha256=xM-JmKAEIrqDWnymHrbwdd7-ZeA9PWiCsw1irdCc2bc,112434
 dasein/config.py,sha256=lXO8JG4RXbodn3gT5yEnuB0VRwWdrRVwhX3Rm06IZmU,1957
-dasein/events.py,sha256=mG-lnOvQoZUhXbrPSjrG4RME6ywUcbSZ04PscoJ15GI,12896
+dasein/events.py,sha256=Im5imxrLLEeuYuNq0LLDsJnbP-rLmANDYDpJhSdIl74,12892
 dasein/extractors.py,sha256=fUFBVH9u2x4cJaM-8Zw4qiIpBF2LvjcdYkMvoXQUpL8,3986
 dasein/injection_strategies.py,sha256=JBAvLnJK4xKqK4D1ZQnklIy-yIKSvWuvm2x0YGDMZVU,6507
 dasein/injector.py,sha256=EItWhlG6oMAf_D7YJnRNyDwAQIK5MsaATu1ig3OENqM,7256
-dasein/microturn.py,sha256=raFDQquEPFu5wxYPv9od0Nli9tdV55kXRn7Mvk1pyso,19081
-dasein/pipecleaner.py,sha256=zRznACW0dGayfr7V_n8g1fL4VC6-xDltwRLICp0BTmI,80464
+dasein/microturn.py,sha256=GO7VbbrBBRZ0cXkxOD-P1PYziQL7lEE02SdVX6mL9is,19733
+dasein/pipecleaner.py,sha256=ZJmPN8kzU04oUWqL0t2JmU4qPRUIxttatx8Gb-U8BZQ,80714
 dasein/trace_buffer.py,sha256=bIyTpU8ZrNFR_TCwS43HvzUrDHpZ2F8pLVDeUE9jpwM,4117
 dasein/types.py,sha256=FjGXZowiRYZzWj5GzSnAnA_-xwYqqE7WmXFCosVyGI8,2974
-dasein/wrappers.py,sha256=YY7Iht-0xhuMKH3bPnUerlaIyCXhHN0dgXKkEyj9OsA,13389
+dasein/wrappers.py,sha256=-X1mdesnruFsPdmTZhH8-dSt3Sy56o_ivjrIIywyj0c,14123
 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
@@ -41,11 +41,11 @@ dasein/models/en_core_web_sm/en_core_web_sm/en_core_web_sm-3.7.1/vocab/strings.j
 dasein/models/en_core_web_sm/en_core_web_sm/en_core_web_sm-3.7.1/vocab/vectors,sha256=FHcraD5yZDbVlIrT__K0PQNu8uu-NFiq_tYATgWkBwY,128
 dasein/models/en_core_web_sm/en_core_web_sm/en_core_web_sm-3.7.1/vocab/vectors.cfg,sha256=_0NZCRlSyM0W8fBIL1dw-4LRcHNo1cyjxGqlAfVS48U,22
 dasein/services/__init__.py,sha256=0o6vKEVSYgGo-u-xDFf7Z4cQr8gIht2YovD6eEXUquE,356
-dasein/services/post_run_client.py,sha256=ZdvQ9s4Gxze0jxbMHwe-sOEhtKg68bR9z6D3lKETfo8,5164
+dasein/services/post_run_client.py,sha256=sfvrzpxQQfSxF1DGG9mjX8gjxBPnMBwlU9lefpHRYzk,5043
 dasein/services/pre_run_client.py,sha256=2-HwdsmZGy0x-G19bxpZEDUc34vxBJBrVsx3ddW2-Aw,4383
 dasein/services/service_adapter.py,sha256=hpADfh-oqSipSu8AvM23n7aVJYMmHjqQqKBM_FhoS3Q,7617
 dasein/services/service_config.py,sha256=8_4tpV4mZvfaOc5_yyHbOyL4rYsPHzkLTEY1rtYgLs8,1629
-dasein_core-0.2.18.dist-info/licenses/LICENSE,sha256=7FHjIFEKl_3hSc3tGUVEWmufC_3oi8rh_2zVuL7jMKs,1091
+dasein_core-0.2.20.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.18.dist-info/METADATA,sha256=1cg0P6VWPhCh8PXRlrYiHLgjJLp-9H_LVkfIDnwdpV4,10330
-dasein_core-0.2.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dasein_core-0.2.18.dist-info/top_level.txt,sha256=6yYY9kltjvvPsg9K6KyMKRtzEr5qM7sHXN7VzmrDtp0,7
-dasein_core-0.2.18.dist-info/RECORD,,
+dasein_core-0.2.20.dist-info/METADATA,sha256=dLFMNEkef2Ym4K_3pxmsI_H2ffmZ1AW6x8qLfyju7fw,10330
+dasein_core-0.2.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dasein_core-0.2.20.dist-info/top_level.txt,sha256=6yYY9kltjvvPsg9K6KyMKRtzEr5qM7sHXN7VzmrDtp0,7
+dasein_core-0.2.20.dist-info/RECORD,,