nativelab 0.1.0__py3-none-any.whl

nativelab/GlobalConfig/binaryResolve.py

@@ -0,0 +1,34 @@
+from nativelab.imports.import_global import Path, json, Dict
+from .config import LLAMA_CLI_DEFAULT, LLAMA_SERVER_DEFAULT
+from .const import APP_CONFIG_DEFAULTS, APP_CONFIG_FILE
+def refresh_binary_paths():
+    """Re-read SERVER_CONFIG and update module-level LLAMA_CLI / LLAMA_SERVER."""
+    from nativelab.Server.server_global import SERVER_CONFIG  # local import
+
+    global LLAMA_CLI, LLAMA_SERVER
+    LLAMA_CLI    = _resolve_binary(SERVER_CONFIG.cli_path,    LLAMA_CLI_DEFAULT)
+    LLAMA_SERVER = _resolve_binary(SERVER_CONFIG.server_path, LLAMA_SERVER_DEFAULT)
+MODELS_DIR   = Path("./localllm")
+SESSIONS_DIR = Path("./sessions")
+SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+def _load_app_config() -> Dict:
+    cfg = dict(APP_CONFIG_DEFAULTS)
+    if APP_CONFIG_FILE.exists():
+        try:
+            saved = json.loads(APP_CONFIG_FILE.read_text())
+            cfg.update({k: v for k, v in saved.items() if k in cfg})
+        except Exception:
+            pass
+    return cfg
+
+def save_app_config(cfg: Dict):
+    APP_CONFIG_FILE.write_text(json.dumps(cfg, indent=2))
+
+APP_CONFIG = _load_app_config()
+
+def _resolve_binary(cfg_path: str, fallback: str) -> str:
+    """Return cfg_path if set and exists, else fallback."""
+    if cfg_path and Path(cfg_path).exists():
+        return cfg_path
+    return fallback

nativelab/GlobalConfig/config.py

