ins-pricing 0.5.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

ins_pricing/cli/BayesOpt_entry.py

@@ -11,11 +11,21 @@ import json
 import os
 import sys
 
-if __package__ in {None, ""}:
-    if importlib.util.find_spec("ins_pricing") is None:
-        repo_root = Path(__file__).resolve().parents[2]
-        if str(repo_root) not in sys.path:
-            sys.path.insert(0, str(repo_root))
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 def _apply_env_from_config(argv: list[str]) -> None:
     if "--config-json" not in argv:

ins_pricing/cli/BayesOpt_incremental.py

@@ -20,11 +20,22 @@ from pathlib import Path
 import importlib.util
 import sys
 
-if __package__ in {None, ""}:
-    if importlib.util.find_spec("ins_pricing") is None:
-        repo_root = Path(__file__).resolve().parents[2]
-        if str(repo_root) not in sys.path:
-            sys.path.insert(0, str(repo_root))
+
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 import argparse
 import json
@@ -422,9 +433,20 @@ class IncrementalUpdateRunner:
         self.prediction_cache_dir = runtime_cfg["prediction_cache_dir"]
         self.prediction_cache_format = runtime_cfg["prediction_cache_format"]
         self.plot_path_style = runtime_cfg["plot_path_style"]
-        self.xgb_max_depth_max = runtime_cfg["xgb_max_depth_max"]
-        self.xgb_n_estimators_max = runtime_cfg["xgb_n_estimators_max"]
-        self.optuna_storage = runtime_cfg["optuna_storage"]
+        self.xgb_max_depth_max = runtime_cfg["xgb_max_depth_max"]
+        self.xgb_n_estimators_max = runtime_cfg["xgb_n_estimators_max"]
+        self.xgb_gpu_id = runtime_cfg["xgb_gpu_id"]
+        self.xgb_cleanup_per_fold = runtime_cfg["xgb_cleanup_per_fold"]
+        self.xgb_cleanup_synchronize = runtime_cfg["xgb_cleanup_synchronize"]
+        self.xgb_use_dmatrix = runtime_cfg["xgb_use_dmatrix"]
+        self.ft_cleanup_per_fold = runtime_cfg["ft_cleanup_per_fold"]
+        self.ft_cleanup_synchronize = runtime_cfg["ft_cleanup_synchronize"]
+        self.resn_cleanup_per_fold = runtime_cfg["resn_cleanup_per_fold"]
+        self.resn_cleanup_synchronize = runtime_cfg["resn_cleanup_synchronize"]
+        self.gnn_cleanup_per_fold = runtime_cfg["gnn_cleanup_per_fold"]
+        self.gnn_cleanup_synchronize = runtime_cfg["gnn_cleanup_synchronize"]
+        self.optuna_cleanup_synchronize = runtime_cfg["optuna_cleanup_synchronize"]
+        self.optuna_storage = runtime_cfg["optuna_storage"]
         self.optuna_study_prefix = runtime_cfg["optuna_study_prefix"]
         self.best_params_files = runtime_cfg["best_params_files"]
         self.reuse_best_params = runtime_cfg["reuse_best_params"]
@@ -593,8 +615,19 @@ class IncrementalUpdateRunner:
             use_ft_ddp=self.cfg.get("use_ft_ddp", False),
             use_gnn_ddp=self.cfg.get("use_gnn_ddp", False),
             output_dir=str(self.output_root) if self.output_root else None,
-            xgb_max_depth_max=self.xgb_max_depth_max,
-            xgb_n_estimators_max=self.xgb_n_estimators_max,
+            xgb_max_depth_max=self.xgb_max_depth_max,
+            xgb_n_estimators_max=self.xgb_n_estimators_max,
+            xgb_gpu_id=self.xgb_gpu_id,
+            xgb_cleanup_per_fold=self.xgb_cleanup_per_fold,
+            xgb_cleanup_synchronize=self.xgb_cleanup_synchronize,
+            xgb_use_dmatrix=self.xgb_use_dmatrix,
+            ft_cleanup_per_fold=self.ft_cleanup_per_fold,
+            ft_cleanup_synchronize=self.ft_cleanup_synchronize,
+            resn_cleanup_per_fold=self.resn_cleanup_per_fold,
+            resn_cleanup_synchronize=self.resn_cleanup_synchronize,
+            gnn_cleanup_per_fold=self.gnn_cleanup_per_fold,
+            gnn_cleanup_synchronize=self.gnn_cleanup_synchronize,
+            optuna_cleanup_synchronize=self.optuna_cleanup_synchronize,
             resn_weight_decay=self.cfg.get("resn_weight_decay"),
             final_ensemble=bool(self.cfg.get("final_ensemble", False)),
             final_ensemble_k=int(self.cfg.get("final_ensemble_k", 3)),

