mainsequence 3.11.2__tar.gz → 3.12.2__tar.gz

{mainsequence-3.11.2 → mainsequence-3.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 3.11.2
+Version: 3.12.2
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

mainsequence-3.12.2/mainsequence/ai/__init__.py

@@ -0,0 +1 @@
+from .base import BaseAgentTool

mainsequence-3.12.2/mainsequence/ai/base.py

@@ -0,0 +1,314 @@
+"""
+base.py
+
+Minimal, production-oriented client-side base for Agent Tools.
+
+Requirements from Jose:
+- Single public class: BaseAgentTool
+- No registries / decorators / factories
+- No HtmlApp
+- No Jupyter/notebook helpers
+- Keep _send_agent_tool_to_backend(payload) for AgentTool upsert
+- Provide introspection for:
+    - input_schema
+    - output_schema (defined envelope with status/response/error)
+    - config_schema
+- Provide canonical runtime entrypoint:
+    - run_and_response(): calls user run(), wraps into stable response envelope, then send_to_backend()
+
+This file intentionally avoids any backend design advice.
+"""
+
+from __future__ import annotations
+
+import os
+import traceback
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import BaseModel
+
+import mainsequence.client as msc
+from mainsequence import logger
+
+_REF_TEMPLATE = "#/$defs/{model}"
+
+
+
+
+class BaseAgentTool(ABC):
+    """
+    Minimal base class for client-side Agent Tools.
+
+    Tool authors implement:
+        def run(self, *args, **kwargs): ...
+
+    Runners should call:
+        tool.run_and_response(*args, **kwargs)
+
+    The response is ALWAYS a dict:
+        {
+          "status": "OK" | "ERROR",
+          "response": <any JSON-serializable>,
+          "error": { ... } | None
+        }
+
+    This class also provides introspection helpers to build:
+        - input_schema
+        - output_schema (stable response envelope)
+        - config_schema
+    to match your backend AgentTool model fields.
+    """
+
+    # ---- metadata overrides ----
+    tool_description: str
+
+    # ---- config model (Pydantic) ----
+    configuration_class: type[BaseModel] #necessary on runtime
+
+    # ---- Optional strict IO models ----
+
+    output_model: type[BaseModel] | None = None
+
+
+
+    def __init__(self, configuration: Any | None = None):
+        """
+        Accepts:
+          - configuration as instance of configuration_class
+          - configuration as dict (will be parsed into configuration_class)
+          - configuration=None (will try configuration_class() if available)
+
+        If you don't use configuration, you can ignore it.
+        """
+        cfg_cls =self.__class__.configuration_class
+
+        if cfg_cls and isinstance(cfg_cls, type) and issubclass(cfg_cls, BaseModel):
+            if configuration is None:
+                # attempt default construction (will raise if required fields exist)
+                self.configuration = cfg_cls()
+            elif isinstance(configuration, cfg_cls):
+                self.configuration = configuration
+            elif isinstance(configuration, dict):
+                self.configuration = cfg_cls(**configuration)
+            else:
+                raise TypeError(
+                    f"configuration must be {cfg_cls.__name__}, dict, or None; got {type(configuration)}"
+                )
+        else:
+            # No declared configuration class. Allow None or any BaseModel.
+            if configuration is not None and not isinstance(configuration, BaseModel):
+                raise TypeError(
+                    "configuration must be a pydantic BaseModel instance or None "
+                    "(or set configuration_class on the tool)."
+                )
+            self.configuration = configuration
+
+    # -----------------------
+    # Tool author implements
+    # -----------------------
+    @abstractmethod
+    def run(self, *args, **kwargs) -> Any:
+        raise NotImplementedError
+
+    # -----------------------
+    # Canonical runtime entrypoint
+    # -----------------------
+    def run_and_response(self, *args, **kwargs) -> dict[str, Any]:
+        """
+        Execute user run() and ALWAYS return a stable response envelope.
+
+        This is the method your runner should call.
+        """
+        try:
+            raw = self.run(*args, **kwargs)
+            envelope = self._normalize_user_return(raw)
+        except Exception as e:
+            envelope = {
+                "status": "ERROR",
+                "response": None,
+                "error": {
+                    "message": str(e),
+                    "error_type": e.__class__.__name__,
+                    "details": None,
+                    "traceback": traceback.format_exc(),
+                },
+            }
+
+        # Best-effort persistence hook (no hard assumptions)
+        try:
+            self.send_to_backend(envelope)
+        except Exception as e:
+            logger.warning(
+                "[%s] send_to_backend failed: %s", self.__class__.__name__, str(e), exc_info=True
+            )
+
+        return envelope
+
+    def _normalize_user_return(self, raw: Any) -> dict[str, Any]:
+        """
+        Normalize various user return types into the stable response envelope.
+
+        Supported:
+          - dict with 'status' and 'response'
+          - pydantic BaseModel -> becomes response (OK)
+          - any other value -> becomes response (OK)
+        """
+        if isinstance(raw, dict) and "status" in raw and "response" in raw:
+            status = raw.get("status", "OK")
+            if status not in ("OK", "ERROR"):
+                status = "OK"
+            response = self._to_jsonable(raw.get("response"))
+            err = raw.get("error")
+            err = self._to_jsonable(err) if err is not None else None
+            return {"status": status, "response": response, "error": err}
+
+        # If they returned a pydantic model, dump it
+        if isinstance(raw, BaseModel):
+            return {"status": "OK", "response": raw.model_dump(mode="json"), "error": None}
+
+        return {"status": "OK", "response": self._to_jsonable(raw), "error": None}
+
+    @staticmethod
+    def _to_jsonable(value: Any) -> Any:
+        """
+        Convert common Python/Pydantic objects into JSON-serializable structures.
+        """
+        if value is None:
+            return None
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json")
+        if isinstance(value, dict):
+            return {str(k): BaseAgentTool._to_jsonable(v) for k, v in value.items()}
+        if isinstance(value, (list, tuple)):
+            return [BaseAgentTool._to_jsonable(v) for v in value]
+        if isinstance(value, set):
+            return [BaseAgentTool._to_jsonable(v) for v in sorted(value, key=lambda x: str(x))]
+        # Common "jsonable" objects
+        if hasattr(value, "isoformat"):
+            try:
+                return value.isoformat()
+            except Exception as e:
+                logger.exception(f"value {value} is not jsonable:")
+                raise e
+        return value
+
+    # -----------------------
+    # Persistence hook (override if you want)
+    # -----------------------
+    def send_to_backend(self, envelope: dict[str, Any]) -> None:
+        """
+        Best-effort hook to persist the tool response.
+
+        Default behavior:
+          - If SDK helper exists: mainsequence.client.models_tdag.add_tool_response_to_jobrun -> use it
+          - Else: store envelope as JSON artifact and attach via add_output()
+
+        You can override this if you have a preferred mechanism.
+        """
+
+        # If your SDK provides a direct helper, prefer it.
+
+        job_run_id=os.getenv("JOB_RUN_ID", None)
+        if job_run_id is None:
+            raise Exception("JOB_RUN_ID environment variable not set")
+
+        msc.AgentTool.add_tool_response_to_jobrun(job_run_id=job_run_id, response=envelope)  # type: ignore
+
+
+    # -----------------------
+    # Tool metadata + schema introspection
+    # -----------------------
+    @classmethod
+    def agent_tool_payload(cls, attributes: dict[str, Any] | None = None) -> dict[str, Any]:
+        """
+        Build a dict that matches your backend AgentTool model fields:
+          slug, name, description, entrypoint,
+          input_schema, output_schema, config_schema,
+          attributes
+        """
+        return {
+            "description": cls.get_tool_description(),
+            "output_schema": cls.get_output_schema(),
+            "config_schema": cls.get_config_schema(),
+        }
+
+    @classmethod
+    def register_to_backend(cls, attributes: dict[str, Any] | None = None) -> None:
+        """
+        Explicit registration/upsert of this tool metadata.
+        (No registries, no automatic side effects.)
+        """
+        payload=cls.agent_tool_payload(attributes=attributes)
+        msc.AgentTool.update_or_create(**payload)  # type: ignore
+
+
+
+    @classmethod
+    def get_tool_name(cls) -> str:
+        if isinstance(getattr(cls, "tool_name", None), str) and cls.tool_name:
+            return cls.tool_name
+        return cls.__name__
+
+
+
+
+
+    @classmethod
+    def get_config_schema(cls) -> dict[str, Any] | None:
+        cfg_cls = getattr(cls, "configuration_class", None)
+        if cfg_cls and isinstance(cfg_cls, type) and issubclass(cfg_cls, BaseModel):
+            return cfg_cls.model_json_schema(ref_template=_REF_TEMPLATE)
+        return None
+
+
+    @classmethod
+    def get_output_schema(cls) -> dict[str, Any]:
+        """
+        Output schema is always a stable response envelope:
+          {"status": "OK"|"ERROR", "response": ..., "error": ...}
+
+        If output_model is set, response is typed accordingly.
+        """
+        defs: dict[str, Any] = {}
+
+        # Build "response" schema
+        out_model = getattr(cls, "output_model", None)
+        if out_model and isinstance(out_model, type) and issubclass(out_model, BaseModel):
+            response_schema = out_model.model_json_schema(ref_template=_REF_TEMPLATE)
+            if "$defs" in response_schema:
+                defs.update(response_schema.pop("$defs"))
+        else:
+            response_schema = {}
+
+        # error schema (always the same shape)
+        error_schema: dict[str, Any] = {
+            "title": "ToolError",
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"},
+                "error_type": {"type": ["string", "null"]},
+                "details": {"type": ["object", "null"]},
+                "traceback": {"type": ["string", "null"]},
+            },
+            "required": ["message"],
+            "additionalProperties": True,
+        }
+
+        envelope: dict[str, Any] = {
+            "title": f"{cls.__name__}Output",
+            "type": "object",
+            "properties": {
+                "status": {"type": "string", "enum": ["OK", "ERROR"]},
+                "response": {"anyOf": [response_schema, {"type": "null"}]},
+                "error": {"anyOf": [error_schema, {"type": "null"}]},
+            },
+            "required": ["status", "response", "error"],
+            "additionalProperties": False,
+        }
+
+        if defs:
+            envelope["$defs"] = defs
+
+        return envelope
+