@@ -0,0 +1,94 @@
+from nativelab.imports.import_global import Path, _sys, re, os
+_BASE = Path(getattr(_sys, "_MEIPASS", Path(".")))
+_EXT  = ".exe" if __import__("platform").system() == "Windows" else ""
+
+LLAMA_CLI_DEFAULT    = str(_BASE / f"llama-bin/llama-cli{_EXT}")
+LLAMA_SERVER_DEFAULT = str(_BASE / f"llama-bin/llama-server{_EXT}")
+
+# Fallback to local llama/bin for dev mode
+if not Path(LLAMA_CLI_DEFAULT).exists():
+    LLAMA_CLI_DEFAULT    = f"./llama/bin/llama-cli{_EXT}"
+    LLAMA_SERVER_DEFAULT = f"./llama/bin/llama-server{_EXT}"
+
+# These are resolved at runtime via SERVER_CONFIG (set after ServerConfig loads
+LLAMA_CLI    = LLAMA_CLI_DEFAULT
+LLAMA_SERVER = LLAMA_SERVER_DEFAULT
+
+DEFAULT_MODEL      = "./localllm/mistral-7b-instruct-v0.2.Q5_K_M.gguf"
+def DEFAULT_CTX() -> int:
+    return 2048
+
+def DEFAULT_THREADS() -> int:
+    return os.cpu_count() or 4
+DEFAULT_N_PRED     = 512
+CUSTOM_MODELS_FILE  = Path("./localllm/custom_models.json")
+MODEL_CONFIGS_FILE  = Path("./localllm/model_configs.json")
+PARALLEL_PREFS_FILE  = Path("./localllm/parallel_prefs.json")
+SERVER_CONFIG_FILE   = Path("./localllm/server_config.json")
+API_MODELS_FILE      = Path("./localllm/api_models.json")
+
+# ── model roles ───────────────────────────────────────────────────────────────
+MODEL_ROLES = ["general", "reasoning", "summarization", "coding", "secondary"]
+ROLE_ICONS  = {
+    "general":       "💬",
+    "reasoning":     "🧠",
+    "summarization": "📄",
+    "coding":        "💻",
+    "secondary":     "🔀",
+}
+
+# ═════════════════════════════ MODEL FAMILY DETECTION ═══════════════════════
+
+# All GGUF quantization formats supported by llama.cpp
+GGUF_QUANT_PATTERNS = [
+    # imatrix importance quants
+    r'IQ1_S', r'IQ1_M', r'IQ2_XXS', r'IQ2_XS', r'IQ2_S', r'IQ2_M',
+    r'IQ3_XXS', r'IQ3_XS', r'IQ3_S', r'IQ3_M', r'IQ4_XS', r'IQ4_NL',
+    # K-quants
+    r'Q2_K(?:_S)?', r'Q3_K_(?:S|M|L)', r'Q3_K',
+    r'Q4_K_(?:S|M)', r'Q4_K',
+    r'Q5_K_(?:S|M)', r'Q5_K',
+    r'Q6_K',
+    # legacy quants
+    r'Q4_0', r'Q4_1', r'Q5_0', r'Q5_1', r'Q8_0',
+    # float
+    r'F16', r'F32', r'BF16',
+    # GGML legacy
+    r'Q4_0_4_4', r'Q4_0_4_8', r'Q4_0_8_8',
+]
+
+QUANT_REGEX = re.compile(
+    r'\.(' + '|'.join(GGUF_QUANT_PATTERNS) + r')\.gguf$',
+    re.IGNORECASE
+)
+
+# Dynamic accessors (use these everywhere instead of bare constants)
+def RAM_WATCHDOG_MB() -> float:
+    from .binaryResolve import APP_CONFIG
+    return float(APP_CONFIG["ram_watchdog_mb"])
+
+def CHUNK_INDEX_SIZE() -> int:
+    from .binaryResolve import APP_CONFIG
+    return int(APP_CONFIG["chunk_index_size"])
+
+def MAX_RAM_CHUNKS() -> int:
+    from .binaryResolve import APP_CONFIG
+    return int(APP_CONFIG["max_ram_chunks"])
+
+def get_default_threads() -> int:
+    from .binaryResolve import APP_CONFIG
+    return int(APP_CONFIG["default_threads"])
+
+def get_default_ctx() -> int:
+    from .binaryResolve import APP_CONFIG
+    return int(APP_CONFIG["default_ctx"])
+
+def get_default_n_pred() -> int:
+    from .binaryResolve import APP_CONFIG
+    return int(APP_CONFIG["default_n_predict"])
+from nativelab.Model.model_global import SCRIPT_LANGUAGES
+SCRIPT_EXTENSIONS_FILTER = (
+    "Source files ("
+    + " ".join(f"*{ext}" for ext in SCRIPT_LANGUAGES.keys())
+    + ");;All Files (*)"
+)

nativelab/GlobalConfig/config_global.py

@@ -0,0 +1,4 @@
+from .config import *
+from .binaryResolve import *
+from .const import * 
+from .hardwareUtil import *

nativelab/GlobalConfig/const.py