ins_pricing/cli/Explain_Run.py

@@ -5,11 +5,22 @@ from typing import Optional
 import importlib.util
 import sys
 
-if __package__ in {None, ""}:
-    if importlib.util.find_spec("ins_pricing") is None:
-        repo_root = Path(__file__).resolve().parents[2]
-        if str(repo_root) not in sys.path:
-            sys.path.insert(0, str(repo_root))
+
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 try:
     from ins_pricing.cli.utils.notebook_utils import run_from_config, run_from_config_cli  # type: ignore

ins_pricing/cli/Explain_entry.py

@@ -6,11 +6,21 @@ from pathlib import Path
 import importlib.util
 import sys
 
-if __package__ in {None, ""}:
-    if importlib.util.find_spec("ins_pricing") is None:
-        repo_root = Path(__file__).resolve().parents[2]
-        if str(repo_root) not in sys.path:
-            sys.path.insert(0, str(repo_root))
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 import argparse
 import json
@@ -460,9 +470,20 @@ def explain_from_config(args: argparse.Namespace) -> None:
             "epochs": int(runtime_cfg["epochs"]),
             "use_gpu": bool(cfg.get("use_gpu", True)),
             "output_dir": output_dir,
-            "xgb_max_depth_max": runtime_cfg["xgb_max_depth_max"],
-            "xgb_n_estimators_max": runtime_cfg["xgb_n_estimators_max"],
-            "resn_weight_decay": cfg.get("resn_weight_decay"),
+            "xgb_max_depth_max": runtime_cfg["xgb_max_depth_max"],
+            "xgb_n_estimators_max": runtime_cfg["xgb_n_estimators_max"],
+            "xgb_gpu_id": runtime_cfg["xgb_gpu_id"],
+            "xgb_cleanup_per_fold": runtime_cfg["xgb_cleanup_per_fold"],
+            "xgb_cleanup_synchronize": runtime_cfg["xgb_cleanup_synchronize"],
+            "xgb_use_dmatrix": runtime_cfg["xgb_use_dmatrix"],
+            "ft_cleanup_per_fold": runtime_cfg["ft_cleanup_per_fold"],
+            "ft_cleanup_synchronize": runtime_cfg["ft_cleanup_synchronize"],
+            "resn_cleanup_per_fold": runtime_cfg["resn_cleanup_per_fold"],
+            "resn_cleanup_synchronize": runtime_cfg["resn_cleanup_synchronize"],
+            "gnn_cleanup_per_fold": runtime_cfg["gnn_cleanup_per_fold"],
+            "gnn_cleanup_synchronize": runtime_cfg["gnn_cleanup_synchronize"],
+            "optuna_cleanup_synchronize": runtime_cfg["optuna_cleanup_synchronize"],
+            "resn_weight_decay": cfg.get("resn_weight_decay"),
             "final_ensemble": bool(cfg.get("final_ensemble", False)),
             "final_ensemble_k": int(cfg.get("final_ensemble_k", 3)),
             "final_refit": bool(cfg.get("final_refit", True)),

ins_pricing/cli/Pricing_Run.py

@@ -5,11 +5,22 @@ from typing import Optional
 import importlib.util
 import sys
 
-if __package__ in {None, ""}:
-    if importlib.util.find_spec("ins_pricing") is None:
-        repo_root = Path(__file__).resolve().parents[2]
-        if str(repo_root) not in sys.path:
-            sys.path.insert(0, str(repo_root))
+
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 try:
     from ins_pricing.cli.utils.notebook_utils import run_from_config, run_from_config_cli  # type: ignore

ins_pricing/cli/bayesopt_entry_runner.py

@@ -15,11 +15,22 @@ from pathlib import Path
 import importlib.util
 import sys
 
-if __package__ in {None, ""}:
-    if importlib.util.find_spec("ins_pricing") is None:
-        repo_root = Path(__file__).resolve().parents[2]
-        if str(repo_root) not in sys.path:
-            sys.path.insert(0, str(repo_root))
+
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 import argparse
 import hashlib
@@ -1114,10 +1125,21 @@ def train_from_config(args: argparse.Namespace) -> None:
         output_override=args.output_dir,
     )
     output_dir = output_cfg["output_dir"]