mainsequence-3.12.2/mainsequence/ai/cli.py

@@ -0,0 +1,54 @@
+# cli.py
+import importlib
+import json
+import os
+import sys
+
+
+def load_class(entry_point: str):
+    entry_point = entry_point.strip()
+    if ":" in entry_point:  # preferred standard
+        module_path, class_name = entry_point.split(":", 1)
+    else:  # also accept your requested dotted form
+        module_path, class_name = entry_point.rsplit(".", 1)
+
+    module = importlib.import_module(module_path)
+    return getattr(module, class_name)
+
+
+def read_configuration() -> dict:
+    # Priority: argv[1] -> $CONFIGURATION -> stdin (if piped)
+    if len(sys.argv) >= 2 and sys.argv[1].strip():
+        raw = sys.argv[1]
+    else:
+        raw = os.getenv("TOOL_CONFIGURATION")
+        if (raw is None or not raw.strip()) and not sys.stdin.isatty():
+            raw = sys.stdin.read()
+
+    if raw is None or not raw.strip():
+        return {}
+
+    cfg = json.loads(raw)
+    if not isinstance(cfg, dict):
+        raise SystemExit("CONFIGURATION must be a JSON object (dict).")
+    return cfg
+
+
+def main() -> None:
+    entry_point = os.getenv("TOOL_ENTRY_POINT")
+    if not entry_point:
+        raise SystemExit("Missing TOOL_ENTRY_POINT env var.")
+
+    ToolClass = load_class(entry_point)
+    cfg = read_configuration()
+
+    # What you asked for:
+
+    tool = ToolClass(**cfg)
+    tool.run_and_response()
+
+
+
+
+if __name__ == "__main__":
+    main()

