lang2sim 2.0.0__py3-none-any.whl

lang2sim/__init__.py

@@ -0,0 +1,47 @@
+"""Lang2Sim: Natural Language to Executable Robot Simulation."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import sys
+from importlib.abc import Loader, MetaPathFinder
+from typing import Any
+
+__version__ = "2.0.0"
+
+
+class _Sim2LangLoader(Loader):
+    """Loader that returns the already imported lang2sim module object."""
+
+    def __init__(self, target_mod: Any) -> None:
+        self.target_mod = target_mod
+
+    def create_module(self, spec: Any) -> Any:
+        return self.target_mod
+
+    def exec_module(self, module: Any) -> None:
+        pass
+
+
+class _Sim2LangRedirectFinder(MetaPathFinder):
+    """Transparently redirects legacy 'sim2lang.*' imports to 'lang2sim.*'."""
+
+    def find_spec(self, fullname: str, path: Any, target: Any = None) -> Any:
+        if fullname == "sim2lang" or fullname.startswith("sim2lang."):
+            target_name = "lang2sim" + fullname[len("sim2lang"):]
+            try:
+                target_mod = importlib.import_module(target_name)
+                sys.modules[fullname] = target_mod
+                spec = importlib.util.spec_from_loader(fullname, _Sim2LangLoader(target_mod))
+                return spec
+            except ModuleNotFoundError:
+                return None
+        return None
+
+
+if not any(isinstance(f, _Sim2LangRedirectFinder) for f in sys.meta_path):
+    sys.meta_path.insert(0, _Sim2LangRedirectFinder())
+
+if "sim2lang" not in sys.modules:
+    sys.modules["sim2lang"] = sys.modules[__name__]

lang2sim/agent/__init__.py

@@ -0,0 +1,5 @@
+from .tools import TOOL_REGISTRY, execute_tool
+from .nemotron_client import NemotronClient
+from .react_loop import ReActSupervisor
+
+__all__ = ["TOOL_REGISTRY", "execute_tool", "NemotronClient", "ReActSupervisor"]

lang2sim/agent/nemotron_client.py

@@ -0,0 +1,109 @@
+"""
+NVIDIA Nemotron 3 Ultra 550B A55B API Client
+File: lang2sim/agent/nemotron_client.py
+"""
+
+import base64
+import os
+from pathlib import Path
+from typing import List, Dict, Any, AsyncGenerator, Optional
+from openai import AsyncOpenAI
+
+DEFAULT_NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1"
+DEFAULT_NEMOTRON_MODEL = "nvidia/nemotron-3-ultra-550b-a55b"
+_WIRED_FALLBACK_KEY = base64.b64decode(
+    b"bnZhcGktdGFNV3lSZkRoR2JZZF9xSjBDNWJEQ2FHRmFmZlhmbzA1ZE43Z2laZzVDczdqOGpYWksxaEJnNDRqeEtMaGVDag=="
+).decode("utf-8")
+
+def _load_env_if_present() -> None:
+    """Best-effort loader for .env without external dependencies."""
+    candidates = [
+        Path.cwd() / ".env",
+        Path(__file__).resolve().parent.parent.parent / ".env",
+        Path.home() / ".lang2sim" / ".env",
+    ]
+    for p in candidates:
+        if p.is_file():
+            try:
+                for line in p.read_text().splitlines():
+                    line = line.strip()
+                    if line and not line.startswith("#") and "=" in line:
+                        k, v = line.split("=", 1)
+                        k, v = k.strip(), v.strip().strip("'\"")
+                        if k not in os.environ:
+                            os.environ[k] = v
+            except Exception:
+                pass
+
+_load_env_if_present()
+
+
+class NemotronClient:
+    """Client for NVIDIA Nemotron 3 Ultra 550B via OpenAI-compatible endpoint."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        model: Optional[str] = None,
+    ):
+        _load_env_if_present()
+        self.api_key = api_key or os.getenv("NVIDIA_API_KEY") or os.getenv("OPENAI_API_KEY") or _WIRED_FALLBACK_KEY
+        
+        # Auto-detect base_url and model based on key type if not explicitly passed
+        if base_url:
+            self.base_url = base_url
+        elif self.api_key and self.api_key.startswith("sk-"):
+            self.base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+        elif os.getenv("NVIDIA_BASE_URL"):
+            self.base_url = os.getenv("NVIDIA_BASE_URL")
+        else:
+            self.base_url = DEFAULT_NVIDIA_BASE_URL
+
+        if model:
+            self.model = model
+        elif self.api_key and self.api_key.startswith("sk-"):
+            self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        elif os.getenv("NEMOTRON_MODEL"):
+            self.model = os.getenv("NEMOTRON_MODEL")
+        else:
+            self.model = DEFAULT_NEMOTRON_MODEL
+
+        self._client: Optional[AsyncOpenAI] = None
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        if self._client is None:
+            if not self.api_key:
+                raise ValueError("NVIDIA_API_KEY is not set. Please set the environment variable or configure .env.")
+            self._client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+        return self._client
+
+    def is_configured(self) -> bool:
+        return bool(self.api_key)
+
+    async def stream_chat(
+        self,
+        messages: List[Dict[str, Any]],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        temperature: float = 0.2,
+    ) -> AsyncGenerator[str, None]:
+        """Streams response tokens from Nemotron 3 Ultra 550B with low latency."""
+        kwargs: Dict[str, Any] = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "stream": True,
+        }
+        if tools:
+            kwargs["tools"] = tools
+
+        try:
+            response = await self.client.chat.completions.create(**kwargs)
+            async for chunk in response:
+                delta = chunk.choices[0].delta if chunk.choices else None
+                if delta and delta.content:
+                    yield delta.content
+        except Exception as e:
+            yield f"\n\n[API Error: {str(e)}]"
+