-    reuse_best_params = bool(
-        args.reuse_best_params or runtime_cfg["reuse_best_params"])
-    xgb_max_depth_max = runtime_cfg["xgb_max_depth_max"]
-    xgb_n_estimators_max = runtime_cfg["xgb_n_estimators_max"]
+    reuse_best_params = bool(
+        args.reuse_best_params or runtime_cfg["reuse_best_params"])
+    xgb_max_depth_max = runtime_cfg["xgb_max_depth_max"]
+    xgb_n_estimators_max = runtime_cfg["xgb_n_estimators_max"]
+    xgb_gpu_id = runtime_cfg["xgb_gpu_id"]
+    xgb_cleanup_per_fold = runtime_cfg["xgb_cleanup_per_fold"]
+    xgb_cleanup_synchronize = runtime_cfg["xgb_cleanup_synchronize"]
+    xgb_use_dmatrix = runtime_cfg["xgb_use_dmatrix"]
+    ft_cleanup_per_fold = runtime_cfg["ft_cleanup_per_fold"]
+    ft_cleanup_synchronize = runtime_cfg["ft_cleanup_synchronize"]
+    resn_cleanup_per_fold = runtime_cfg["resn_cleanup_per_fold"]
+    resn_cleanup_synchronize = runtime_cfg["resn_cleanup_synchronize"]
+    gnn_cleanup_per_fold = runtime_cfg["gnn_cleanup_per_fold"]
+    gnn_cleanup_synchronize = runtime_cfg["gnn_cleanup_synchronize"]
+    optuna_cleanup_synchronize = runtime_cfg["optuna_cleanup_synchronize"]
     optuna_storage = runtime_cfg["optuna_storage"]
     optuna_study_prefix = runtime_cfg["optuna_study_prefix"]
     best_params_files = runtime_cfg["best_params_files"]
@@ -1249,9 +1271,20 @@ def train_from_config(args: argparse.Namespace) -> None:
             "use_ft_ddp": use_ft_ddp,
             "use_gnn_ddp": use_gnn_ddp,
             "output_dir": output_dir,
-            "xgb_max_depth_max": xgb_max_depth_max,
-            "xgb_n_estimators_max": xgb_n_estimators_max,
-            "resn_weight_decay": cfg.get("resn_weight_decay"),
+            "xgb_max_depth_max": xgb_max_depth_max,
+            "xgb_n_estimators_max": xgb_n_estimators_max,
+            "xgb_gpu_id": xgb_gpu_id,
+            "xgb_cleanup_per_fold": xgb_cleanup_per_fold,
+            "xgb_cleanup_synchronize": xgb_cleanup_synchronize,
+            "xgb_use_dmatrix": xgb_use_dmatrix,
+            "ft_cleanup_per_fold": ft_cleanup_per_fold,
+            "ft_cleanup_synchronize": ft_cleanup_synchronize,
+            "resn_cleanup_per_fold": resn_cleanup_per_fold,
+            "resn_cleanup_synchronize": resn_cleanup_synchronize,
+            "gnn_cleanup_per_fold": gnn_cleanup_per_fold,
+            "gnn_cleanup_synchronize": gnn_cleanup_synchronize,
+            "optuna_cleanup_synchronize": optuna_cleanup_synchronize,
+            "resn_weight_decay": cfg.get("resn_weight_decay"),
             "final_ensemble": bool(cfg.get("final_ensemble", False)),
             "final_ensemble_k": int(cfg.get("final_ensemble_k", 3)),
             "final_refit": bool(cfg.get("final_refit", True)),

ins_pricing/cli/utils/bootstrap.py