@@ -0,0 +1,191 @@
+from nativelab.imports.import_global import _sys
+from pathlib import Path
+from .hardwareUtil import cpu_count
+_sys.path.append(str(Path(__file__).resolve().parents[1]))
+# ── Reference system constants ────────────────────────────────────────────────
+REFS_DIR          = Path("chat_refs")
+REF_CACHE_DIR     = Path("ref_cache")
+REF_INDEX_DIR     = Path("ref_index")
+PAUSED_JOBS_DIR   = Path("paused_jobs")
+APP_CONFIG_FILE   = Path("app_config.json")
+REFS_DIR.mkdir(parents=True, exist_ok=True)
+REF_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+REF_INDEX_DIR.mkdir(parents=True, exist_ok=True)
+PAUSED_JOBS_DIR.mkdir(parents=True, exist_ok=True)
+PIPELINES_DIR = Path.home() / ".native_lab" / "pipelines"
+PIPELINES_DIR.mkdir(parents=True, exist_ok=True)
+APP_CONFIG_DEFAULTS = {
+    "ram_watchdog_mb":        800,
+    "chunk_index_size":       400,
+    "max_ram_chunks":         120,
+    "summary_chunk_chars":    3000,
+    "summary_ctx_carry":      600,
+    "summary_n_pred_sect":    380,
+    "summary_n_pred_final":   700,
+    "multipdf_n_pred_sect":   380,
+    "multipdf_n_pred_final":  900,
+    "ref_top_k":              6,
+    "ref_max_context_chars":  3000,
+    "pause_after_chunks":     2,   # auto-pause suggestion threshold
+    "default_threads":        12,
+    "default_ctx":            4096,
+    "default_n_predict":      512,
+    "tps_display":            True,
+    "auto_spill_on_start":    False,
+    "stream_socket_timeout":  32000,   # seconds before a silent read errors
+    "stream_stall_timeout":   32000,    # seconds of no tokens before giving up  
+    "stream_max_buf_bytes":   65536, # max line buffer size
+}
+# ─── Config descriptions ──────────────────────────────────────────────────────
+CONFIG_FIELD_META = {
+    "ram_watchdog_mb": {
+        "label": "RAM Watchdog (MB)",
+        "desc":  (
+            "Free RAM threshold in megabytes. When available RAM drops below "
+            "this value, reference chunk caches are automatically spilled to disk "
+            "to prevent system memory exhaustion. Lower = more aggressive spilling. "
+            "Recommended: 400–1200 MB depending on your total RAM."
+        ),
+        "min": 100, "max": 8000, "type": "int",
+    },
+    "chunk_index_size": {
+        "label": "Ref Chunk Size (chars)",
+        "desc":  (
+            "Character size of each indexed chunk when a reference file is loaded. "
+            "Smaller chunks = finer retrieval granularity but more memory entries. "
+            "Larger chunks = broader context per hit but less precise. "
+            "Recommended: 300–600."
+        ),
+        "min": 100, "max": 2000, "type": "int",
+    },
+    "max_ram_chunks": {
+        "label": "Max RAM Chunks (per ref)",
+        "desc":  (
+            "Maximum number of reference chunks kept in RAM per loaded file. "
+            "Chunks beyond this limit are evicted to disk. On systems with "
+            "8 GB RAM, 80–120 is safe. On 4 GB, consider 40–60."
+        ),
+        "min": 10, "max": 500, "type": "int",
+    },
+    "summary_chunk_chars": {
+        "label": "Summary Chunk Size (chars)",
+        "desc":  (
+            "Size of each text chunk sent to the model during PDF summarization. "
+            "Smaller values = more chunks, less RAM per step, but more inference calls. "
+            "Larger values = fewer calls but each prompt uses more context window. "
+            "Recommended: 2000–4000."
+        ),
+        "min": 500, "max": 8000, "type": "int",
+    },
+    "summary_ctx_carry": {
+        "label": "Summary Context Carry (chars)",
+        "desc":  (
+            "Number of characters from the previous chunk's summary to carry forward "
+            "as context for the next chunk. Helps maintain narrative continuity "
+            "across long documents. Recommended: 400–800."
+        ),
+        "min": 100, "max": 2000, "type": "int",
+    },
+    "summary_n_pred_sect": {
+        "label": "Summary Tokens / Section",
+        "desc":  (
+            "Maximum tokens the model generates for each section summary. "
+            "Higher = more detailed section summaries but slower processing. "
+            "Recommended: 250–500."
+        ),
+        "min": 64, "max": 1024, "type": "int",
+    },
+    "summary_n_pred_final": {
+        "label": "Summary Tokens / Final Pass",
+        "desc":  (
+            "Maximum tokens for the final consolidation pass that synthesizes "
+            "all section summaries into one cohesive document summary. "
+            "Recommended: 500–900."
+        ),
+        "min": 128, "max": 2048, "type": "int",
+    },
+    "multipdf_n_pred_sect": {
+        "label": "Multi-PDF Tokens / Section",
+        "desc":  (
+            "Tokens per section for multi-PDF batch summarization. "
+            "Same as Summary Tokens / Section but applied to each document "
+            "in a multi-document batch job. Recommended: 300–500."
+        ),
+        "min": 64, "max": 1024, "type": "int",
+    },
+    "multipdf_n_pred_final": {
+        "label": "Multi-PDF Tokens / Final",
+        "desc":  (
+            "Tokens for the final cross-document consolidation in multi-PDF mode. "
+            "This pass synthesizes summaries across all loaded documents, "
+            "so a higher value gives richer cross-document analysis. "
+            "Recommended: 700–1200."
+        ),
+        "min": 128, "max": 2048, "type": "int",
+    },
+    "ref_top_k": {
+        "label": "Reference Top-K Chunks",
+        "desc":  (
+            "Number of most relevant chunks retrieved from each reference file "
+            "per query. Higher = more context injected but larger prompts. "
+            "Lower = faster, smaller prompts. Recommended: 4–8."
+        ),
+        "min": 1, "max": 20, "type": "int",
+    },
+    "ref_max_context_chars": {
+        "label": "Ref Max Context (chars)",
+        "desc":  (
+            "Maximum total characters injected from all references combined "
+            "into each prompt. Guards against overflowing the model's context window. "
+            "Recommended: 1500–4000."
+        ),
+        "min": 200, "max": 12000, "type": "int",
+    },
+    "pause_after_chunks": {
+        "label": "Pause-Suggest Threshold (chunks)",
+        "desc":  (
+            "After this many chunks are processed, the app will show a "
+            "pause/save banner if many chunks remain. Set to 0 to disable "
+            "auto-pause suggestions. Recommended: 2–5."
+        ),
+        "min": 0, "max": 50, "type": "int",
+    },
+    "default_threads": {
+        "label": "Default CPU Threads",
+        "desc":  (
+            "Number of CPU threads used by llama.cpp for inference. "
+            "Setting this higher than your physical core count may reduce performance. "
+            f"Your system has {cpu_count()} logical CPUs. "
+            "Recommended: physical core count (not hyperthreaded)."
+        ),
+        "min": 1, "max": 64, "type": "int",
+    },
+    "default_ctx": {
+        "label": "Default Context Window (tokens)",
+        "desc":  (
+            "Default token context window loaded with each model. "
+            "Larger context = more conversation history, more RAM. "
+            "Each 4096 additional tokens uses ~0.5 GB extra RAM. "
+            "Recommended: 2048–8192 for most systems."
+        ),
+        "min": 512, "max": 32768, "type": "int",
+    },
+    "default_n_predict": {
+        "label": "Default Max New Tokens",
+        "desc":  (
+            "Default maximum number of tokens the model generates per response. "
+            "Does not affect RAM usage, only generation length. "
+            "Recommended: 256–1024."
+        ),
+        "min": 32, "max": 4096, "type": "int",
+    },
+    "auto_spill_on_start": {
+        "label": "Auto-Spill Refs on Startup",
+        "desc":  (
+            "When enabled, all reference chunk caches are immediately spilled to disk "
+            "on app startup regardless of available RAM. Useful on systems with "
+            "very low RAM where you need the model to have maximum headroom."
+        ),
+        "min": 0, "max": 1, "type": "bool",
+    },
+}

nativelab/GlobalConfig/hardwareUtil.py

@@ -0,0 +1,38 @@
+from nativelab.imports.import_global import hashlib, psutil, HAS_PSUTIL, Dict
+
+def ram_free_mb() -> float:
+    if HAS_PSUTIL:
+        return psutil.virtual_memory().available / (1024 * 1024)
+    return 9999.0
+
+def cpu_count() -> int:
+    try:
+        import multiprocessing
+        n = multiprocessing.cpu_count()
+        return n if n and n > 0 else 4
+    except Exception:
+        return 4
+
+def simple_hash(text: str) -> str:
+    return hashlib.md5(text.encode("utf-8", errors="replace")).hexdigest()[:12]
+
+_SESSION_REF_STORES: Dict = {}
+
+def get_ref_store(session_id: str):
+    from codeparser.codeparser_global import SessionReferenceStore
+    if session_id not in _SESSION_REF_STORES:
+        _SESSION_REF_STORES[session_id] = SessionReferenceStore(session_id)
+    return _SESSION_REF_STORES[session_id]
+
+class RamWatchdog:
+    triggered = False
+
+    @staticmethod
+    def check_and_spill(session_id: str) -> bool:
+        from nativelab.GlobalConfig.config_global import RAM_WATCHDOG_MB
+        if ram_free_mb() < RAM_WATCHDOG_MB:
+            store = get_ref_store(session_id)
+            store.flush_ram()
+            RamWatchdog.triggered = True
+            return True
+        return False

nativelab/Model/APImodels.py

@@ -0,0 +1,69 @@
+from nativelab.imports.import_global import dataclass, List, json, Dict
+def _cfg():
+    from GlobalConfig import config_global
+    return config_global
+@dataclass
+class ApiConfig:
+    name:        str   = ""
+    provider:    str   = "OpenAI"
+    model_id:    str   = ""
+    api_key:     str   = ""
+    base_url:    str   = ""
+    api_format:  str   = "openai"
+    max_tokens:  int   = 2048
+    temperature: float = 0.7
+    # ── custom prompt format ─────────────────────────────────────────────────
+    use_custom_prompt:   bool = False
+    system_prompt:       str  = ""
+    user_prefix:         str  = ""
+    user_suffix:         str  = ""
+    assistant_prefix:    str  = ""
+    prompt_template:     str  = "default"   # "default"|"chatml"|"llama2"|"alpaca"|"custom"
+    # ── custom provider display ──────────────────────────────────────────────
+    custom_provider_name: str = ""
+
+    def to_dict(self) -> Dict:
+        return {k: getattr(self, k) for k in self.__dataclass_fields__}
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "ApiConfig":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+
+class ApiRegistry:
+    def __init__(self):
+        self._configs: List[ApiConfig] = []
+        self._load()
+
+    def _load(self):
+        if _cfg().API_MODELS_FILE.exists():
+            try:
+                self._configs = [ApiConfig.from_dict(d)
+                                 for d in json.loads(_cfg().API_MODELS_FILE.read_text())]
+            except Exception:
+                self._configs = []
+
+    def save(self):
+        _cfg().API_MODELS_FILE.write_text(
+            json.dumps([c.to_dict() for c in self._configs], indent=2))
+
+    def add(self, cfg: ApiConfig):
+        self._configs = [c for c in self._configs if c.name != cfg.name]
+        self._configs.append(cfg)
+        self.save()
+
+    def remove(self, name: str):
+        self._configs = [c for c in self._configs if c.name != name]
+        self.save()
+
+    def all(self) -> List[ApiConfig]:
+        return list(self._configs)
+
+
+api_registry = None
+
+def getapi_registry():
+    global api_registry
+    if api_registry is None:
+        api_registry = ApiRegistry()
+    return api_registry

nativelab/Model/ModelRegistry.py

@@ -0,0 +1,159 @@
+from nativelab.imports.import_global import Dict, dataclass, Path, json, field
+from .model_family import *
+# ═════════════════════════════ MODEL REGISTRY ═══════════════════════════════
+def _cfg():
+    from GlobalConfig import config_global
+    return config_global
+
+def _default_ctx():
+    v = _cfg().DEFAULT_CTX
+    return v() if callable(v) else int(v)
+
+def _default_threads():
+    v = _cfg().DEFAULT_THREADS
+    return v() if callable(v) else int(v)
+
+def _default_n_pred():
+    v = _cfg().DEFAULT_N_PRED
+    return v() if callable(v) else int(v)
+
+@dataclass
+class ModelConfig:
+    path: str
+    role: str = "general"
+
+    threads: int = field(default_factory=_default_threads)
+    ctx: int = field(default_factory=_default_ctx)
+    n_predict: int = field(default_factory=_default_n_pred)
+
+    temperature: float = 0.7
+    top_p: float = 0.9
+    repeat_penalty: float = 1.1
+    family: str = "default"
+
+    def to_dict(self) -> Dict:
+        return {
+            "path": self.path, "role": self.role,
+            "threads":        int(self.threads)        if not callable(self.threads)        else int(self.threads()),
+            "ctx":            int(self.ctx)             if not callable(self.ctx)             else int(self.ctx()),
+            "n_predict":      int(self.n_predict)       if not callable(self.n_predict)       else int(self.n_predict()),
+            "temperature":    self.temperature,
+            "top_p":          self.top_p,
+            "repeat_penalty": self.repeat_penalty,
+            "family":         self.family,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "ModelConfig":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+    @property
+    def name(self) -> str:
+        return Path(self.path).name
+
+    @property
+    def size_mb(self) -> float:
+        p = Path(self.path)
+        return round(p.stat().st_size / 1e6, 1) if p.exists() else 0.0
+
+    @property
+    def detected_family(self) -> ModelFamily:
+        return detect_model_family(self.path)
+
+    @property
+    def quant_type(self) -> str:
+        return detect_quant_type(self.path)
+
+
+class ModelRegistry:
+    def __init__(self):
+        self._custom:  List[str]              = []
+        self._configs: Dict[str, ModelConfig] = {}
+        self._load()
+
+    def _load(self):
+        from nativelab.GlobalConfig.config_global import DEFAULT_CTX, DEFAULT_THREADS, DEFAULT_N_PRED, CUSTOM_MODELS_FILE, MODEL_CONFIGS_FILE, MODELS_DIR
+        if CUSTOM_MODELS_FILE.exists():
+            try:
+                self._custom = json.loads(CUSTOM_MODELS_FILE.read_text())
+            except Exception:
+                self._custom = []
+        if MODEL_CONFIGS_FILE.exists():
+            try:
+                raw = json.loads(MODEL_CONFIGS_FILE.read_text())
+                self._configs = {p: ModelConfig.from_dict(d) for p, d in raw.items()}
+            except Exception:
+                self._configs = {}
+
+    def save(self):
+        from nativelab.GlobalConfig.config_global import DEFAULT_CTX, DEFAULT_THREADS, DEFAULT_N_PRED, CUSTOM_MODELS_FILE, MODEL_CONFIGS_FILE, MODELS_DIR
+        CUSTOM_MODELS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        MODEL_CONFIGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+        CUSTOM_MODELS_FILE.write_text(json.dumps(self._custom, indent=2))
+        MODEL_CONFIGS_FILE.write_text(
+            json.dumps({p: c.to_dict() for p, c in self._configs.items()}, indent=2))
+
+    def add(self, path: str):
+        if path not in self._custom:
+            self._custom.append(path)
+        if path not in self._configs:
+            fam = detect_model_family(path)
+            self._configs[path] = ModelConfig(path=path, family=fam.family)
+        self.save()
+
+    def remove(self, path: str):
+        self._custom  = [p for p in self._custom if p != path]
+        self._configs.pop(path, None)
+        self.save()
+
+    def get_config(self, path: str) -> ModelConfig:
+        if path not in self._configs:
+            fam = detect_model_family(path)
+            self._configs[path] = ModelConfig(path=path, family=fam.family)
+        return self._configs[path]
+
+    def set_config(self, path: str, cfg: ModelConfig):
+        self._configs[path] = cfg
+        self.save()
+
+    def all_models(self) -> List[Dict]:
+        from nativelab.GlobalConfig.config_global import DEFAULT_CTX, DEFAULT_THREADS, DEFAULT_N_PRED, CUSTOM_MODELS_FILE, MODEL_CONFIGS_FILE, MODELS_DIR
+        seen:   set        = set()
+        models: List[Dict] = []
+        if MODELS_DIR.exists():
+            for f in sorted(MODELS_DIR.glob("*.gguf")):
+                seen.add(str(f))
+                cfg = self.get_config(str(f))
+                fam = detect_model_family(str(f))
+                qt  = detect_quant_type(str(f))
+                models.append({
+                    "path": str(f), "name": f.name,
+                    "size_mb": round(f.stat().st_size / 1e6, 1),
+                    "source": "auto", "role": cfg.role,
+                    "family": fam.name, "quant": qt,
+                })
+        for p in self._custom:
+            fp = Path(p)
+            if fp.exists() and p not in seen:
+                seen.add(p)
+                cfg = self.get_config(p)
+                fam = detect_model_family(p)
+                qt  = detect_quant_type(p)
+                models.append({
+                    "path": p, "name": fp.name,
+                    "size_mb": round(fp.stat().st_size / 1e6, 1),
+                    "source": "custom", "role": cfg.role,
+                    "family": fam.name, "quant": qt,
+                })
+        return models
+
+
+_model_registry = None
+
+def get_model_registry():
+    global _model_registry
+    if _model_registry is None:
+        _model_registry = ModelRegistry()
+    return _model_registry
+