ai-microcore 4.2.2__tar.gz → 4.2.4__tar.gz

{ai_microcore-4.2.2 → ai_microcore-4.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-microcore
-Version: 4.2.2
+Version: 4.2.4
 Summary: # Minimalistic Foundation for AI Applications
 Keywords: llm,large language models,ai,similarity search,ai search,gpt,openai,framework,adapter
 Author-email: Vitalii Stepanenko <mail@vitaliy.in>

{ai_microcore-4.2.2 → ai_microcore-4.2.4}/microcore/__init__.py

@@ -186,4 +186,4 @@ __all__ = [
     # "wrappers",
 ]
 
-__version__ = "4.2.2"
+__version__ = "4.2.4"

{ai_microcore-4.2.2 → ai_microcore-4.2.4}/microcore/mcp.py

@@ -25,12 +25,24 @@ class WrongMcpUsage(BadAIAnswer):
 
 
 class HeaderAuth(httpx.Auth):
-    def __init__(self, header_name, header_value):
-        self.header_name = header_name
-        self.header_value = header_value
+    def __init__(self, header_name_or_dict: str | dict, header_value: str | None = None):
+        if isinstance(header_name_or_dict, dict):
+            if header_value is not None:
+                raise ValueError(
+                    "HeaderAuth: If a dictionary is provided in first argument, "
+                    "header_value should not be set."
+                )
+            self.headers = header_name_or_dict
+        else:
+            if header_value is None:
+                raise ValueError(
+                    "HeaderAuth: header_value must be provided when header_name is a string"
+                )
+            self.headers = {str(header_name_or_dict): str(header_value)}
 
     def auth_flow(self, request):
-        request.headers[self.header_name] = self.header_value
+        for k, v in self.headers.items():
+            request.headers[k] = v
         yield request
 
 
@@ -293,12 +305,8 @@ class MCPServer:
             self.name = MCPServer.name_from_url(self.url)
         if not self.transport:
             self.transport = self._guess_transport_type_by_url(self.url)
-        if self.auth and isinstance(self.auth, dict) and len(self.auth) == 1:
-            header_name, header_value = next(iter(self.auth.items()))
-            self.auth = HeaderAuth(
-                header_name=header_name,
-                header_value=header_value
-            )
+        if self.auth and isinstance(self.auth, dict):
+            self.auth = HeaderAuth(self.auth)
 
     async def connect(
         self,

{ai_microcore-4.2.2 → ai_microcore-4.2.4}/microcore/utils.py

@@ -355,32 +355,57 @@ async def run_parallel(tasks: list, max_concurrent_tasks: int):
     return await asyncio.gather(*[worker(task) for task in tasks])
 
 
+class CantResolveCallable(ValueError):
+    """
+    Raised when a callable cannot be resolved by name.
+    """
+    def __init__(self, message: str = None, name: str = None, e: Exception = None):
+        message = message or f"Can't resolve callable by name '{name}'{', ' + str(e) if e else ''}"
+        super().__init__(message)
+        self.name = name
+
+
 def resolve_callable(
     fn: Union[Callable, str, None], allow_empty=False
 ) -> Union[Callable, None]:
     """
-    Resolves a callable function from a string (module.function)
+    Resolves a callable function from a string.
+    Supported formats:
+      - module[.submodules].function
+      - module[.submodules].ClassName.static_method
     """
     if callable(fn):
         return fn
     if not fn:
         if allow_empty:
             return None
-        raise ValueError("Function is not specified")
+        raise CantResolveCallable("Can't resolve callable: function is not specified")
     try:
         if "." not in fn:
             fn = globals()[fn]
         else:
             parts = fn.split(".")
+            # Try resolve as *module.ClassName.static_method if 1st character is upper-cased
+            if len(parts) >= 3 and len(parts[-2]) and parts[-2][0].isupper():
+                module_name = ".".join(parts[:-2])
+                class_name = parts[-2]
+                try:
+                    module = __import__(module_name, fromlist=[class_name])
+                    cls = getattr(module, class_name)
+                    fn = getattr(cls, parts[-1])
+                    assert callable(fn)
+                    return fn
+                except (ImportError, AttributeError, AssertionError, ValueError):
+                    pass
             module_name = ".".join(parts[:-1])
             func_name = parts[-1]
             if not module_name:
-                raise ValueError(f"Invalid module name: {module_name}")
+                raise CantResolveCallable(f"Invalid module name: {module_name}")
             module = __import__(module_name, fromlist=[func_name])
             fn = getattr(module, func_name)
         assert callable(fn)
     except (ImportError, AttributeError, AssertionError, ValueError) as e:
-        raise ValueError(f"Can't resolve callable by name '{fn}', {e}") from e
+        raise CantResolveCallable(name=fn, e=e) from e
     return fn