@@ -0,0 +1,23 @@
+"""Bootstrap helpers for running CLI modules as scripts."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def _find_repo_root(start: Optional[Path] = None) -> Path:
+    anchor = (start or Path(__file__)).resolve()
+    for parent in [anchor] + list(anchor.parents):
+        if (parent / "ins_pricing").is_dir():
+            return parent
+    return anchor.parent
+
+
+def ensure_repo_root(repo_root: Optional[Path] = None) -> Path:
+    """Ensure the repository root (parent of ins_pricing/) is on sys.path."""
+    root = _find_repo_root(repo_root)
+    if str(root) not in sys.path:
+        sys.path.insert(0, str(root))
+    return root

ins_pricing/cli/utils/cli_config.py

@@ -339,21 +339,40 @@ def resolve_split_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
-def resolve_runtime_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "save_preprocess": bool(cfg.get("save_preprocess", False)),
-        "preprocess_artifact_path": cfg.get("preprocess_artifact_path"),
-        "rand_seed": cfg.get("rand_seed", 13),
-        "epochs": cfg.get("epochs", 50),
-        "plot_path_style": cfg.get("plot_path_style"),
-        "reuse_best_params": bool(cfg.get("reuse_best_params", False)),
-        "xgb_max_depth_max": int(cfg.get("xgb_max_depth_max", 25)),
-        "xgb_n_estimators_max": int(cfg.get("xgb_n_estimators_max", 500)),
-        "optuna_storage": cfg.get("optuna_storage"),
-        "optuna_study_prefix": cfg.get("optuna_study_prefix"),
-        "best_params_files": cfg.get("best_params_files"),
-        "bo_sample_limit": cfg.get("bo_sample_limit"),
-        "cache_predictions": bool(cfg.get("cache_predictions", False)),
+def resolve_runtime_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
+    xgb_gpu_id = cfg.get("xgb_gpu_id")
+    if isinstance(xgb_gpu_id, str) and xgb_gpu_id.strip() == "":
+        xgb_gpu_id = None
+    if xgb_gpu_id is not None:
+        try:
+            xgb_gpu_id = int(xgb_gpu_id)
+        except (TypeError, ValueError):
+            xgb_gpu_id = None
+    return {
+        "save_preprocess": bool(cfg.get("save_preprocess", False)),
+        "preprocess_artifact_path": cfg.get("preprocess_artifact_path"),
+        "rand_seed": cfg.get("rand_seed", 13),
+        "epochs": cfg.get("epochs", 50),
+        "plot_path_style": cfg.get("plot_path_style"),
+        "reuse_best_params": bool(cfg.get("reuse_best_params", False)),
+        "xgb_max_depth_max": int(cfg.get("xgb_max_depth_max", 25)),
+        "xgb_n_estimators_max": int(cfg.get("xgb_n_estimators_max", 500)),
+        "xgb_gpu_id": xgb_gpu_id,
+        "xgb_cleanup_per_fold": bool(cfg.get("xgb_cleanup_per_fold", False)),
+        "xgb_cleanup_synchronize": bool(cfg.get("xgb_cleanup_synchronize", False)),
+        "xgb_use_dmatrix": bool(cfg.get("xgb_use_dmatrix", True)),
+        "ft_cleanup_per_fold": bool(cfg.get("ft_cleanup_per_fold", False)),
+        "ft_cleanup_synchronize": bool(cfg.get("ft_cleanup_synchronize", False)),
+        "resn_cleanup_per_fold": bool(cfg.get("resn_cleanup_per_fold", False)),
+        "resn_cleanup_synchronize": bool(cfg.get("resn_cleanup_synchronize", False)),
+        "gnn_cleanup_per_fold": bool(cfg.get("gnn_cleanup_per_fold", False)),
+        "gnn_cleanup_synchronize": bool(cfg.get("gnn_cleanup_synchronize", False)),
+        "optuna_cleanup_synchronize": bool(cfg.get("optuna_cleanup_synchronize", False)),
+        "optuna_storage": cfg.get("optuna_storage"),
+        "optuna_study_prefix": cfg.get("optuna_study_prefix"),
+        "best_params_files": cfg.get("best_params_files"),
+        "bo_sample_limit": cfg.get("bo_sample_limit"),
+        "cache_predictions": bool(cfg.get("cache_predictions", False)),
         "prediction_cache_dir": cfg.get("prediction_cache_dir"),
         "prediction_cache_format": cfg.get("prediction_cache_format", "parquet"),
         "ddp_min_rows": cfg.get("ddp_min_rows", 50000),

ins_pricing/cli/utils/import_resolver.py

@@ -12,12 +12,14 @@ Usage:
 
 from __future__ import annotations
 
-import importlib
-import os
-import sys
+import importlib
+import os
+import sys
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+
+from ins_pricing.cli.utils.bootstrap import ensure_repo_root
 
 
 @dataclass
@@ -381,13 +383,11 @@ def resolve_imports() -> ResolvedImports:
 
 
 # Convenience function for backward compatibility
-def setup_sys_path() -> None:
-    """Ensure the repository root is in sys.path for imports."""
-    try:
-        if importlib.util.find_spec("ins_pricing") is not None:
-            return
-    except Exception:
-        pass
-    repo_root = Path(__file__).resolve().parents[3]
-    if str(repo_root) not in sys.path:
-        sys.path.insert(0, str(repo_root))
+def setup_sys_path() -> None:
+    """Ensure the repository root is in sys.path for imports."""
+    try:
+        if importlib.util.find_spec("ins_pricing") is not None:
+            return
+    except Exception:
+        pass
+    ensure_repo_root()