{mainsequence-3.11.2 → mainsequence-3.12.2}/mainsequence/client/models_tdag.py

@@ -2689,6 +2689,25 @@ class Constant(BasePydanticModel, BaseObjectOrm):
         return created_constants
 
 
+
+# AI Models
+
+class AgentTool(BasePydanticModel, BaseObjectOrm):
+    """
+    Represents the actual tool metadata that an agent needs to know.
+    """
+    slug: str
+    name: str = Field(max_length=255)
+    description:str= None
+
+    entrypoint: str
+    # JSONFields
+    output_schema: dict[str, Any] | None = None
+    config_schema: dict[str, Any] | None = None
+
+
+
+
 SessionDataSource = PodDataSource()
 SessionDataSource.set_remote_db()
 

mainsequence-3.12.2/mainsequence/dashboards/streamlit/components/asset_select.py

@@ -0,0 +1,158 @@
+# dashboards/streamlit/components/asset_select.py
+"""
+import mainsequence.dashboards.streamlit.components.asset_select
+
+
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import streamlit as st
+
+import mainsequence.client as msc
+
+
+@st.cache_data(show_spinner=False)
+def _search_assets(q: str) -> list[dict[str, Any]]:
+    """
+    Search MainSequence assets by current_snapshot.name or unique_identifier.
+    Returns [{'id', 'label', 'instance'}] with unique IDs.
+    """
+    if not q or len(q.strip()) < 3:
+        return []
+    out: list[dict[str, Any]] = []
+    seen = set()
+
+    try:
+        by_name = msc.Asset.filter(current_snapshot__name__contains=q.strip())
+    except Exception:
+        by_name = []
+
+    try:
+        by_uid = msc.Asset.filter(unique_identifier__contains=q.strip())
+    except Exception:
+        by_uid = []
+
+    for a in list(by_name or []) + list(by_uid or []):
+        try:
+            aid = getattr(a, "id", None)
+            if aid is None or aid in seen:
+                continue
+            uid = getattr(a, "unique_identifier", None)
+            snap = getattr(getattr(a, "current_snapshot", None), "name", None)
+            label = f"{uid or '—'} · {snap or '—'} (id={aid})"
+            out.append({"id": aid, "label": label, "instance": a})
+            seen.add(aid)
+        except Exception:
+            continue
+    return out
+
+
+def sidebar_asset_single_select(
+    *,
+    title: str = "Find asset",
+    key_prefix: str = "asset_select",
+    min_chars: int = 3,
+) -> Any | None:
+    """
+    Streamlit sidebar widget:
+      - Text search (cached)
+      - Single-select of results
+      - Returns the loaded Asset instance and keeps it in session until cleared.
+      - Only changes the loaded asset when "Load asset" is pressed.
+    Session keys:
+      • {key_prefix}_loaded_id
+      • {key_prefix}_loaded_instance
+      • {key_prefix}_q, {key_prefix}_results, {key_prefix}_sel  (UI state)
+    """
+    loaded_id_key = f"{key_prefix}_loaded_id"
+    loaded_inst_key = f"{key_prefix}_loaded_instance"
+    results_key = f"{key_prefix}_results"
+    select_key = f"{key_prefix}_sel"
+    query_key = f"{key_prefix}_q"
+
+    with st.sidebar:
+        st.markdown(f"### {title}")
+        st.caption(f"Type at least **{min_chars}** characters to search.")
+
+        # Show the currently loaded asset (if any)
+        loaded_id = st.session_state.get(loaded_id_key)
+        loaded_inst = st.session_state.get(loaded_inst_key)
+        if loaded_inst is not None:
+            try:
+                uid = getattr(loaded_inst, "unique_identifier", None)
+                snap = getattr(getattr(loaded_inst, "current_snapshot", None), "name", None)
+                st.caption(f"Loaded asset: **{uid or '—'} · {snap or '—'} (id={loaded_id})**")
+            except Exception:
+                st.caption(f"Loaded asset: id={loaded_id}")
+
+        # Search box
+        def _do_search_from_state(prefix: str, min_chars_local: int) -> None:
+            q_local = st.session_state.get(f"{prefix}_q", "")
+            if q_local and len(q_local.strip()) >= min_chars_local:
+                st.session_state[f"{prefix}_results"] = _search_assets(q_local.strip())
+            else:
+                st.session_state.pop(f"{prefix}_results", None)
+
+        q = st.text_input(
+            "Search assets",
+            placeholder="e.g. BONOS 2030  or  MXN:... UID",
+            key=query_key,
+            on_change=_do_search_from_state,
+            args=(key_prefix, min_chars),
+        )
+
+        if st.button("Search", key=f"{key_prefix}_btn") and q and len(q.strip()) >= min_chars:
+            st.session_state[results_key] = _search_assets(q.strip())
+
+        assets = st.session_state.get(results_key, [])
+        if q and len(q.strip()) < min_chars:
+            st.caption(f"Keep typing… need **{min_chars}+** characters to search.")
+
+        if assets:
+            id_to_label = {a["id"]: a["label"] for a in assets}
+            id_to_inst = {a["id"]: a["instance"] for a in assets}
+            # Preselect currently loaded id if visible in the options
+            default_index = 0
+            options = list(id_to_label.keys())
+            if loaded_id in options:
+                default_index = options.index(loaded_id)
+
+            selected_id = st.selectbox(
+                "Select an asset",
+                options=options,
+                index=default_index if options else 0,
+                format_func=lambda x: id_to_label.get(x, str(x)),
+                key=select_key,
+            )
+
+            col_load, col_clear = st.columns([3, 2])
+            with col_load:
+                if st.button(
+                    "Load asset", type="primary", width='stretch', key=f"{key_prefix}_load"
+                ):
+                    inst = id_to_inst.get(selected_id)
+                    # Persist loaded selection
+                    st.session_state[loaded_id_key] = (
+                        int(selected_id) if selected_id is not None else None
+                    )
+                    st.session_state[loaded_inst_key] = inst
+                    return inst
+
+            with col_clear:
+                if st.button("Clear", width='stretch', key=f"{key_prefix}_clear"):
+                    # Clear UI + loaded asset
+                    st.session_state.pop(query_key, None)
+                    st.session_state.pop(results_key, None)
+                    st.session_state.pop(select_key, None)
+                    st.session_state.pop(loaded_id_key, None)
+                    st.session_state.pop(loaded_inst_key, None)
+                    st.rerun()
+
+    # Persisted behavior: if an asset is already loaded, return it on every rerun
+    loaded_inst = st.session_state.get(loaded_inst_key)
+    if loaded_inst is not None:
+        return loaded_inst
+
+    return None

mainsequence-3.12.2/mainsequence/dashboards/streamlit/components/date_settings.py

@@ -0,0 +1,50 @@
+# dashboards/streamlit/components/date_settings.py
+from __future__ import annotations
+
+import datetime as dt
+import os
+
+import streamlit as st
+from dashboards.components.date_selector import date_selector
+
+
+def sidebar_date_settings(
+    *,
+    date_label: str = "Valuation date",
+    session_cfg_key: str = "position_cfg_mem",
+    cfg_field: str = "valuation_date",
+    date_key: str = "valuation_date_input",
+    date_help: str | None = None,
+    use_last_curve_label: str = "Use last available curve",
+    use_last_curve_key: str = "use_last_obs_curve",
+    use_last_curve_help: str | None = None,
+    env_var_key: str = "USE_LAST_OBSERVATION_MS_INSTRUMENT",
+) -> tuple[dt.date, bool]:
+    """
+    Sidebar date settings: valuation date selector + "use last available curve" toggle.
+    Persists date in session cfg and toggles env var for downstream curve construction.
+    Returns (valuation_date, use_last_curve).
+    """
+    valuation_date = date_selector(
+        label=date_label,
+        session_cfg_key=session_cfg_key,
+        cfg_field=cfg_field,
+        key=date_key,
+        help=date_help,
+    )
+
+    default_use_last = st.session_state.get(
+        use_last_curve_key,
+        os.environ.get(env_var_key, "1").lower() in ("1", "true", "yes", "y", "on"),
+    )
+    use_last_curve = st.checkbox(
+        use_last_curve_label,
+        value=default_use_last,
+        key=use_last_curve_key,
+        help=use_last_curve_help,
+    )
+
+    # Set the process env var so downstream curve-building respects it in this run.
+    os.environ[env_var_key] = "True" if use_last_curve else "False"
+
+    return valuation_date, use_last_curve

{mainsequence-3.11.2 → mainsequence-3.12.2}/mainsequence/virtualfundbuilder/resource_factory/base_factory.py

@@ -239,7 +239,7 @@ def send_resource_to_backend(resource_class, attributes: dict | None = None):
     if merged_definitions:
         final_json_schema["$defs"] = merged_definitions
 
-    resource_config = DynamicResource.create(
+    resource_config = DynamicResource.update_or_create(
         name=resource_class.__name__,
         type=resource_class.TYPE.value,
         object_signature=final_json_schema,

{mainsequence-3.11.2 → mainsequence-3.12.2}/mainsequence/virtualfundbuilder/resource_factory/signal_factory.py

@@ -166,8 +166,7 @@ def _get_class_source_code(cls):
         return None
 
 
-SIGNAL_CLASS_REGISTRY = SIGNAL_CLASS_REGISTRY if "SIGNAL_CLASS_REGISTRY" in globals() else {}
-
+SIGNAL_CLASS_REGISTRY = globals().get("SIGNAL_CLASS_REGISTRY", {})
 
 def register_signal_class(name=None, register_in_agent=True):
     """

{mainsequence-3.11.2 → mainsequence-3.12.2}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 3.11.2
+Version: 3.12.2
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement