langroid 0.53.10__tar.gz → 0.53.12__tar.gz

{langroid-0.53.10 → langroid-0.53.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.53.10
+Version: 0.53.12
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.53.10 → langroid-0.53.12}/langroid/agent/task.py

@@ -578,19 +578,24 @@ class Task:
         return self.pending_message
 
     def init_loggers(self) -> None:
+        """Initialise per-task Rich and TSV loggers."""
+        from langroid.utils.logging import RichFileLogger
+
         if self.caller is not None and self.caller.logger is not None:
             self.logger = self.caller.logger
         elif self.logger is None:
             self.logger = RichFileLogger(
                 str(Path(self.config.logs_dir) / f"{self.name}.log"),
+                append=True,
                 color=self.color_log,
             )
 
         if self.caller is not None and self.caller.tsv_logger is not None:
             self.tsv_logger = self.caller.tsv_logger
         elif self.tsv_logger is None:
+            # unique logger name ensures a distinct `logging.Logger` object
             self.tsv_logger = setup_file_logger(
-                "tsv_logger",
+                f"tsv_logger.{self.name}.{id(self)}",
                 str(Path(self.config.logs_dir) / f"{self.name}.tsv"),
             )
             header = ChatDocLoggerFields().tsv_header()

{langroid-0.53.10 → langroid-0.53.12}/langroid/embedding_models/models.py

@@ -521,7 +521,7 @@ class GeminiEmbeddings(EmbeddingModel):
         for batch in batched(texts, self.config.batch_size):
             result = self.client.models.embed_content(  # type: ignore[attr-defined]
                 model=self.config.model_name,
-                contents=batch,
+                contents=batch,  # type: ignore
             )
 
             if not hasattr(result, "embeddings") or not isinstance(
@@ -532,7 +532,9 @@ class GeminiEmbeddings(EmbeddingModel):
                 )
 
             # Extract .values from ContentEmbedding objects
-            all_embeddings.extend([emb.values for emb in result.embeddings])
+            all_embeddings.extend(
+                [emb.values for emb in result.embeddings]  # type: ignore
+            )
 
         return all_embeddings
 

{langroid-0.53.10 → langroid-0.53.12}/langroid/utils/logging.py

@@ -1,6 +1,8 @@
 import logging
+import os
 import os.path
-from typing import no_type_check
+import threading
+from typing import ClassVar, Dict, no_type_check
 
 import colorlog
 from rich.console import Console
@@ -114,22 +116,86 @@ def setup_loggers_for_package(package_name: str, level: int) -> None:
 
 
 class RichFileLogger:
-    def __init__(self, log_file: str, append: bool = False, color: bool = True):
-        os.makedirs(os.path.dirname(log_file), exist_ok=True)
-        self.log_file = log_file
-        if not append:
-            if os.path.exists(self.log_file):
-                os.remove(self.log_file)
-        self.file = None
-        self.console = None
-        self.append = append
-        self.color = color
+    """Singleton-per-path, ref-counted, thread-safe file logger.
 
+    • Any number of calls to `RichFileLogger(path)` yield the same object.
+    • A per-instance lock guarantees that the underlying file is opened only
+      once, even when many threads construct the logger concurrently.
+    • A reference counter tracks how many parts of the program are using the
+      logger; the FD is closed only when the counter reaches zero.
+    • All writes are serialised with a dedicated write-lock.
+    """
+
+    _instances: ClassVar[Dict[str, "RichFileLogger"]] = {}
+    _ref_counts: ClassVar[Dict[str, int]] = {}
+    # guards _instances & _ref_counts
+    _class_lock: ClassVar[threading.Lock] = threading.Lock()
+
+    # ------------------------------------------------------------------ #
+    # construction / destruction
+    # ------------------------------------------------------------------ #
+    def __new__(
+        cls, log_file: str, append: bool = False, color: bool = True
+    ) -> "RichFileLogger":
+        with cls._class_lock:
+            if log_file in cls._instances:
+                cls._ref_counts[log_file] += 1
+                return cls._instances[log_file]
+
+            inst = super().__new__(cls)
+            # create the per-instance init-lock *before* releasing class-lock
+            inst._init_lock = threading.Lock()
+            cls._instances[log_file] = inst
+            cls._ref_counts[log_file] = 1
+            return inst
+
+    def __init__(self, log_file: str, append: bool = False, color: bool = True) -> None:
+        # Double-checked locking: perform heavy init exactly once.
+        if getattr(self, "_init_done", False):
+            return
+
+        if not hasattr(self, "_init_lock"):
+            self._init_lock: threading.Lock = threading.Lock()
+
+        with self._init_lock:
+            if getattr(self, "_init_done", False):
+                return
+
+            os.makedirs(os.path.dirname(log_file), exist_ok=True)
+            mode = "a" if append else "w"
+            self.file = open(log_file, mode, buffering=1, encoding="utf-8")
+            self.log_file: str = log_file
+            self.color: bool = color
+            self.console: Console | None = (
+                Console(file=self.file, force_terminal=True, width=200)
+                if color
+                else None
+            )
+            self._write_lock = threading.Lock()
+            self._init_done = True  # set last
+
+    # ------------------------------------------------------------------ #
+    # public API
+    # ------------------------------------------------------------------ #
     @no_type_check
     def log(self, message: str) -> None:
-        with open(self.log_file, "a") as f:
-            if self.color:
-                console = Console(file=f, force_terminal=True, width=200)
-                console.print(escape(message))
+        """Thread-safe write to the log file."""
+        with self._write_lock:
+            if self.color and self.console is not None:
+                self.console.print(escape(message))
+            else:
+                print(message, file=self.file)
+            self.file.flush()
+
+    def close(self) -> None:
+        """Decrease ref-count; close FD only when last user is done."""
+        with self._class_lock:
+            count = self._ref_counts.get(self.log_file, 0) - 1
+            if count <= 0:
+                self._ref_counts.pop(self.log_file, None)
+                self._instances.pop(self.log_file, None)
+                with self._write_lock:
+                    if not self.file.closed:
+                        self.file.close()
             else:
-                print(message, file=f)
+                self._ref_counts[self.log_file] = count

{langroid-0.53.10 → langroid-0.53.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langroid"
-version = "0.53.10"
+version = "0.53.12"
 authors = [
     {name = "Prasad Chalasani", email = "pchalasani@gmail.com"},
 ]