vincta 0.1.0__tar.gz

vincta-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: vincta
+Version: 0.1.0
+Summary: Auto-discover and serve Python functions over HTTP with a built-in RAM object store
+License-Expression: MIT
+Keywords: fastapi,functions,orchestration,http,object-store,autodiscovery,api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0.0; extra == "pandas"
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.24.0; extra == "numpy"
+Provides-Extra: all
+Requires-Dist: pandas>=2.0.0; extra == "all"
+Requires-Dist: numpy>=1.24.0; extra == "all"

vincta-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vincta"
+version = "0.1.0"
+description = "Auto-discover and serve Python functions over HTTP with a built-in RAM object store"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["fastapi", "functions", "orchestration", "http", "object-store", "autodiscovery", "api"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Framework :: FastAPI",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+]
+dependencies = [
+    "fastapi>=0.111.0",
+    "uvicorn[standard]>=0.29.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+pandas = ["pandas>=2.0.0"]
+numpy  = ["numpy>=1.24.0"]
+all    = ["pandas>=2.0.0", "numpy>=1.24.0"]
+
+[project.scripts]
+vincta = "vincta.cli:main"
+
+[tool.setuptools.packages.find]
+where   = ["."]
+include = ["vincta*"]

vincta-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vincta-0.1.0/vincta/cli.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="relay",
+        description="Pure function orchestration engine — serve Python functions over HTTP.",
+    )
+    parser.add_argument("--host", default="127.0.0.1", help="Bind host (default: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=8000, help="Bind port (default: 8000)")
+    parser.add_argument(
+        "--dir",
+        action="append",
+        dest="dirs",
+        default=[],
+        metavar="DIR",
+        help="Directory to discover functions from (repeatable)",
+    )
+    parser.add_argument(
+        "--sys-path",
+        action="append",
+        dest="sys_paths",
+        default=[],
+        metavar="PATH",
+        help="Extra path prepended to sys.path before discovery (repeatable)",
+    )
+    parser.add_argument(
+        "--exclude",
+        default="test_*,*.test.py",
+        help="Comma-separated glob patterns to exclude from discovery",
+    )
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload (development)")
+    parser.add_argument(
+        "--workers", type=int, default=1, help="Number of worker processes (ignored with --reload)"
+    )
+
+    args = parser.parse_args()
+
+    if args.dirs:
+        os.environ["RELAY_DIRS"] = os.pathsep.join(args.dirs)
+    if args.sys_paths:
+        os.environ["RELAY_SYS_PATHS"] = os.pathsep.join(args.sys_paths)
+    os.environ["RELAY_EXCLUDE"] = args.exclude
+
+    try:
+        import uvicorn
+    except ImportError:
+        print("uvicorn is required: pip install uvicorn[standard]", file=sys.stderr)
+        sys.exit(1)
+
+    uvicorn.run(
+        "vincta.server:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        workers=1 if args.reload else args.workers,
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+

vincta-0.1.0/vincta/discovery/autodiscover.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+_ALWAYS_EXCLUDE = {"__pycache__", ".git", ".venv", "venv", "node_modules", ".mypy_cache"}
+
+
+def _should_exclude(path: Path, patterns: List[str]) -> bool:
+    for part in path.parts:
+        if part in _ALWAYS_EXCLUDE:
+            return True
+    for pattern in patterns:
+        if path.match(pattern):
+            return True
+    return False
+
+
+def _path_to_module_name(file: Path, base: Path) -> str:
+    rel = file.relative_to(base)
+    parts = list(rel.with_suffix("").parts)
+    return ".".join(parts)
+
+
+def _auto_register_module_functions(module) -> int:
+    from vincta.registry.registry import is_registered, register
+
+    count = 0
+    for attr_name, obj in inspect.getmembers(module, inspect.isfunction):
+        if attr_name.startswith("_"):
+            continue
+        # Only register functions defined in this module (not imported ones)
+        if getattr(obj, "__module__", None) != module.__name__:
+            continue
+        if is_registered(obj):
+            continue
+        register(obj, name=attr_name, module=module.__name__)
+        count += 1
+    return count
+
+
+def discover_and_import(
+    directories: List[Path],
+    exclude_patterns: Optional[List[str]] = None,
+    extra_sys_paths: Optional[List[Path]] = None,
+) -> dict:
+    exclude_patterns = exclude_patterns or []
+    results = {"imported": [], "auto_registered": 0, "errors": []}
+
+    # Prepend caller-supplied paths first so they win over anything already
+    # on sys.path.  Typical use: dependency directories for codebases that
+    # use flat (non-package) imports.
+    for p in reversed(extra_sys_paths or []):
+        s = str(p)
+        if p.exists() and s not in sys.path:
+            sys.path.insert(0, s)
+
+    for directory in directories:
+        if not directory.exists():
+            continue
+
+        # Add both the directory and its parent to sys.path.
+        # - parent  → enables  `import <dirname>.<module>` style
+        # - directory itself → enables flat `from <module> import ...` style
+        #   (used by MarketSentiment and other codebases that were written to
+        #    be run from inside their own folder)
+        for p in (directory.parent, directory):
+            s = str(p)
+            if s not in sys.path:
+                sys.path.insert(0, s)
+
+        for py_file in sorted(directory.rglob("*.py")):
+            if _should_exclude(py_file, exclude_patterns):
+                continue
+            if py_file.name == "__init__.py":
+                continue
+
+            module_name = _path_to_module_name(py_file, directory.parent)
+
+            try:
+                if module_name in sys.modules:
+                    module = sys.modules[module_name]
+                else:
+                    spec = importlib.util.spec_from_file_location(module_name, py_file)
+                    if spec is None or spec.loader is None:
+                        continue
+                    module = importlib.util.module_from_spec(spec)
+                    module.__name__ = module_name
+                    sys.modules[module_name] = module
+                    spec.loader.exec_module(module)
+
+                count = _auto_register_module_functions(module)
+                results["imported"].append(module_name)
+                results["auto_registered"] += count
+
+            except Exception as e:
+                msg = f"{py_file}: {e}"
+                results["errors"].append(msg)
+                print(f"[discovery] Failed to import {msg}")
+
+    return results
+
+

vincta-0.1.0/vincta/execution/engine.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Tuple
+
+from vincta.object_store.store import retrieve_object, store_object
+
+try:
+    import pandas as pd
+    _HAS_PANDAS = True
+except ImportError:
+    _HAS_PANDAS = False
+
+try:
+    import numpy as np
+    _HAS_NUMPY = True
+except ImportError:
+    _HAS_NUMPY = False
+
+_PRIMITIVES = (int, float, str, bool, type(None))
+
+# Collections smaller than this length are returned directly
+_COLLECTION_THRESHOLD = 100
+
+
+def _is_obj_ref(value: Any) -> bool:
+    return isinstance(value, str) and value.startswith("obj_")
+
+
+def _resolve_inputs(raw_inputs: Dict[str, Any]) -> Dict[str, Any]:
+    resolved: Dict[str, Any] = {}
+    for key, value in raw_inputs.items():
+        if _is_obj_ref(value):
+            obj = retrieve_object(value)
+            if obj is None:
+                raise KeyError(f"Object ref '{value}' not found in store")
+            resolved[key] = obj
+        else:
+            resolved[key] = value
+    return resolved
+
+
+def _should_store(obj: Any) -> bool:
+    if isinstance(obj, _PRIMITIVES):
+        return False
+    if _HAS_PANDAS and isinstance(obj, pd.DataFrame):
+        return True
+    if _HAS_NUMPY and isinstance(obj, np.ndarray):
+        return True
+    if isinstance(obj, (dict, list)) and len(obj) > _COLLECTION_THRESHOLD:
+        return True
+    return False
+
+
+def _package_value(value: Any, key: str) -> Tuple[str, Any]:
+    if _should_store(value):
+        ref = store_object(value)
+        return key, ref
+    return key, value
+
+
+def execute(function_name: str, raw_inputs: Dict[str, Any]) -> Dict[str, Any]:
+    from vincta.registry.registry import get_function
+
+    entry = get_function(function_name)
+    if entry is None:
+        raise ValueError(f"Function '{function_name}' not found in registry")
+
+    fn = entry["fn"]
+    declared_outputs: Dict[str, str] = entry.get("outputs", {})
+
+    resolved = _resolve_inputs(raw_inputs)
+    result = fn(**resolved)
+
+    if result is None:
+        return {}
+
+    # Tuple return → zip with declared output keys
+    if isinstance(result, tuple):
+        output_keys = list(declared_outputs.keys())
+        packaged: Dict[str, Any] = {}
+        for i, val in enumerate(result):
+            key = output_keys[i] if i < len(output_keys) else f"result_{i}"
+            k, v = _package_value(val, key)
+            packaged[k] = v
+        return packaged
+
+    # Single return value
+    key = next(iter(declared_outputs), "result")
+    k, v = _package_value(result, key)
+    return {k: v}
+
+

vincta-0.1.0/vincta/object_store/store.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import sys
+import uuid
+from typing import Any, Dict, List, Optional
+
+try:
+    import pandas as pd
+    _HAS_PANDAS = True
+except ImportError:
+    _HAS_PANDAS = False
+
+try:
+    import numpy as np
+    _HAS_NUMPY = True
+except ImportError:
+    _HAS_NUMPY = False
+
+_STORE: Dict[str, Any] = {}
+
+
+def store_object(obj: Any) -> str:
+    ref = f"obj_{uuid.uuid4().hex[:12]}"
+    _STORE[ref] = obj
+    return ref
+
+
+def retrieve_object(ref: str) -> Optional[Any]:
+    return _STORE.get(ref)
+
+
+def delete_object(ref: str) -> bool:
+    if ref in _STORE:
+        del _STORE[ref]
+        return True
+    return False
+
+
+def list_refs() -> List[str]:
+    return list(_STORE.keys())
+
+
+def object_count() -> int:
+    return len(_STORE)
+
+
+def _object_size(obj: Any) -> int:
+    try:
+        if _HAS_PANDAS and isinstance(obj, pd.DataFrame):
+            return int(obj.memory_usage(deep=True).sum())
+        if _HAS_NUMPY and isinstance(obj, np.ndarray):
+            return obj.nbytes
+        return sys.getsizeof(obj)
+    except Exception:
+        return 0
+
+
+def summarize_object(ref: str) -> Optional[dict]:
+    obj = _STORE.get(ref)
+    if obj is None:
+        return None
+
+    type_name = type(obj).__name__
+    summary: dict = {"type": type_name}
+
+    if _HAS_PANDAS and isinstance(obj, pd.DataFrame):
+        summary["shape"] = list(obj.shape)
+        summary["columns"] = list(obj.columns)
+        summary["dtypes"] = {str(k): str(v) for k, v in obj.dtypes.items()}
+        summary["memory_bytes"] = _object_size(obj)
+        try:
+            summary["preview"] = obj.head(5).to_dict(orient="records")
+        except Exception:
+            summary["preview"] = []
+
+    elif _HAS_NUMPY and isinstance(obj, np.ndarray):
+        summary["shape"] = list(obj.shape)
+        summary["dtype"] = str(obj.dtype)
+        summary["memory_bytes"] = obj.nbytes
+
+    elif isinstance(obj, dict):
+        summary["size"] = len(obj)
+        summary["keys_preview"] = list(obj.keys())[:20]
+        summary["memory_bytes"] = _object_size(obj)
+
+    elif isinstance(obj, list):
+        summary["length"] = len(obj)
+        summary["memory_bytes"] = _object_size(obj)
+
+    else:
+        summary["repr"] = repr(obj)[:300]
+        summary["memory_bytes"] = _object_size(obj)
+
+    return summary
+
+
+def get_memory_usage() -> dict:
+    total = 0
+    breakdown: Dict[str, int] = {}
+    for ref, obj in _STORE.items():
+        size = _object_size(obj)
+        total += size
+        breakdown[ref] = size
+    return {"total_bytes": total, "objects": breakdown}

vincta-0.1.0/vincta/registry/decorator.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Callable, Dict, Optional
+
+from vincta.registry.registry import register
+
+
+def register_function(
+    name: Optional[str] = None,
+    inputs: Optional[Dict[str, str]] = None,
+    outputs: Optional[Dict[str, str]] = None,
+    description: Optional[str] = None,
+):
+    """Decorator for explicit function registration with schema override.
+
+    Usage::
+
+        @register_function(
+            name="build_features",
+            inputs={"df_ref": "str"},
+            outputs={"feature_ref": "str"},
+        )
+        def build_features(df):
+            ...
+
+    Decorator schema takes precedence over inferred type hints.
+    """
+    def decorator(fn: Callable) -> Callable:
+        register(
+            fn,
+            name=name,
+            inputs=inputs,
+            outputs=outputs,
+            description=description,
+            explicit=True,
+        )
+        return fn
+
+    return decorator
+
+

vincta-0.1.0/vincta/registry/registry.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import inspect
+import typing
+from typing import Any, Callable, Dict, List, Optional
+
+try:
+    import pandas as pd
+    _PD_DATAFRAME = pd.DataFrame
+except ImportError:
+    _PD_DATAFRAME = None
+
+try:
+    import numpy as np
+    _NP_NDARRAY = np.ndarray
+except ImportError:
+    _NP_NDARRAY = None
+
+# Keyed by function name. Each entry is:
+# { fn, name, module, inputs, outputs, description }
+_REGISTRY: Dict[str, dict] = {}
+
+# Tracks function object ids that were explicitly registered via decorator,
+# so auto-discovery skips them.
+_REGISTERED_FN_IDS: set = set()
+
+
+def _type_to_str(t: Any) -> str:
+    if t is inspect.Parameter.empty or t is type(None):
+        return "Any"
+    if _PD_DATAFRAME is not None and t is _PD_DATAFRAME:
+        return "DataFrame"
+    if _NP_NDARRAY is not None and t is _NP_NDARRAY:
+        return "ndarray"
+    # Handle Optional[X], List[X], Dict[K,V], etc.
+    origin = getattr(t, "__origin__", None)
+    if origin is not None:
+        args = getattr(t, "__args__", ())
+        origin_name = getattr(origin, "__name__", str(origin))
+        if args:
+            arg_strs = ", ".join(_type_to_str(a) for a in args)
+            return f"{origin_name}[{arg_strs}]"
+        return origin_name
+    if hasattr(t, "__name__"):
+        return t.__name__
+    return str(t)
+
+
+def _extract_schema(fn: Callable) -> dict:
+    try:
+        hints = typing.get_type_hints(fn)
+    except Exception:
+        hints = {}
+
+    sig = inspect.signature(fn)
+    inputs: Dict[str, str] = {}
+
+    for param_name, param in sig.parameters.items():
+        if param_name == "self":
+            continue
+        hint = hints.get(param_name, inspect.Parameter.empty)
+        inputs[param_name] = _type_to_str(hint)
+
+    return_hint = hints.get("return", inspect.Parameter.empty)
+    if return_hint is type(None) or return_hint is inspect.Parameter.empty:
+        outputs: Dict[str, str] = {}
+    else:
+        outputs = {"result": _type_to_str(return_hint)}
+
+    return {
+        "inputs": inputs,
+        "outputs": outputs,
+        "description": inspect.getdoc(fn),
+    }
+
+
+def register(
+    fn: Callable,
+    *,
+    name: Optional[str] = None,
+    inputs: Optional[Dict[str, str]] = None,
+    outputs: Optional[Dict[str, str]] = None,
+    description: Optional[str] = None,
+    module: Optional[str] = None,
+    explicit: bool = False,
+) -> None:
+    fn_name = name or fn.__qualname__
+    schema = _extract_schema(fn)
+
+    if inputs is not None:
+        schema["inputs"] = inputs
+    if outputs is not None:
+        schema["outputs"] = outputs
+    if description is not None:
+        schema["description"] = description
+
+    _REGISTRY[fn_name] = {
+        "fn": fn,
+        "name": fn_name,
+        "module": module or getattr(fn, "__module__", "unknown"),
+        "inputs": schema["inputs"],
+        "outputs": schema["outputs"],
+        "description": schema["description"],
+    }
+
+    if explicit:
+        _REGISTERED_FN_IDS.add(id(fn))
+
+
+def is_registered(fn: Callable) -> bool:
+    return id(fn) in _REGISTERED_FN_IDS
+
+
+def get_function(name: str) -> Optional[dict]:
+    return _REGISTRY.get(name)
+
+
+def list_functions() -> List[dict]:
+    return [
+        {k: v for k, v in entry.items() if k != "fn"}
+        for entry in _REGISTRY.values()
+    ]
+
+
+def function_count() -> int:
+    return len(_REGISTRY)

vincta-0.1.0/vincta/routers/execution.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict
+
+from fastapi import APIRouter, HTTPException
+
+from vincta.schemas.models import RunRequest
+from vincta.services.execution_service import run_function
+
+router = APIRouter(prefix="/function", tags=["execution"])
+
+
+@router.post("/run", response_model=Dict[str, Any])
+def run_function_endpoint(req: RunRequest) -> Dict[str, Any]:
+    """Execute a registered function.
+
+    Inputs that are object refs (``obj_*``) are automatically resolved
+    from the object store before calling the function.  Heavy outputs
+    (DataFrames, arrays, large collections) are stored automatically and
+    returned as lightweight refs.
+    """
+    try:
+        return run_function(req.function, req.inputs)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except KeyError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except TypeError as e:
+        raise HTTPException(status_code=422, detail=f"Argument error: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Execution error: {e}")
+
+

vincta-0.1.0/vincta/routers/functions.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+
+from vincta.registry.registry import list_functions
+from vincta.schemas.models import FunctionListResponse, FunctionSchema
+
+router = APIRouter(prefix="/functions", tags=["functions"])
+
+
+@router.get("", response_model=FunctionListResponse)
+def get_functions():
+    """Return all registered functions with their schemas and descriptions."""
+    entries = list_functions()
+    return FunctionListResponse(
+        functions=[
+            FunctionSchema(
+                name=e["name"],
+                module=e["module"],
+                description=e.get("description"),
+                inputs=e["inputs"],
+                outputs=e["outputs"],
+            )
+            for e in entries
+        ]
+    )
+
+

vincta-0.1.0/vincta/routers/objects.py

@@ -0,0 +1,50 @@
+from fastapi import APIRouter, HTTPException
+
+from vincta.object_store.store import (
+    delete_object,
+    get_memory_usage,
+    list_refs,
+    store_object,
+    summarize_object,
+)
+from vincta.schemas.models import (
+    DeleteResponse,
+    MemoryStats,
+    ObjectListResponse,
+    ObjectSummary,
+)
+
+router = APIRouter(prefix="/object", tags=["objects"])
+
+
+@router.get("/list", response_model=ObjectListResponse)
+def list_objects():
+    """List all object refs currently in the store."""
+    return ObjectListResponse(refs=list_refs())
+
+
+@router.get("/memory", response_model=MemoryStats)
+def memory_stats():
+    """Return memory usage breakdown for all stored objects."""
+    usage = get_memory_usage()
+    return MemoryStats(total_bytes=usage["total_bytes"], objects=usage["objects"])
+
+
+@router.get("/{ref}", response_model=ObjectSummary)
+def get_object_summary(ref: str):
+    """Preview a stored object — returns metadata/head, never the full payload."""
+    summary = summarize_object(ref)
+    if summary is None:
+        raise HTTPException(status_code=404, detail=f"Object '{ref}' not found")
+    obj_type = summary.pop("type")
+    return ObjectSummary(ref=ref, type=obj_type, summary=summary)
+
+
+@router.delete("/{ref}", response_model=DeleteResponse)
+def delete_object_endpoint(ref: str):
+    """Remove an object from the store and free its memory."""
+    if not delete_object(ref):
+        raise HTTPException(status_code=404, detail=f"Object '{ref}' not found")
+    return DeleteResponse(deleted=ref)
+
+

vincta-0.1.0/vincta/schemas/models.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+
+
+class FunctionSchema(BaseModel):
+    name: str
+    module: str
+    description: Optional[str] = None
+    inputs: Dict[str, str]
+    outputs: Dict[str, str]
+
+
+class FunctionListResponse(BaseModel):
+    functions: List[FunctionSchema]
+
+
+class RunRequest(BaseModel):
+    function: str
+    inputs: Dict[str, Any] = {}
+
+
+class ObjectSummary(BaseModel):
+    ref: str
+    type: str
+    summary: Dict[str, Any]
+
+
+class MemoryStats(BaseModel):
+    total_bytes: int
+    objects: Dict[str, int]
+
+
+class ObjectListResponse(BaseModel):
+    refs: List[str]
+
+
+class DeleteResponse(BaseModel):
+    deleted: str
+
+
+class HealthResponse(BaseModel):
+    status: str
+    registered_functions: int
+    stored_objects: int

vincta-0.1.0/vincta/server.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+
+from vincta.routers import execution, functions, objects
+from vincta.registry.registry import function_count
+from vincta.object_store.store import object_count
+
+
+def _discovery_config():
+    dirs_raw = os.environ.get("RELAY_DIRS", "")
+    paths_raw = os.environ.get("RELAY_SYS_PATHS", "")
+    exclude_raw = os.environ.get("RELAY_EXCLUDE", "test_*,*.test.py")
+    dirs = [Path(d) for d in dirs_raw.split(os.pathsep) if d]
+    sys_paths = [Path(p) for p in paths_raw.split(os.pathsep) if p]
+    exclude = [p.strip() for p in exclude_raw.split(",") if p.strip()]
+    return dirs, sys_paths, exclude
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from vincta.discovery.autodiscover import discover_and_import
+
+    dirs, sys_paths, exclude = _discovery_config()
+    results = discover_and_import(dirs, exclude, sys_paths)
+    print(f"[startup] Imported modules:   {results['imported']}")
+    print(f"[startup] Auto-registered:    {results['auto_registered']} functions")
+    if results["errors"]:
+        print(f"[startup] Import errors:      {results['errors']}")
+    yield
+
+
+app = FastAPI(
+    title="relay",
+    description=(
+        "Pure function orchestration engine — auto-discover and serve Python functions "
+        "over HTTP with a built-in RAM object store."
+    ),
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+app.include_router(functions.router)
+app.include_router(execution.router)
+app.include_router(objects.router)
+
+
+@app.get("/health", tags=["meta"])
+def health():
+    return {
+        "status": "ok",
+        "registered_functions": function_count(),
+        "stored_objects": object_count(),
+    }
+
+

vincta-0.1.0/vincta/services/execution_service.py

@@ -0,0 +1,9 @@
+from typing import Any, Dict
+
+from vincta.execution.engine import execute
+
+
+def run_function(function_name: str, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    return execute(function_name, inputs)
+
+

vincta-0.1.0/vincta.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: vincta
+Version: 0.1.0
+Summary: Auto-discover and serve Python functions over HTTP with a built-in RAM object store
+License-Expression: MIT
+Keywords: fastapi,functions,orchestration,http,object-store,autodiscovery,api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0.0; extra == "pandas"
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.24.0; extra == "numpy"
+Provides-Extra: all
+Requires-Dist: pandas>=2.0.0; extra == "all"
+Requires-Dist: numpy>=1.24.0; extra == "all"

vincta-0.1.0/vincta.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+pyproject.toml
+vincta/__init__.py
+vincta/cli.py
+vincta/server.py
+vincta.egg-info/PKG-INFO
+vincta.egg-info/SOURCES.txt
+vincta.egg-info/dependency_links.txt
+vincta.egg-info/entry_points.txt
+vincta.egg-info/requires.txt
+vincta.egg-info/top_level.txt
+vincta/discovery/__init__.py
+vincta/discovery/autodiscover.py
+vincta/execution/__init__.py
+vincta/execution/engine.py
+vincta/object_store/__init__.py
+vincta/object_store/store.py
+vincta/registry/__init__.py
+vincta/registry/decorator.py
+vincta/registry/registry.py
+vincta/routers/__init__.py
+vincta/routers/execution.py
+vincta/routers/functions.py
+vincta/routers/objects.py
+vincta/schemas/__init__.py
+vincta/schemas/models.py
+vincta/services/__init__.py
+vincta/services/execution_service.py

vincta-0.1.0/vincta.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vincta-0.1.0/vincta.egg-info/entry_points.txt

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

vincta-0.1.0/vincta.egg-info/requires.txt

@@ -0,0 +1,13 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+pydantic>=2.0.0
+
+[all]
+pandas>=2.0.0
+numpy>=1.24.0
+
+[numpy]
+numpy>=1.24.0
+
+[pandas]
+pandas>=2.0.0

vincta-0.1.0/vincta.egg-info/top_level.txt

@@ -0,0 +1 @@
+vincta