mainsequence 2.0.4rc0__py3-none-any.whl → 3.0.2__py3-none-any.whl

mainsequence/instruments/settings.py

@@ -7,168 +7,8 @@ import sys
 from pathlib import Path
 from types import SimpleNamespace
 
+ENV_PREFIX = "MSI"
 
-HERE = Path(__file__).resolve().parent
-# ---------------- App identity & app dirs ----------------
-APP_VENDOR = "mainsequence"
-APP_NAME = "instruments"
-APP_ID = f"{APP_VENDOR}/{APP_NAME}"
 
-# All environment variables use this prefix now.
-ENV_PREFIX = "MSI"                    # e.g., MSI_CONFIG_FILE, MSI_DATA_BACKEND
-ENV_CONFIG_FILE = f"{ENV_PREFIX}_CONFIG_FILE"
-ENV_DEFAULT_TOML_FILE = f"{ENV_PREFIX}_DEFAULT_TOML_FILE"
-
-
-def _user_config_root() -> Path:
-    if sys.platform == "win32":
-        base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
-    elif sys.platform == "darwin":
-        base = Path.home() / "Library" / "Application Support"
-    else:
-        base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
-    return (base / APP_VENDOR / APP_NAME).resolve()
-
-APP_ROOT = _user_config_root()
-# (No POSITIONS_DIR / BUILDS_DIR / DATA_DIR and no bulk mkdir here.)
-
-# ---------------- tiny config loader (stdlib only) ----------------
-def _load_toml(text: str) -> dict:
-    try:
-        import tomllib  # py311+
-        return tomllib.loads(text)
-    except Exception:
-        return {}
-
-def _load_file_config() -> dict:
-    candidates: list[Path] = []
-    # 1) explicit path via MSI_CONFIG_FILE
-    env_cfg = os.getenv(ENV_CONFIG_FILE)
-    if env_cfg:
-        candidates.append(Path(env_cfg).expanduser())
-
-    # 2) project-local
-    candidates += [Path("./instruments.toml"), Path("./instruments.json")]
-
-    # 3) user config root
-    candidates += [APP_ROOT / "config.toml", APP_ROOT / "config.json"]
-
-    for p in candidates:
-        try:
-            if not p.exists():
-                continue
-            s = p.read_text(encoding="utf-8")
-            if p.suffix.lower() == ".toml":
-                return _load_toml(s) or {}
-            if p.suffix.lower() == ".json":
-                return json.loads(s)
-        except Exception:
-            pass
-    return {}
-
-# ---------------- default TOML (read from a real file next to this module) -----
-def _read_default_toml_text() -> str | None:
-    """
-    Returns the text of the default TOML configuration.
-    Order of precedence:
-      1) Path from MSI_DEFAULT_TOML_FILE (if set)
-      2) instruments.default.toml next to this file
-    Returns None if no default file is found/readable.
-    """
-    candidate = Path(os.getenv(ENV_DEFAULT_TOML_FILE, HERE / "instruments.default.toml")).expanduser()
-    try:
-        if candidate.exists():
-            return candidate.read_text(encoding="utf-8")
-    except Exception:
-        pass
-    return None
-
-def _existing_config_path() -> Path | None:
-    env_cfg = os.getenv(ENV_CONFIG_FILE)
-    if env_cfg:
-        p = Path(env_cfg).expanduser()
-        if p.exists():
-            return p
-    for p in (
-        Path("./instruments.toml"),
-        Path("./instruments.json"),
-        APP_ROOT / "config.toml",
-        APP_ROOT / "config.json",
-    ):
-        if p.exists():
-            return p
-    return None
-
-def _ensure_default_config_file() -> Path | None:
-    """If no config exists anywhere, create one. Never overwrites existing."""
-    if _existing_config_path() is not None:
-        return None
-    default_text = _read_default_toml_text()
-    if default_text is None:
-        return None
-
-    target = Path(os.getenv(ENV_CONFIG_FILE, APP_ROOT / "config.toml")).expanduser()
-    try:
-        target.parent.mkdir(parents=True, exist_ok=True)  # ensure parent dir only
-        if not target.exists():
-            target.write_text(default_text, encoding="utf-8")
-    except Exception:
-        return None
-    return target
-
-# Create a default config file if none is present anywhere.
-_ensure_default_config_file()
-
-# Now load the config (env still overrides)
-_CFG = _load_file_config()
-
-def _get(key: str, default: str) -> str:
-    # Env overrides config file (MSI_<KEY>)
-    v = os.getenv(f"{ENV_PREFIX}_{key}")
-    if v is not None:
-        return v
-    try:
-        section, leaf = key.lower().split(".", 1)
-        return _CFG.get(section, {}).get(leaf, default)
-    except Exception:
-        return _CFG.get(key, default)
-
-# ---------------- Your existing constants (with overrides) ----------------
-# Tables
-DISCOUNT_CURVES_TABLE         = _get("DISCOUNT_CURVES_TABLE", "discount_curves")
-REFERENCE_RATES_FIXING_TABLE  = _get("REFERENCE_RATES_FIXING_TABLE", "fixing_rates_1d")
-
-# Curve identifiers
-TIIE_28_ZERO_CURVE = _get("TIIE_28_ZERO_CURVE", "F_TIIE_28_VALMER")
-M_BONOS_ZERO_CURVE = _get("M_BONOS_ZERO_CURVE", "M_BONOS_ZERO_OTR")
-
-# Index UIDs
-TIIE_28_UID        = _get("TIIE_28_UID", "TIIE_28")
-TIIE_91_UID        = _get("TIIE_91_UID", "TIIE_91")
-TIIE_182_UID       = _get("TIIE_182_UID", "TIIE_182")
-TIIE_OVERNIGHT_UID = _get("TIIE_OVERNIGHT_UID", "TIIE_OVERNIGHT")
-
-CETE_28_UID        = _get("CETE_28_UID", "CETE_28")
-CETE_91_UID        = _get("CETE_91_UID", "CETE_91")
-CETE_182_UID       = _get("CETE_182_UID", "CETE_182")
-
-# Optional file locations (let your code decide how to use them)
-TIIE_ZERO_CSV      = (_CFG.get("files", {}) or {}).get("tiie_zero_csv")
-TIIE28_FIXINGS_CSV = (_CFG.get("files", {}) or {}).get("tiie28_fixings_csv")
-
-# ---------------- Convenience namespaces for legacy import sites ------------
-indices = SimpleNamespace(
-    TIIE_28_UID=TIIE_28_UID,
-    TIIE_91_UID=TIIE_91_UID,
-    TIIE_182_UID=TIIE_182_UID,
-    TIIE_OVERNIGHT_UID=TIIE_OVERNIGHT_UID,
-    CETE_28_UID=CETE_28_UID,
-    CETE_91_UID=CETE_91_UID,
-    CETE_182_UID=CETE_182_UID,
-)
-curves = SimpleNamespace(
-    TIIE_28_ZERO_CURVE=TIIE_28_ZERO_CURVE,
-    M_BONOS_ZERO_CURVE=M_BONOS_ZERO_CURVE,
-)
-DATA_BACKEND = os.getenv(f"{ENV_PREFIX}_DATA_BACKEND", (_CFG.get("data", {}) or {}).get("backend", "mainsequence"))
+DATA_BACKEND = os.getenv(f"{ENV_PREFIX}_DATA_BACKEND","mainsequence")
 data = SimpleNamespace(backend=DATA_BACKEND)

mainsequence/tdag/config.py

@@ -112,8 +112,8 @@ class TimeSeriesOGM:
         return target_path
 
     @property
-    def local_metadata_path(self):
-        target_path = os.path.join(f"{self.time_series_folder}", "metadata")
+    def data_node_update_path(self):
+        target_path = os.path.join(f"{self.time_series_folder}", "data_node_update")
         self.verify_exist(target_path=target_path)
         return target_path
 

mainsequence/tdag/data_nodes/build_operations.py

@@ -211,10 +211,10 @@ def prepare_config_kwargs(kwargs: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[
 def verify_backend_git_hash_with_pickle(local_persist_manager:PersistManager,
                                         time_serie_class: "DataNode") -> None:
     """Verifies if the git hash in the backend matches the one from the pickled object."""
-    if local_persist_manager.metadata is not None:
+    if local_persist_manager.data_node_storage is not None:
         load_git_hash = get_data_node_source_code_git_hash(time_serie_class)
 
-        persisted_pickle_hash = local_persist_manager.metadata.time_serie_source_code_git_hash
+        persisted_pickle_hash = local_persist_manager.data_node_storage.time_serie_source_code_git_hash
         if load_git_hash != persisted_pickle_hash:
             local_persist_manager.logger.warning(
                 f"{bcolors.WARNING}Source code does not match with pickle rebuilding{bcolors.ENDC}")
@@ -228,7 +228,7 @@ def verify_backend_git_hash_with_pickle(local_persist_manager:PersistManager,
             rebuild_time_serie.persist_to_pickle()
         else:
             # if no need to rebuild, just sync the metadata
-            local_persist_manager.synchronize_metadata(local_metadata=None)
+            local_persist_manager.synchronize_data_node_storage(data_node_update=None)
 
 def hash_signature(dictionary: Dict[str, Any]) -> Tuple[str, str]:
     """

mainsequence/tdag/data_nodes/data_nodes.py

@@ -34,7 +34,7 @@ from abc import ABC
 
 from typing import Union
 
-from mainsequence.client import LocalTimeSerie,  CONSTANTS, \
+from mainsequence.client import DataNodeUpdate,  CONSTANTS, \
     DynamicTableDataSource, AssetTranslationTable
 
 from functools import wraps
@@ -106,7 +106,7 @@ class DataAccessMixin:
 
     def __repr__(self) -> str:
         try:
-            local_id = self.local_time_serie.id
+            local_id = self.data_node_update.id
         except:
             local_id = 0
         repr = self.__class__.__name__ + f" {os.environ['TDAG_ENDPOINT']}/local-time-series/details/?local_time_serie_id={local_id}"
@@ -350,14 +350,14 @@ class APIDataNode(DataAccessMixin):
 
 
     @classmethod
-    def build_from_local_time_serie(cls, source_table: "LocalTimeSerie") -> "APIDataNode":
+    def build_from_local_time_serie(cls, source_table: "DataNodeUpdate") -> "APIDataNode":
         return cls(data_source_id=source_table.data_source.id,
                    storage_hash=source_table.storage_hash
                    )
 
     @classmethod
     def build_from_table_id(cls, table_id: str) -> "APIDataNode":
-        table = ms_client.DynamicTableMetaData.get(id=table_id)
+        table = ms_client.DataNodeStorage.get(id=table_id)
         ts = cls(
             data_source_id=table.data_source.id,
             storage_hash=table.storage_hash
@@ -367,7 +367,7 @@ class APIDataNode(DataAccessMixin):
     @classmethod
     def build_from_identifier(cls, identifier: str) -> "APIDataNode":
 
-        table = ms_client.DynamicTableMetaData.get(identifier=identifier)
+        table = ms_client.DataNodeStorage.get(identifier=identifier)
         ts = cls(
             data_source_id=table.data_source.id,
             storage_hash=table.storage_hash
@@ -462,9 +462,9 @@ class APIDataNode(DataAccessMixin):
     def _set_local_persist_manager(self) -> None:
         self._verify_local_data_source()
         self._local_persist_manager = APIPersistManager(storage_hash=self.storage_hash, data_source_id=self.data_source_id)
-        metadata = self._local_persist_manager.metadata
+        data_node_storage = self._local_persist_manager.data_node_storage
 
-        assert metadata is not None, f"Verify that the table {self.storage_hash} exists "
+        assert data_node_storage is not None, f"Verify that the table {self.storage_hash} exists "
 
 
 
@@ -480,7 +480,7 @@ class APIDataNode(DataAccessMixin):
             A tuple containing the last update time for the table and a dictionary of last update times per asset.
         """
 
-        return  self.local_persist_manager.metadata.sourcetableconfiguration.get_data_updates()
+        return  self.local_persist_manager.data_node_storage.sourcetableconfiguration.get_data_updates()
 
     def get_earliest_updated_asset_filter(self, unique_identifier_list: list,
                                           last_update_per_asset: dict) -> datetime.datetime:
@@ -537,7 +537,7 @@ class DataNode(DataAccessMixin,ABC):
             *args,
             **kwargs):
         """
-        Initializes the DataNode object with the provided metadata and configurations. For extension of the method
+        Initializes the DataNode object with the provided data_node_storage and configurations. For extension of the method
 
         This method sets up the time series object, loading the necessary configurations
         and metadata.
@@ -548,7 +548,7 @@ class DataNode(DataAccessMixin,ABC):
         - init_meta
         - build_meta_data
 
-        Each DataNode instance will create a update_hash and a LocalTimeSerie instance in the Data Engine by uniquely hashing
+        Each DataNode instance will create a update_hash and a DataNodeUpdate instance in the Data Engine by uniquely hashing
         the same arguments as the table but excluding the arguments inside _LOCAL_KWARGS_TO_IGNORE
 
 
@@ -715,12 +715,12 @@ class DataNode(DataAccessMixin,ABC):
 
 
     @property
-    def local_time_serie(self) -> LocalTimeSerie:
+    def data_node_update(self) -> DataNodeUpdate:
         """The local time series metadata object."""
-        return self.local_persist_manager.local_metadata
+        return self.local_persist_manager.data_node_update
 
     @property
-    def metadata(self) -> "DynamicTableMetaData":
+    def metadata(self) -> "DataNodeStorage":
         return self.local_persist_manager.metadata
 
 
@@ -768,7 +768,7 @@ class DataNode(DataAccessMixin,ABC):
         if graph_depth <= graph_depth_limit and self.data_source.related_resource_class_type:
             self._set_local_persist_manager(
                 update_hash=self.update_hash,
-                local_metadata=None,
+                data_node_update=None,
             )
 
         deserializer = build_operations.DeserializerManager()
@@ -782,7 +782,7 @@ class DataNode(DataAccessMixin,ABC):
 
         self.__dict__.update(state)
 
-        self.local_persist_manager.synchronize_metadata(local_metadata=None)
+        self.local_persist_manager.synchronize_metadata(data_node_update=None)
 
     def _prepare_state_for_pickle(self, state: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -803,8 +803,8 @@ class DataNode(DataAccessMixin,ABC):
                 "local_persist_manager",
                 "logger",
                 "init_meta",
-                "_local_metadata_future",
-                "_local_metadata_lock",
+                "_data_node_update_future",
+                "_data_node_update_lock",
                 "_local_persist_manager",
                 "update_tracker",
             ]:
@@ -822,7 +822,7 @@ class DataNode(DataAccessMixin,ABC):
 
         return properties
     def _set_local_persist_manager(self, update_hash: str,
-                                  local_metadata: Union[None, dict] = None,
+                                  data_node_update: Union[None, dict] = None,
 
                                   ) -> None:
         """
@@ -835,13 +835,13 @@ class DataNode(DataAccessMixin,ABC):
                The local hash ID for the time series.
            storage_hash : str
                The remote table hash name for the time series.
-           local_metadata : Union[None, dict], optional
+           data_node_update : Union[None, dict], optional
                Local metadata for the time series, if available.
         """
         self._local_persist_manager = PersistManager.get_from_data_type(
             update_hash=update_hash,
             class_name=self.__class__.__name__,
-            local_metadata=local_metadata,
+            data_node_update=data_node_update,
             data_source=self.data_source
         )
 
@@ -883,7 +883,7 @@ class DataNode(DataAccessMixin,ABC):
 
         """Sets the node relationships in the backend by calling the dependencies() method."""
 
-        if self.local_persist_manager.local_metadata is None:
+        if self.local_persist_manager.data_node_update is None:
             self.verify_and_build_remote_objects()  #
         if self.local_persist_manager.is_local_relation_tree_set():
             return
@@ -911,7 +911,7 @@ class DataNode(DataAccessMixin,ABC):
         self.depth_df = depth_df
         if not depth_df.empty:
             self.dependencies_df = depth_df[
-                depth_df["local_time_serie_id"] != self.local_time_serie.id].copy()
+                depth_df["data_node_update_id"] != self.data_node_update.id].copy()
         else:
             self.dependencies_df = pd.DataFrame()
 
@@ -1108,7 +1108,7 @@ class WrapperDataNode(DataNode):
             """
             from mainsequence.client import DoesNotExist
             try:
-                metadata = ms_client.DynamicTableMetaData.get(identifier=table_identifier)
+                metadata = ms_client.DataNodeStorage.get(identifier=table_identifier)
 
             except DoesNotExist as e:
                 raise e