integrum 0.1.0__py3-none-any.whl

integrum/__init__.py

@@ -0,0 +1,19 @@
+"""Integrum: Expose any Python module or library as an MCP server."""
+
+from integrum.filter import MemberFilter
+from integrum.inspector import import_target, inspect_class, inspect_function, inspect_module
+from integrum.server import IntegrumServer
+from integrum.store import ObjectStore, WordIdGenerator
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "IntegrumServer",
+    "ObjectStore",
+    "WordIdGenerator",
+    "MemberFilter",
+    "import_target",
+    "inspect_class",
+    "inspect_function",
+    "inspect_module",
+]

integrum/cli.py

@@ -0,0 +1,109 @@
+"""Command line interface for Integrum."""
+
+import sys
+from typing import List, Optional
+import click
+
+from integrum.filter import MemberFilter
+from integrum.inspector import import_target, inspect_class, inspect_function, inspect_module
+from integrum.server import IntegrumServer
+
+
+@click.group()
+@click.version_option()
+def main() -> None:
+    """Integrum: Expose Python modules as Model Context Protocol (MCP) servers."""
+    pass
+
+
+@main.command("expose")
+@click.argument("targets", nargs=-1, required=True)
+@click.option("--name", default="integrum-server", help="Name of the MCP server.")
+@click.option("--include", "-i", multiple=True, help="Regex pattern(s) to include.")
+@click.option("--exclude", "-e", multiple=True, help="Regex pattern(s) to exclude.")
+@click.option(
+    "--transport",
+    "-t",
+    type=click.Choice(["stdio", "http", "sse"], case_sensitive=False),
+    default="stdio",
+    help="MCP transport protocol (default: stdio).",
+)
+@click.option("--host", default="127.0.0.1", help="Host to bind for HTTP/SSE (default: 127.0.0.1).")
+@click.option("--port", "-p", default=8000, type=int, help="Port to bind for HTTP/SSE (default: 8000).")
+def expose_cmd(
+    targets: List[str],
+    name: str,
+    include: List[str],
+    exclude: List[str],
+    transport: str,
+    host: str,
+    port: int,
+) -> None:
+    """Expose TARGETS (modules, classes, or functions) as an MCP server."""
+    server = IntegrumServer(name=name)
+    inc_list = list(include) if include else None
+    exc_list = list(exclude) if exclude else None
+
+    try:
+        registered = server.expose(list(targets), include=inc_list, exclude=exc_list)
+        if not registered:
+            click.echo("Warning: No tools were registered. Check your targets or filter patterns.", err=True)
+        else:
+            click.echo(f"Successfully registered {len(registered)} tools: {', '.join(registered)}", err=True)
+
+        click.echo(f"Starting Integrum MCP server '{name}' via transport={transport}...", err=True)
+        server.run(transport=transport, host=host, port=port)
+    except Exception as e:
+        click.echo(f"Error starting Integrum server: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command("list")
+@click.argument("targets", nargs=-1, required=True)
+@click.option("--include", "-i", multiple=True, help="Regex pattern(s) to include.")
+@click.option("--exclude", "-e", multiple=True, help="Regex pattern(s) to exclude.")
+def list_cmd(targets: List[str], include: List[str], exclude: List[str]) -> None:
+    """Preview the functions and classes that would be exposed from TARGETS."""
+    inc_list = list(include) if include else None
+    exc_list = list(exclude) if exclude else None
+    member_filter = MemberFilter(include=inc_list, exclude=exc_list) if (inc_list or exc_list) else None
+
+    for target_str in targets:
+        try:
+            obj = import_target(target_str)
+        except Exception as e:
+            click.echo(f"Error importing '{target_str}': {e}", err=True)
+            continue
+
+        click.echo(f"\nTarget: {target_str} ({type(obj).__name__})")
+        click.echo("-" * 40)
+
+        import inspect
+        if inspect.isfunction(obj) or inspect.isbuiltin(obj):
+            fn_info = inspect_function(obj)
+            click.echo(f"  [Function] {fn_info.name}{fn_info.signature}")
+            if fn_info.docstring:
+                first_line = fn_info.docstring.strip().split("\n")[0]
+                click.echo(f"             Doc: {first_line}")
+        elif inspect.isclass(obj):
+            cls_info = inspect_class(obj, member_filter=member_filter)
+            click.echo(f"  [Class] {cls_info.name}")
+            click.echo(f"    Constructor: {cls_info.name}_create{cls_info.init_signature}")
+            for m_name, m_info in cls_info.methods.items():
+                click.echo(f"    Method: {cls_info.name}_{m_name}{m_info.signature}")
+        elif inspect.ismodule(obj):
+            mod_info = inspect_module(obj, member_filter=member_filter)
+            if mod_info.functions:
+                click.echo("  Functions:")
+                for fn_name, fn_info in mod_info.functions.items():
+                    click.echo(f"    - {fn_name}{fn_info.signature}")
+            if mod_info.classes:
+                click.echo("  Classes:")
+                for c_name, c_info in mod_info.classes.items():
+                    click.echo(f"    - {c_name} ({len(c_info.methods)} methods)")
+                    for m_name in c_info.methods:
+                        click.echo(f"        * {c_name}_{m_name}")
+
+
+if __name__ == "__main__":
+    main()

integrum/docstrings.py

@@ -0,0 +1,103 @@
+"""Docstring parsing and instruction injection for Integrum FastMCP tools."""
+
+import docstring_parser
+from typing import Dict, Optional
+
+
+SERVER_INSTRUCTIONS = (
+    "This MCP server is dynamically generated by Integrum.\n"
+    "- State Management: Non-primitive Python objects (such as model instances, datasets, "
+    "and arrays) are stored in memory and assigned memorable word IDs (e.g., 'playful_llama', 'swift_falcon').\n"
+    "- Using Objects: When a tool returns an object ID, supply that ID to subsequent tools operating on it. "
+    "For class methods, pass it as the 'obj_id' parameter. "
+    "You can also use dot-notation for sub-attributes (e.g., 'swift_falcon.data' and 'swift_falcon.target')."
+)
+
+
+def format_function_description(
+    raw_doc: Optional[str],
+    is_constructor: bool = False,
+    is_method: bool = False,
+    class_name: Optional[str] = None,
+    function_name: Optional[str] = None,
+) -> str:
+    """Format and enhance tool description with injected instructions."""
+    summary_parts = []
+    param_docs: Dict[str, str] = {}
+
+    if raw_doc:
+        try:
+            parsed = docstring_parser.parse(raw_doc)
+            if parsed.short_description:
+                summary_parts.append(parsed.short_description)
+            if parsed.long_description:
+                # Add first 1-2 paragraphs of long description if reasonable
+                long_desc = parsed.long_description.strip()
+                if len(long_desc) > 500:
+                    long_desc = long_desc[:500] + "..."
+                summary_parts.append(long_desc)
+
+            for param in parsed.params:
+                if param.arg_name and param.description:
+                    param_docs[param.arg_name] = param.description.strip()
+        except Exception:
+            summary_parts.append(raw_doc.strip()[:400])
+    else:
+        if is_constructor:
+            summary_parts.append(f"Create an instance of {class_name}.")
+        elif is_method:
+            summary_parts.append(f"Execute method on {class_name} instance.")
+        else:
+            summary_parts.append("Execute Python function.")
+
+    description_text = "\n\n".join(summary_parts)
+
+    # Injected state management instructions
+    injected_instructions = []
+    if is_constructor:
+        injected_instructions.append(
+            "[STATE INSTRUCTION]: Calling this creates a new instance and returns an object ID "
+            "(e.g. 'playful_llama'). Store this ID to pass as 'obj_id' in subsequent method calls."
+        )
+    elif is_method:
+        injected_instructions.append(
+            "[STATE INSTRUCTION]: Requires 'obj_id' referencing an existing instance. "
+            "Arguments accepting datasets/arrays can accept registered object IDs or dot-notation "
+            "(e.g. 'swift_falcon.data')."
+        )
+    elif function_name == "train_test_split":
+        injected_instructions.append(
+            "[STATE INSTRUCTION]: Pass arrays to split as a list, e.g. arrays=['<id>.data', '<id>.target'] "
+            "(or arrays=['<id>_0', '<id>_1']), or X='...' and y='...'. "
+            "Returns 4 arrays: X_train, X_test, y_train, y_test, which can be passed to subsequent tools."
+        )
+    elif function_name == "accuracy_score":
+        injected_instructions.append(
+            "[STATE INSTRUCTION]: Pass y_true and y_pred as object IDs (e.g. y_true='<split_id>.y_test', "
+            "y_pred='<predictions_id>'). Returns accuracy float."
+        )
+    else:
+        injected_instructions.append(
+            "[STATE INSTRUCTION]: If this function returns a dataset or complex object, it will be "
+            "registered in memory with a word ID. Arguments can also accept registered object IDs."
+        )
+
+    if injected_instructions:
+        description_text += "\n\n" + "\n".join(injected_instructions)
+
+    return description_text
+
+
+def extract_parameter_descriptions(raw_doc: Optional[str]) -> Dict[str, str]:
+    """Extract individual parameter descriptions from docstrings."""
+    if not raw_doc:
+        return {}
+    param_docs = {}
+    try:
+        parsed = docstring_parser.parse(raw_doc)
+        for param in parsed.params:
+            if param.arg_name and param.description:
+                param_docs[param.arg_name] = param.description.strip()
+    except Exception:
+        pass
+    return param_docs

integrum/filter.py

@@ -0,0 +1,60 @@
+"""Regex-based filtering for module members and class methods."""
+
+import re
+from typing import Optional, Pattern, Union, List
+
+
+class MemberFilter:
+    """Filters symbols (functions, classes, methods) using regex patterns."""
+
+    def __init__(
+        self,
+        include: Optional[Union[str, List[str]]] = None,
+        exclude: Optional[Union[str, List[str]]] = None,
+    ) -> None:
+        self.include_patterns: List[Pattern[str]] = self._compile_patterns(include)
+        self.exclude_patterns: List[Pattern[str]] = self._compile_patterns(exclude)
+
+    @staticmethod
+    def _compile_patterns(patterns: Optional[Union[str, List[str]]]) -> List[Pattern[str]]:
+        if not patterns:
+            return []
+        if isinstance(patterns, str):
+            patterns = [patterns]
+        compiled = []
+        for pat in patterns:
+            if pat:
+                try:
+                    compiled.append(re.compile(pat))
+                except re.error as e:
+                    raise ValueError(f"Invalid regex pattern '{pat}': {e}") from e
+        return compiled
+
+    def matches(self, name: str, qualified_name: Optional[str] = None) -> bool:
+        """Check if a symbol name passes include/exclude rules.
+        
+        Args:
+            name: Simple name (e.g. 'fit', 'load_iris')
+            qualified_name: Full name (e.g. 'RandomForestClassifier.fit')
+        """
+        candidates = [name]
+        if qualified_name and qualified_name != name:
+            candidates.append(qualified_name)
+
+        # Check excludes first
+        for pat in self.exclude_patterns:
+            for cand in candidates:
+                if pat.search(cand):
+                    return False
+
+        # If no includes are specified, everything non-excluded passes
+        if not self.include_patterns:
+            return True
+
+        # Check includes
+        for pat in self.include_patterns:
+            for cand in candidates:
+                if pat.search(cand):
+                    return True
+
+        return False

integrum/inspector.py

@@ -0,0 +1,201 @@
+"""Dynamic module, function, and class introspection using inspect."""
+
+import importlib
+import inspect
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+
+from integrum.filter import MemberFilter
+
+
+@dataclass
+class FunctionInfo:
+    """Introspected information about a function or static method."""
+    name: str
+    target: Callable[..., Any]
+    signature: inspect.Signature
+    docstring: Optional[str]
+    is_coroutine: bool = False
+    source_module: Optional[str] = None
+
+
+@dataclass
+class MethodInfo:
+    """Introspected information about a class method."""
+    name: str
+    method: Callable[..., Any]
+    signature: inspect.Signature
+    docstring: Optional[str]
+    is_static: bool = False
+    is_class_method: bool = False
+
+
+@dataclass
+class ClassInfo:
+    """Introspected information about a class."""
+    name: str
+    cls: Type[Any]
+    init_signature: inspect.Signature
+    docstring: Optional[str]
+    methods: Dict[str, MethodInfo] = field(default_factory=dict)
+    source_module: Optional[str] = None
+
+
+@dataclass
+class ModuleInfo:
+    """Introspected information about a module."""
+    name: str
+    functions: Dict[str, FunctionInfo] = field(default_factory=dict)
+    classes: Dict[str, ClassInfo] = field(default_factory=dict)
+
+
+def import_target(target: Union[str, Any]) -> Any:
+    """Import a target string or return the object if already imported.
+    
+    Supports:
+        - 'module' (e.g. 'math')
+        - 'module.submodule' (e.g. 'sklearn.datasets')
+        - 'module.submodule.symbol' (e.g. 'sklearn.datasets.load_iris')
+        - 'module:symbol' (e.g. 'sklearn.datasets:load_iris')
+    """
+    if not isinstance(target, str):
+        return target
+
+    # Handle colon notation
+    if ":" in target:
+        mod_name, attr_name = target.split(":", 1)
+        mod = importlib.import_module(mod_name)
+        curr = mod
+        for part in attr_name.split("."):
+            curr = getattr(curr, part)
+        return curr
+
+    # Try importing directly as module
+    try:
+        return importlib.import_module(target)
+    except ModuleNotFoundError:
+        # If last part is an attribute of a module
+        if "." in target:
+            parts = target.rsplit(".", 1)
+            try:
+                mod = importlib.import_module(parts[0])
+                if hasattr(mod, parts[1]):
+                    return getattr(mod, parts[1])
+            except ModuleNotFoundError:
+                pass
+        raise
+
+
+def inspect_function(func: Callable[..., Any], name: Optional[str] = None) -> FunctionInfo:
+    """Inspect a function using the inspect module."""
+    fn_name = name or getattr(func, "__name__", "anonymous_func")
+    try:
+        sig = inspect.signature(func)
+    except (ValueError, TypeError):
+        sig = inspect.Signature()
+
+    doc = inspect.getdoc(func)
+    is_coro = inspect.iscoroutinefunction(func)
+    mod = getattr(func, "__module__", None)
+
+    return FunctionInfo(
+        name=fn_name,
+        target=func,
+        signature=sig,
+        docstring=doc,
+        is_coroutine=is_coro,
+        source_module=mod,
+    )
+
+
+def inspect_class(
+    cls: Type[Any],
+    name: Optional[str] = None,
+    member_filter: Optional[MemberFilter] = None,
+) -> ClassInfo:
+    """Inspect a class, its constructor, and public methods."""
+    cls_name = name or cls.__name__
+    doc = inspect.getdoc(cls)
+    mod = getattr(cls, "__module__", None)
+
+    # Constructor signature
+    try:
+        init_sig = inspect.signature(cls)
+    except (ValueError, TypeError):
+        try:
+            init_sig = inspect.signature(cls.__init__)
+        except (ValueError, TypeError):
+            init_sig = inspect.Signature()
+
+    methods: Dict[str, MethodInfo] = {}
+
+    for attr_name, member in inspect.getmembers(cls):
+        # Skip private/dunder methods
+        if attr_name.startswith("_"):
+            continue
+
+        # Check filter if provided
+        if member_filter and not member_filter.matches(attr_name, f"{cls_name}.{attr_name}"):
+            continue
+
+        # Distinguish functions/methods
+        if inspect.isfunction(member) or inspect.ismethod(member) or inspect.isbuiltin(member):
+            try:
+                sig = inspect.signature(member)
+            except (ValueError, TypeError):
+                sig = inspect.Signature()
+
+            method_doc = inspect.getdoc(member)
+            # Check static/classmethod attributes
+            raw_attr = getattr(cls, attr_name, member)
+            is_static = isinstance(raw_attr, staticmethod)
+            is_class = isinstance(raw_attr, classmethod)
+
+            methods[attr_name] = MethodInfo(
+                name=attr_name,
+                method=member,
+                signature=sig,
+                docstring=method_doc,
+                is_static=is_static,
+                is_class_method=is_class,
+            )
+
+    return ClassInfo(
+        name=cls_name,
+        cls=cls,
+        init_signature=init_sig,
+        docstring=doc,
+        methods=methods,
+        source_module=mod,
+    )
+
+
+def inspect_module(
+    module: Any,
+    member_filter: Optional[MemberFilter] = None,
+) -> ModuleInfo:
+    """Inspect an entire module for public functions and classes."""
+    mod_name = getattr(module, "__name__", str(module))
+    functions: Dict[str, FunctionInfo] = {}
+    classes: Dict[str, ClassInfo] = {}
+
+    for attr_name, member in inspect.getmembers(module):
+        # Skip private members
+        if attr_name.startswith("_"):
+            continue
+
+        # Respect filter
+        if member_filter and not member_filter.matches(attr_name, f"{mod_name}.{attr_name}"):
+            continue
+
+        if inspect.isclass(member):
+            # Check if class was defined in this module or related package
+            classes[attr_name] = inspect_class(member, name=attr_name, member_filter=member_filter)
+        elif inspect.isfunction(member) or inspect.isbuiltin(member):
+            functions[attr_name] = inspect_function(member, name=attr_name)
+
+    return ModuleInfo(
+        name=mod_name,
+        functions=functions,
+        classes=classes,
+    )

integrum/server.py

@@ -0,0 +1,479 @@
+"""FastMCP server integration and dynamic tool generation for Integrum."""
+
+import inspect
+import json
+import logging
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+
+from fastmcp import FastMCP, Context
+from fastmcp.server.server import Transport
+
+from integrum.docstrings import (
+    SERVER_INSTRUCTIONS,
+    format_function_description,
+    extract_parameter_descriptions,
+)
+from integrum.filter import MemberFilter
+from integrum.inspector import (
+    ClassInfo,
+    FunctionInfo,
+    import_target,
+    inspect_class,
+    inspect_function,
+    inspect_module,
+)
+from integrum.store import ObjectStore
+
+logger = logging.getLogger("integrum")
+
+
+def _get_session_id(ctx: Optional[Context]) -> str:
+    """Extract session ID safely from FastMCP Context, or fallback to 'default'."""
+    if ctx is not None:
+        try:
+            sid = getattr(ctx, "session_id", None)
+            if sid:
+                return str(sid)
+        except Exception:
+            pass
+    return "default"
+
+
+def _build_parameter_list(
+    sig: inspect.Signature,
+    skip_first: bool = False,
+    extra_lead_params: Optional[List[Tuple[str, str]]] = None,
+) -> Tuple[List[str], List[Tuple[str, str, Any, bool]], Optional[str]]:
+    """Parse signature parameters into executable code definitions and metadata.
+    
+    Returns:
+        (param_code_list, param_meta_list, var_pos_param_name)
+    """
+    param_code_list: List[str] = []
+    param_meta_list: List[Tuple[str, str, Any, bool]] = []
+    has_kwonly_marker = False
+    var_pos_param_name: Optional[str] = None
+
+    if extra_lead_params:
+        for name, ann in extra_lead_params:
+            param_code_list.append(f"{name}: {ann}")
+            param_meta_list.append((name, ann, inspect.Parameter.empty, False))
+
+    for i, (name, param) in enumerate(sig.parameters.items()):
+        if name in ("self", "cls"):
+            continue
+        if param.kind == inspect.Parameter.VAR_KEYWORD:
+            continue
+        if param.kind == inspect.Parameter.VAR_POSITIONAL:
+            var_pos_param_name = name
+            param_code_list.append(f"{name}: Any = None")
+            param_meta_list.append((name, "Any", None, True))
+            # If named arrays/args, also support X and y as optional aliases
+            if name in ("arrays", "args") and "X" not in sig.parameters and "y" not in sig.parameters:
+                param_code_list.append("X: Any = None")
+                param_meta_list.append(("X", "Any", None, True))
+                param_code_list.append("y: Any = None")
+                param_meta_list.append(("y", "Any", None, True))
+            continue
+
+        if param.kind == inspect.Parameter.KEYWORD_ONLY and not has_kwonly_marker:
+            param_code_list.append("*")
+            has_kwonly_marker = True
+
+        default = param.default
+        has_default = default is not inspect.Parameter.empty
+
+        ann = "Any"
+        if name == "obj_id":
+            ann = "str"
+        elif param.annotation in (int, float, str, bool):
+            ann = param.annotation.__name__
+
+        if has_default:
+            if isinstance(default, (int, float, str, bool, type(None))):
+                def_repr = repr(default)
+            else:
+                def_repr = "None"
+            param_code_list.append(f"{name}: {ann} = {def_repr}")
+            param_meta_list.append((name, ann, default, True))
+        else:
+            param_code_list.append(f"{name}: {ann}")
+            param_meta_list.append((name, ann, inspect.Parameter.empty, False))
+
+    return param_code_list, param_meta_list, var_pos_param_name
+
+
+def _create_dynamic_wrapper(
+    tool_name: str,
+    docstring: str,
+    param_code_list: List[str],
+    handler: Callable[[Dict[str, Any], Optional[Context]], Any],
+) -> Callable[..., Any]:
+    """Create a typed dynamic function compatible with FastMCP inspection."""
+    full_params = list(param_code_list) + ["ctx: Context = None"]
+    param_str = ", ".join(full_params)
+
+    code = f"""
+def {tool_name}({param_str}) -> Any:
+    kw = locals().copy()
+    kw.pop('ctx', None)
+    return __handler(kw, ctx)
+"""
+    local_ns: Dict[str, Any] = {
+        "Context": Context,
+        "Any": Any,
+        "__handler": handler,
+    }
+    exec(code, local_ns)
+    wrapper = local_ns[tool_name]
+    wrapper.__name__ = tool_name
+    wrapper.__doc__ = docstring
+    return wrapper
+
+
+def _format_result(
+    result: Any,
+    store: ObjectStore,
+    session_id: str,
+    label: str,
+    target_obj_id: Optional[str] = None,
+) -> Any:
+    """Format execution output, registering non-primitive objects in the store."""
+    # If method returned self (like estimator.fit())
+    if target_obj_id is not None and result is store.get(target_obj_id, session_id=session_id):
+        return {
+            "status": "success",
+            "object_id": target_obj_id,
+            "message": f"Successfully executed on object '{target_obj_id}' (returned self).",
+        }
+
+    # If result is primitive
+    if result is None:
+        return {"status": "success", "message": "Execution completed successfully (None)."}
+    if isinstance(result, (int, float, bool)):
+        return result
+    if isinstance(result, str) and len(result) < 500:
+        return result
+
+    # Non-primitive object (numpy array, model, Bunch, dict, dataset, etc.)
+    new_id = store.register(result, label=label, session_id=session_id)
+
+    meta = store.list_objects(session_id=session_id).get(new_id, {})
+    response: Dict[str, Any] = {
+        "status": "success",
+        "object_id": new_id,
+        "type": meta.get("type", type(result).__name__),
+    }
+    if meta.get("shape"):
+        response["shape"] = meta["shape"]
+
+    # If composite (tuple/dict/bunch)
+    if isinstance(result, (tuple, list)):
+        response["items"] = [f"{new_id}_{i}" for i in range(len(result))]
+        if len(result) == 4 and "split" in label.lower():
+            sub_labels = ["X_train", "X_test", "y_train", "y_test"]
+            for idx, sub in enumerate(sub_labels):
+                store._sessions[session_id][f"{new_id}.{sub}"] = result[idx]
+                store._sessions[session_id][f"{new_id}_{sub}"] = result[idx]
+            response["sub_keys"] = [f"{new_id}.{sub}" for sub in sub_labels]
+            response["message"] = (
+                f"train_test_split returned 4 arrays stored under '{new_id}':\n"
+                f"  - X_train: '{new_id}.X_train' (or '{new_id}_0')\n"
+                f"  - X_test:  '{new_id}.X_test' (or '{new_id}_1')\n"
+                f"  - y_train: '{new_id}.y_train' (or '{new_id}_2')\n"
+                f"  - y_test:  '{new_id}.y_test' (or '{new_id}_3')"
+            )
+        else:
+            response["message"] = (
+                f"Stored {type(result).__name__} with object_id '{new_id}'. "
+                f"Access items using: {response['items']}."
+            )
+    elif isinstance(result, dict) or hasattr(result, "keys"):
+        try:
+            keys = list(result.keys())[:10]
+            response["sub_keys"] = [f"{new_id}.{k}" for k in keys]
+            response["message"] = (
+                f"Stored {type(result).__name__} with object_id '{new_id}'. "
+                f"Access sub-keys using dot notation: {response['sub_keys']}."
+            )
+        except Exception:
+            response["message"] = f"Stored {type(result).__name__} with object_id '{new_id}'."
+    else:
+        response["message"] = f"Stored {type(result).__name__} with object_id '{new_id}'."
+
+    return response
+
+
+class IntegrumServer:
+    """Converts Python modules, classes, and functions into a FastMCP server with state management."""
+
+    def __init__(
+        self,
+        name: str = "integrum-server",
+        store: Optional[ObjectStore] = None,
+        instructions: Optional[str] = None,
+    ) -> None:
+        self.name = name
+        self.store = store or ObjectStore()
+        self.instructions = instructions or SERVER_INSTRUCTIONS
+        self.mcp = FastMCP(name=self.name, instructions=self.instructions)
+        self._registered_tool_names: set[str] = set()
+
+        # Register utility tools
+        self._register_utility_tools()
+
+    def _register_utility_tools(self) -> None:
+        """Register built-in utility tools for inspecting stored objects."""
+        store = self.store
+
+        def list_stored_objects(ctx: Context = None) -> Dict[str, Any]:
+            """List all objects currently held in memory for this session."""
+            session_id = _get_session_id(ctx)
+            return {"session_id": session_id, "objects": store.list_objects(session_id=session_id)}
+
+        def inspect_stored_object(obj_id: str, ctx: Context = None) -> Dict[str, Any]:
+            """Inspect detailed attributes, shape, and representation of a stored object."""
+            session_id = _get_session_id(ctx)
+            if not store.has(obj_id, session_id=session_id):
+                return {"error": f"Object '{obj_id}' not found in session '{session_id}'."}
+            obj = store.get(obj_id, session_id=session_id)
+            attrs = [a for a in dir(obj) if not a.startswith("_")][:25]
+            return {
+                "object_id": obj_id,
+                "type": type(obj).__name__,
+                "repr": repr(obj)[:500],
+                "shape": getattr(obj, "shape", None),
+                "public_attributes": attrs,
+            }
+
+        self.mcp.tool(list_stored_objects)
+        self.mcp.tool(inspect_stored_object)
+        self._registered_tool_names.add("list_stored_objects")
+        self._registered_tool_names.add("inspect_stored_object")
+
+    def expose_function(self, func: Callable[..., Any], name: Optional[str] = None) -> str:
+        """Expose a standalone function as an MCP tool."""
+        info = inspect_function(func, name=name)
+        tool_name = info.name
+        if tool_name in self._registered_tool_names:
+            return tool_name
+
+        doc = format_function_description(info.docstring, is_constructor=False, is_method=False, function_name=tool_name)
+        param_code, _, var_pos_name = _build_parameter_list(info.signature)
+
+        store = self.store
+        target_fn = info.target
+
+        def handler(kwargs: Dict[str, Any], ctx: Optional[Context]) -> Any:
+            session_id = _get_session_id(ctx)
+            pos_args = []
+            if var_pos_name and var_pos_name in kwargs and kwargs[var_pos_name] is not None:
+                val = kwargs.pop(var_pos_name)
+                if isinstance(val, (list, tuple)):
+                    pos_args.extend([store.resolve(x, session_id=session_id) for x in val])
+                else:
+                    pos_args.append(store.resolve(val, session_id=session_id))
+            # Fallback if caller passed X and y as named arguments
+            if not pos_args and "X" in kwargs and "y" in kwargs:
+                x_val = kwargs.pop("X", None)
+                y_val = kwargs.pop("y", None)
+                if x_val is not None or y_val is not None:
+                    pos_args.extend([
+                        store.resolve(x_val, session_id=session_id),
+                        store.resolve(y_val, session_id=session_id),
+                    ])
+            kwargs.pop("X", None)
+            kwargs.pop("y", None)
+
+            resolved_kwargs = {
+                k: store.resolve(v, session_id=session_id)
+                for k, v in kwargs.items()
+                if v is not None or k in info.signature.parameters
+            }
+            try:
+                res = target_fn(*pos_args, **resolved_kwargs)
+            except Exception as e:
+                return {"error": f"Error executing {tool_name}: {e}"}
+            return _format_result(res, store, session_id, label=tool_name)
+
+        wrapper = _create_dynamic_wrapper(tool_name, doc, param_code, handler)
+        self.mcp.tool(wrapper)
+        self._registered_tool_names.add(tool_name)
+        logger.info(f"Registered function tool: {tool_name}")
+        return tool_name
+
+    def expose_class(
+        self,
+        cls: Type[Any],
+        name: Optional[str] = None,
+        member_filter: Optional[MemberFilter] = None,
+    ) -> List[str]:
+        """Expose a class constructor and its public methods as MCP tools."""
+        info = inspect_class(cls, name=name, member_filter=member_filter)
+        cls_name = info.name
+        registered = []
+        store = self.store
+
+        # 1. Constructor tool: <ClassName>_create
+        ctor_tool_name = f"{cls_name}_create"
+        if ctor_tool_name not in self._registered_tool_names:
+            ctor_doc = format_function_description(
+                info.docstring,
+                is_constructor=True,
+                class_name=cls_name,
+            )
+            param_code, _, _ = _build_parameter_list(info.init_signature, skip_first=True)
+
+            def ctor_handler(kwargs: Dict[str, Any], ctx: Optional[Context]) -> Any:
+                session_id = _get_session_id(ctx)
+                resolved_kwargs = {k: store.resolve(v, session_id=session_id) for k, v in kwargs.items()}
+                try:
+                    instance = cls(**resolved_kwargs)
+                except Exception as e:
+                    return {"error": f"Error instantiating {cls_name}: {e}"}
+                obj_id = store.register(instance, label=cls_name, session_id=session_id)
+                return {
+                    "status": "success",
+                    "object_id": obj_id,
+                    "class": cls_name,
+                    "message": (
+                        f"Created {cls_name} instance with object_id '{obj_id}'. "
+                        f"Use obj_id='{obj_id}' in subsequent method calls like {cls_name}_fit."
+                    ),
+                }
+
+            wrapper = _create_dynamic_wrapper(ctor_tool_name, ctor_doc, param_code, ctor_handler)
+            self.mcp.tool(wrapper)
+            self._registered_tool_names.add(ctor_tool_name)
+            registered.append(ctor_tool_name)
+            logger.info(f"Registered constructor tool: {ctor_tool_name}")
+
+        # 2. Methods: <ClassName>_<method_name>
+        for method_name, method_info in info.methods.items():
+            method_tool_name = f"{cls_name}_{method_name}"
+            if method_tool_name in self._registered_tool_names:
+                continue
+
+            method_doc = format_function_description(
+                method_info.docstring,
+                is_method=True,
+                class_name=cls_name,
+            )
+            # Add virtual parameter 'obj_id'
+            param_code, _, _ = _build_parameter_list(
+                method_info.signature,
+                skip_first=True,
+                extra_lead_params=[("obj_id", "str")],
+            )
+
+            # Closure capture for method dispatch
+            def make_method_handler(m_name: str) -> Callable[[Dict[str, Any], Optional[Context]], Any]:
+                def m_handler(kwargs: Dict[str, Any], ctx: Optional[Context]) -> Any:
+                    session_id = _get_session_id(ctx)
+                    obj_id = kwargs.pop("obj_id", None)
+                    if not obj_id or not store.has(obj_id, session_id=session_id):
+                        return {
+                            "error": (
+                                f"Object ID '{obj_id}' not found in session '{session_id}'. "
+                                f"Available objects: {list(store.list_objects(session_id=session_id).keys())}."
+                            )
+                        }
+                    instance = store.get(obj_id, session_id=session_id)
+                    resolved_kwargs = {k: store.resolve(v, session_id=session_id) for k, v in kwargs.items()}
+                    try:
+                        bound_method = getattr(instance, m_name)
+                        res = bound_method(**resolved_kwargs)
+                    except Exception as e:
+                        return {"error": f"Error executing {cls_name}.{m_name} on {obj_id}: {e}"}
+                    return _format_result(
+                        res,
+                        store,
+                        session_id,
+                        label=f"{cls_name}_{m_name}",
+                        target_obj_id=obj_id,
+                    )
+                return m_handler
+
+            wrapper = _create_dynamic_wrapper(
+                method_tool_name,
+                method_doc,
+                param_code,
+                make_method_handler(method_name),
+            )
+            self.mcp.tool(wrapper)
+            self._registered_tool_names.add(method_tool_name)
+            registered.append(method_tool_name)
+            logger.info(f"Registered method tool: {method_tool_name}")
+
+        return registered
+
+    def expose_module(
+        self,
+        module: Any,
+        member_filter: Optional[MemberFilter] = None,
+    ) -> List[str]:
+        """Expose all matching functions and classes from a module."""
+        mod_info = inspect_module(module, member_filter=member_filter)
+        registered: List[str] = []
+
+        for fn_name, fn_info in mod_info.functions.items():
+            tool_name = self.expose_function(fn_info.target, name=fn_name)
+            registered.append(tool_name)
+
+        for cls_name, cls_info in mod_info.classes.items():
+            tools = self.expose_class(cls_info.cls, name=cls_name, member_filter=member_filter)
+            registered.extend(tools)
+
+        return registered
+
+    def expose(
+        self,
+        targets: Union[str, List[str], Any],
+        include: Optional[Union[str, List[str]]] = None,
+        exclude: Optional[Union[str, List[str]]] = None,
+    ) -> List[str]:
+        """Expose one or more modules, classes, or functions.
+        
+        Args:
+            targets: Target string(s) (e.g. 'sklearn.datasets.load_iris') or module/class objects.
+            include: Optional regex pattern(s) to include.
+            exclude: Optional regex pattern(s) to exclude.
+        """
+        member_filter = MemberFilter(include=include, exclude=exclude) if (include or exclude) else None
+
+        if not isinstance(targets, list):
+            targets = [targets]
+
+        registered: List[str] = []
+        for target in targets:
+            obj = import_target(target)
+            if inspect.isclass(obj):
+                registered.extend(self.expose_class(obj, member_filter=member_filter))
+            elif inspect.isfunction(obj) or inspect.isbuiltin(obj):
+                name = getattr(obj, "__name__", None)
+                registered.append(self.expose_function(obj, name=name))
+            elif inspect.ismodule(obj):
+                registered.extend(self.expose_module(obj, member_filter=member_filter))
+            else:
+                # Any other callable
+                if callable(obj):
+                    registered.append(self.expose_function(obj))
+                else:
+                    raise TypeError(f"Target '{target}' is not a module, class, or callable.")
+
+        return registered
+
+    def run(
+        self,
+        transport: str = "stdio",
+        host: str = "127.0.0.1",
+        port: int = 8000,
+    ) -> None:
+        """Run the MCP server using FastMCP."""
+        transport_normalized = transport.lower()
+        if transport_normalized in ("http", "streamable-http"):
+            self.mcp.run(transport="http", host=host, port=port)
+        elif transport_normalized == "sse":
+            self.mcp.run(transport="sse", host=host, port=port)
+        else:
+            self.mcp.run(transport="stdio")

integrum/store.py

@@ -0,0 +1,224 @@
+"""State management and token-saving word-based object store for Integrum."""
+
+import inspect
+import random
+from typing import Any, Dict, List, Optional, Tuple
+
+
+ADJECTIVES: List[str] = [
+    "playful", "swift", "calm", "clever", "brave", "bright", "gentle", "silent",
+    "golden", "cosmic", "frosty", "amber", "emerald", "lively", "agile", "mighty",
+    "nimble", "vibrant", "serene", "dapper", "sunny", "quiet", "daring", "eager",
+    "fuzzy", "grand", "happy", "jolly", "keen", "lucid", "merry", "noble",
+    "polar", "quick", "radiant", "stellar", "tidy", "unique", "valiant", "warm",
+    "witty", "zen", "bold", "crisp", "dawn", "fleet", "gleaming", "honest",
+    "iron", "jade", "kind", "lunar", "mystic", "nova", "optic", "proud",
+]
+
+NOUNS: List[str] = [
+    "llama", "falcon", "otter", "badger", "dolphin", "fox", "panda", "tiger",
+    "eagle", "sparrow", "wolf", "lynx", "bear", "hawk", "koala", "bison",
+    "raven", "crane", "beaver", "puma", "finch", "jaguar", "lemur", "moose",
+    "newt", "owl", "quail", "robin", "seal", "swan", "viper", "walrus",
+    "yak", "zebra", "comet", "river", "cedar", "coral", "ember", "glacier",
+    "haven", "island", "meadow", "oasis", "pebble", "ridge", "shadow", "valley",
+]
+
+
+class WordIdGenerator:
+    """Generates memorable, token-efficient word IDs like 'playful_llama'."""
+
+    def __init__(self, seed: Optional[int] = None) -> None:
+        self._rng = random.Random(seed)
+        self._used_ids: set[str] = set()
+
+    def generate(self, prefix: Optional[str] = None) -> str:
+        """Generate a unique word ID.
+        
+        Args:
+            prefix: Optional hint prefix, though word pairs are preferred to save tokens.
+        """
+        for _ in range(500):
+            adj = self._rng.choice(ADJECTIVES)
+            noun = self._rng.choice(NOUNS)
+            word_id = f"{adj}_{noun}"
+            if word_id not in self._used_ids:
+                self._used_ids.add(word_id)
+                return word_id
+
+        # Fallback if dictionary space is heavily populated
+        counter = 1
+        while True:
+            adj = self._rng.choice(ADJECTIVES)
+            noun = self._rng.choice(NOUNS)
+            word_id = f"{adj}_{noun}_{counter}"
+            if word_id not in self._used_ids:
+                self._used_ids.add(word_id)
+                return word_id
+            counter += 1
+
+    def release(self, word_id: str) -> None:
+        """Release a word ID back to the generator."""
+        self._used_ids.discard(word_id)
+
+
+class ObjectStore:
+    """In-memory multi-session store for Python objects with dot-notation resolution."""
+
+    def __init__(self) -> None:
+        # session_id -> {obj_id -> python_object}
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+        # session_id -> {obj_id -> metadata_dict}
+        self._metadata: Dict[str, Dict[str, Dict[str, Any]]] = {}
+        self._id_generators: Dict[str, WordIdGenerator] = {}
+
+    def _get_generator(self, session_id: str) -> WordIdGenerator:
+        if session_id not in self._id_generators:
+            self._id_generators[session_id] = WordIdGenerator()
+        return self._id_generators[session_id]
+
+    def _ensure_session(self, session_id: str) -> None:
+        if session_id not in self._sessions:
+            self._sessions[session_id] = {}
+            self._metadata[session_id] = {}
+
+    def register(self, obj: Any, label: Optional[str] = None, session_id: str = "default") -> str:
+        """Register an object into the store and return its word ID.
+        
+        Also generates child references for composite objects (e.g. tuples or bunches).
+        """
+        self._ensure_session(session_id)
+        generator = self._get_generator(session_id)
+        obj_id = generator.generate()
+
+        self._sessions[session_id][obj_id] = obj
+
+        # Metadata summary
+        type_name = type(obj).__name__
+        module_name = getattr(type(obj), "__module__", "")
+        full_type = f"{module_name}.{type_name}" if module_name else type_name
+
+        try:
+            shape = getattr(obj, "shape", None)
+            if shape is not None:
+                shape_str = str(shape)
+            elif hasattr(obj, "__len__") and not isinstance(obj, (str, bytes)):
+                shape_str = f"len={len(obj)}"
+            else:
+                shape_str = None
+        except Exception:
+            shape_str = None
+
+        meta: Dict[str, Any] = {
+            "type": full_type,
+            "label": label or type_name,
+            "shape": shape_str,
+            "repr": repr(obj)[:120],
+        }
+
+        # If object is a tuple/list, register indexed shortcuts
+        if isinstance(obj, (tuple, list)):
+            item_ids = []
+            for idx, item in enumerate(obj):
+                child_id = f"{obj_id}_{idx}"
+                self._sessions[session_id][child_id] = item
+                item_ids.append(child_id)
+            meta["items"] = item_ids
+
+        # If object has keys/attributes (e.g. scikit-learn Bunch or dict), record available sub-paths
+        if isinstance(obj, dict) or hasattr(obj, "keys"):
+            try:
+                keys = list(obj.keys())[:10]
+                meta["keys"] = keys
+            except Exception:
+                pass
+
+        self._metadata[session_id][obj_id] = meta
+        return obj_id
+
+    def has(self, key: str, session_id: str = "default") -> bool:
+        """Check if an object or valid dot-notation path exists."""
+        self._ensure_session(session_id)
+        if key in self._sessions[session_id]:
+            return True
+        try:
+            self.get(key, session_id=session_id)
+            return True
+        except KeyError:
+            return False
+
+    def get(self, key: str, session_id: str = "default") -> Any:
+        """Retrieve an object by key, supporting dot-notation attribute and index access."""
+        self._ensure_session(session_id)
+        session_store = self._sessions[session_id]
+
+        if key in session_store:
+            return session_store[key]
+
+        # Check dot notation e.g. 'playful_llama.data' or index access 'playful_llama[0]'
+        if "." in key:
+            parts = key.split(".")
+            root_id = parts[0]
+            if root_id in session_store:
+                curr = session_store[root_id]
+                for part in parts[1:]:
+                    if isinstance(curr, dict) and part in curr:
+                        curr = curr[part]
+                    elif hasattr(curr, part):
+                        curr = getattr(curr, part)
+                    else:
+                        raise KeyError(f"Attribute or key '{part}' not found on object '{root_id}'")
+                return curr
+
+        # Check bracket indexing e.g. 'playful_llama[0]'
+        if "[" in key and key.endswith("]"):
+            root_id, index_str = key[:-1].split("[", 1)
+            if root_id in session_store:
+                curr = session_store[root_id]
+                try:
+                    idx = int(index_str)
+                    return curr[idx]
+                except (ValueError, IndexError, TypeError) as e:
+                    raise KeyError(f"Index [{index_str}] invalid on object '{root_id}': {e}")
+
+        available = list(session_store.keys())
+        raise KeyError(
+            f"Object '{key}' not found in session '{session_id}'. "
+            f"Available objects: {available}"
+        )
+
+    def resolve(self, val: Any, session_id: str = "default") -> Any:
+        """Resolve a value to an underlying stored object if it references one."""
+        if isinstance(val, str):
+            # Strip whitespace
+            stripped = val.strip()
+            # If it's a registered ID or dot-notation path, resolve it
+            if self.has(stripped, session_id=session_id):
+                return self.get(stripped, session_id=session_id)
+        return val
+
+    def list_objects(self, session_id: str = "default") -> Dict[str, Dict[str, Any]]:
+        """List summary of all primary objects stored in this session."""
+        self._ensure_session(session_id)
+        return dict(self._metadata[session_id])
+
+    def delete(self, key: str, session_id: str = "default") -> bool:
+        """Delete an object from this session."""
+        self._ensure_session(session_id)
+        if key in self._sessions[session_id]:
+            del self._sessions[session_id][key]
+            self._metadata[session_id].pop(key, None)
+            self._get_generator(session_id).release(key)
+            return True
+        return False
+
+    def clear(self, session_id: Optional[str] = None) -> None:
+        """Clear objects for a specific session, or all sessions if None."""
+        if session_id is not None:
+            self._sessions.pop(session_id, None)
+            self._metadata.pop(session_id, None)
+            self._id_generators.pop(session_id, None)
+        else:
+            self._sessions.clear()
+            self._metadata.clear()
+            self._id_generators.clear()

integrum-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.5
+Name: integrum
+Version: 0.1.0
+Summary: Convert any Python module or library into an MCP server with FastMCP and stateful word-based object management.
+Author: Integrum Team
+License: MIT
+Keywords: fastmcp,llm,mcp,reflection,scikit-learn,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.0
+Requires-Dist: docstring-parser>=0.16
+Requires-Dist: fastmcp>=4.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: test
+Requires-Dist: openai>=1.30.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'
+Requires-Dist: python-dotenv>=1.0.0; extra == 'test'
+Requires-Dist: scikit-learn>=1.4.0; extra == 'test'
+Requires-Dist: tenacity>=8.2.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="src/integrum/logo.png" alt="Integrum Logo" width="180"/>
+</p>
+
+<h1 align="center">Integrum</h1>
+
+<p align="center">
+  <em>Convert any Python module or library into a FastMCP Model Context Protocol server.</em>
+</p>
+
+**Integrum** turns any Python module, library, function, or class into a [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server powered by [FastMCP](https://github.com/jlowin/fastmcp).
+
+Integrum uses Python reflection (`inspect`), regex filtering, and an in-memory **Word-Based Object Store** (`playful_llama`, `swift_falcon`) so that object-oriented libraries (such as `scikit-learn`, `pandas`, `PyTorch`) can be used naturally by LLMs across multi-turn conversations without token bloat.
+
+## Features
+
+- **Module Reflection**: Automatically introspects functions and classes using `inspect`.
+- **Regex Filtering**: Expose only what you need with `--include` and `--exclude` regex patterns.
+- **Word-Based State Management**: Object IDs are short, memorable words (e.g. `playful_llama`) to save tokens and avoid UUID hallucination.
+- **Multi-User Isolation**: Supports FastMCP `Context` sessions to partition objects per connecting client.
+- **Docstring Instruction Injection**: Transforms Python docstrings into LLM tool documentation and automatically injects state-handling instructions.
+- **Dot-Notation Attribute Resolution**: Pass `swift_falcon.data` or `swift_falcon.target` directly to subsequent tool calls like `fit()`.
+- **CLI & Python API**: Run from the command line (`integrum expose`) or integrate directly into Python scripts.
+
+## Installation
+
+```bash
+uv pip install integrum
+# or
+pip install integrum
+```
+
+## Quick Start (CLI)
+
+Expose `scikit-learn` dataset loaders and RandomForestClassifier as an MCP server:
+
+```bash
+integrum expose sklearn.datasets.load_iris sklearn.ensemble.RandomForestClassifier
+```
+
+Preview what tools will be exposed:
+
+```bash
+integrum list sklearn.datasets.load_iris sklearn.ensemble.RandomForestClassifier
+```
+
+Filter functions and methods with regex:
+
+```bash
+integrum expose sklearn.datasets sklearn.ensemble \
+  --include "^(load_iris|RandomForestClassifier)$"
+```
+
+Run with HTTP or SSE transport:
+
+```bash
+integrum expose sklearn.datasets.load_iris --transport http --port 8000
+```
+
+## Python API
+
+```python
+from integrum import IntegrumServer
+
+server = IntegrumServer(name="ml-server")
+server.expose(["sklearn.datasets.load_iris", "sklearn.ensemble.RandomForestClassifier"])
+
+# Run over stdio (default for MCP desktop clients)
+server.run(transport="stdio")
+```
+
+## How State Management Works
+
+When a class is exposed, Integrum registers:
+1. `<ClassName>_create`: Instantiates the class and stores it under a word ID (e.g., `playful_llama`).
+2. `<ClassName>_<method>`: Accepts a virtual parameter `obj_id: str` (e.g., `obj_id="playful_llama"`), resolves the underlying instance, and executes the method.
+
+Returned objects (such as datasets or numpy arrays) are also registered in the store with word IDs, allowing subsequent tools to receive them as arguments.
+
+## Examples
+
+Check out [`examples/gemma_sklearn_session.md`](examples/gemma_sklearn_session.md) and [`examples/gemma_sklearn_session.json`](examples/gemma_sklearn_session.json) for a complete, verified multi-turn transcript of Gemma 4 26B loading the Iris dataset, performing `train_test_split`, training a `RandomForestClassifier`, and evaluating accuracy.

integrum-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+integrum/__init__.py,sha256=HDKO5ci3Vwn3S6Z2FF67P99lj3TO3IjaOLY7vK2KdyQ,515
+integrum/cli.py,sha256=I44Nj6qiAL71uqCHmV16afUwr-IdNZrhMyl9VN_0piA,4571
+integrum/docstrings.py,sha256=gup2MEknEJKDby1Wi7bdIbJhsTZYiOrDhOuIkgrwqMY,4326
+integrum/filter.py,sha256=IZHbMsSIR6uQCcaFbbw7-j5n_dut4fZT88XKsJxwlWE,2024
+integrum/inspector.py,sha256=GpunOwOGzN8Ohau6I5kmhny8kBU8ozBZidrgJ0nUW_Y,6135
+integrum/logo.png,sha256=uFMU3N6dYFXs-c2Aew91K9dfOP_CRYtIy-xVCMUbxsg,49983
+integrum/logo_white.png,sha256=WZH2fVwMzdlBC4ay3w5ZI6eL6D81Su66t9YeJdj7XuA,49819
+integrum/server.py,sha256=m22zboMaS88VGcZdcElbMrtRUsBW9u9MHf8Jz_VWu5U,19455
+integrum/store.py,sha256=CnmlQ_IrJM6D9nTaOcG5W2ox-QOrrZ6YL3ihBipTnu0,8949
+integrum-0.1.0.dist-info/METADATA,sha256=uQbOqOvIjJ609Qga-8uC2cwhy6ZmKtJdQwRFh3Cre5k,4624
+integrum-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+integrum-0.1.0.dist-info/entry_points.txt,sha256=NeG6TVeLe0jYuEtbWGeRN_ngb2g5-rtiTNqwr-4P4dE,47
+integrum-0.1.0.dist-info/RECORD,,

integrum-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

integrum-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+integrum = integrum.cli:main