lange-python 0.3.31__tar.gz → 0.5.0__tar.gz

lange_python-0.5.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: lange-python
+Version: 0.5.0
+Summary: A bundeld set of tools, clients for the lange-suite of tools and more.
+Author: contact@robertlange.me
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: certifi (>=2026.0.0)
+Requires-Dist: click (>=8.0.0,<9.0.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: idna (>=3.15)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: websockets (>=12.0,<20.0)
+Description-Content-Type: text/markdown
+
+# lange-python
+
+Python helpers for Lange services.
+
+## Mesh Relay Worker
+
+`MeshRelay` connects a local HTTP service to the Lange mesh relay and forwards
+public relay requests to your local target.
+
+```bash
+pip install lange-python
+```
+
+```python
+from lange.mesh.relay import MeshRelay
+
+relay = MeshRelay(
+    host="wss://api.lange-labs.com",
+    key="default",
+    target="http://localhost:3000",
+)
+
+relay.start()
+
+try:
+    print(relay.status)
+    print(relay.remote_relay_address)
+finally:
+    relay.stop()
+```
+
+By default, `MeshRelay` reads authentication from the `LANGE_LABS_API_KEY`
+environment variable. Keep API keys in the environment or a local secret store
+instead of hardcoding them in application code.
+
+```bash
+export LANGE_LABS_API_KEY="your-api-key"
+```
+
+The relay exposes lifecycle state for integrations:
+
+- `status`: one of `unauthenticated`, `off`, `pending`, `connected`, or `failed`
+- `connected`: whether the relay websocket is currently connected
+- `remote_relay_address`: public REST relay address returned by the API
+- `worker_config`: full worker configuration returned by the API
+
+Reload authentication or reconnect the worker without rebuilding it:
+
+```python
+relay.reload()
+relay.reload(api_key=None)
+relay.reconnect()
+```
+

lange_python-0.5.0/README.md

@@ -0,0 +1,53 @@
+# lange-python
+
+Python helpers for Lange services.
+
+## Mesh Relay Worker
+
+`MeshRelay` connects a local HTTP service to the Lange mesh relay and forwards
+public relay requests to your local target.
+
+```bash
+pip install lange-python
+```
+
+```python
+from lange.mesh.relay import MeshRelay
+
+relay = MeshRelay(
+    host="wss://api.lange-labs.com",
+    key="default",
+    target="http://localhost:3000",
+)
+
+relay.start()
+
+try:
+    print(relay.status)
+    print(relay.remote_relay_address)
+finally:
+    relay.stop()
+```
+
+By default, `MeshRelay` reads authentication from the `LANGE_LABS_API_KEY`
+environment variable. Keep API keys in the environment or a local secret store
+instead of hardcoding them in application code.
+
+```bash
+export LANGE_LABS_API_KEY="your-api-key"
+```
+
+The relay exposes lifecycle state for integrations:
+
+- `status`: one of `unauthenticated`, `off`, `pending`, `connected`, or `failed`
+- `connected`: whether the relay websocket is currently connected
+- `remote_relay_address`: public REST relay address returned by the API
+- `worker_config`: full worker configuration returned by the API
+
+Reload authentication or reconnect the worker without rebuilding it:
+
+```python
+relay.reload()
+relay.reload(api_key=None)
+relay.reconnect()
+```

lange_python-0.5.0/lange/__init__.py

@@ -0,0 +1,4 @@
+"""Public package exports for lange-python."""
+from . import contracts, mesh
+
+__all__ = ["contracts", "mesh"]

{lange_python-0.3.31 → lange_python-0.5.0}/lange/cli/__init__.py

@@ -6,7 +6,9 @@ import click
 
 from .build import build_command
 from .code import code_group
+from ._create import create_command
 from .distribution import distribution_group
+from ._init import init_command
 
 
 
@@ -21,4 +23,6 @@ def cli() -> None:
 
 cli.add_command(code_group, "code")
 cli.add_command(build_command, "build")
+cli.add_command(create_command, "create")
 cli.add_command(distribution_group, "distribution")
+cli.add_command(init_command, "init")

lange_python-0.5.0/lange/cli/_create.py

@@ -0,0 +1,61 @@
+"""Implementation for the ``lange create`` command."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import click
+
+
+SERVICES_FILE = Path("services.json")
+
+
+def _load_services(path: Path) -> list[dict[str, Any]]:
+    """Load existing service definitions from disk.
+
+    :param path: JSON file containing service definitions.
+    :returns: Existing service list or an empty list when the file is absent.
+    """
+    if not path.exists():
+        return []
+
+    raw_services = json.loads(path.read_text(encoding="utf-8"))
+    if isinstance(raw_services, list):
+        return [item for item in raw_services if isinstance(item, dict)]
+    if isinstance(raw_services, dict) and isinstance(raw_services.get("services"), list):
+        return [
+            item for item in raw_services["services"] if isinstance(item, dict)
+        ]
+    raise click.ClickException("services.json must contain a list of services.")
+
+
+def _write_services(path: Path, services: list[dict[str, Any]]) -> None:
+    """Persist service definitions with stable formatting.
+
+    :param path: JSON file to write.
+    :param services: Service definitions to persist.
+    """
+    path.write_text(
+        json.dumps(services, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+@click.command("create")
+def create_command() -> None:
+    """Interactively create one service definition.
+
+    :returns: ``None``.
+    """
+    service = {
+        "name": click.prompt("Service name", type=str),
+        "path": click.prompt("Service path", type=str),
+        "build_type": click.prompt("Build type", type=str),
+        "publish_path": click.prompt("Publish path", type=str),
+    }
+    services = _load_services(SERVICES_FILE)
+    services.append(service)
+    _write_services(SERVICES_FILE, services)
+    click.echo(f"Created service {service['name']}.")

lange_python-0.5.0/lange/cli/_init.py

@@ -0,0 +1,22 @@
+"""Implementation for the ``lange init`` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+
+@click.command("init")
+def init_command() -> None:
+    """Create local ``.lange`` bootstrap files.
+
+    :returns: ``None``.
+    """
+    lange_dir = Path(".lange")
+    lange_dir.mkdir(parents=True, exist_ok=True)
+    lange_dir.joinpath(".gitignore").write_text("*\n", encoding="utf-8")
+    secrets_file = lange_dir / "secrets.json"
+    if not secrets_file.exists():
+        secrets_file.write_text("{}\n", encoding="utf-8")
+    click.echo("Initialized .lange.")

lange_python-0.5.0/lange/contracts/__init__.py

@@ -0,0 +1,7 @@
+from . import mesh
+from .mesh.ai import AiModelConfig
+
+__all__ = [
+    "AiModelConfig",
+    "mesh",
+]

lange_python-0.5.0/lange/contracts/mesh/__init__.py

@@ -0,0 +1,29 @@
+from ._message import MeshMessage
+from .ai import (
+    AIModelSpecs,
+    AiModelConfig,
+    AiModelRegistration,
+    AiModelVirtualEnvironment,
+    ChatRequest,
+    ChatResponse,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    MeshAiWorkerConfig,
+)
+from .relay import MeshRelayRequest, MeshRelayResponse, MeshRelayWorkerConfig
+
+__all__ = [
+    "AIModelSpecs",
+    "AiModelConfig",
+    "AiModelRegistration",
+    "AiModelVirtualEnvironment",
+    "ChatRequest",
+    "ChatResponse",
+    "EmbeddingRequest",
+    "EmbeddingResponse",
+    "MeshAiWorkerConfig",
+    "MeshMessage",
+    "MeshRelayRequest",
+    "MeshRelayResponse",
+    "MeshRelayWorkerConfig",
+]

lange_python-0.5.0/lange/contracts/mesh/_message.py

@@ -0,0 +1,32 @@
+import uuid
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from .ai import EmbeddingResponse, EmbeddingRequest, ChatResponse, ChatRequest
+from lange.contracts.mesh.relay import (
+    MeshRelayRequest,
+    MeshRelayResponse,
+    MeshRelayWorkerConfig,
+    MeshRelayWorkerRegistration,
+)
+from .ai import MeshAiWorkerConfig
+
+
+class MeshMessage(BaseModel):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    status: Literal["hello", "ping", "ready", "request", "response"]
+
+    # data type
+    data: (
+        MeshAiWorkerConfig
+        | MeshRelayRequest
+        | MeshRelayResponse
+        | MeshRelayWorkerConfig
+        | MeshRelayWorkerRegistration
+        | EmbeddingRequest
+        | EmbeddingResponse
+        | ChatRequest
+        | ChatResponse
+        | None
+    )

lange_python-0.5.0/lange/contracts/mesh/ai/__init__.py

@@ -0,0 +1,23 @@
+from .embeddings import EmbeddingRequest, EmbeddingResponse
+from .chat import ChatResponse, ChatRequest
+from .ai_model import (
+    AiModelConfig,
+    AIModelSpecs,
+    AiModelRegistration,
+    AiModelVirtualEnvironment,
+)
+from .worker_config import MeshAiWorkerConfig
+
+__all__ = [
+    "MeshAiWorkerConfig",
+
+    "EmbeddingRequest",
+    "EmbeddingResponse",
+    "AiModelConfig",
+    "AIModelSpecs",
+    "AiModelRegistration",
+    "AiModelVirtualEnvironment",
+
+    "ChatRequest",
+    "ChatResponse",
+]

lange_python-0.5.0/lange/contracts/mesh/ai/ai_model.py

@@ -0,0 +1,73 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class AIModelSpecs(BaseModel):
+    model_format: Literal["mlx", "vLLM"]
+    model_size_in_billions: int
+    quantization: str
+    model_id: str
+    model_hub: Literal["huggingface"]
+    model_revision: None
+    model_uri:str|None
+    activated_size_in_billions: int|None
+
+
+class AiModelVirtualEnvironment(BaseModel):
+    packages: list[str]
+    inherit_pip_config: bool
+    index_url: str | None
+    extra_index_url: str | None
+    find_links: bool | None
+    trusted_host: None
+    no_build_isolation: None
+
+
+class AiModelRegistration(BaseModel):
+    version: int
+    context_length: int
+    model_name: str
+    model_lang: list[str]
+    model_ability: list[Literal["generate", "chat"]]
+    model_description: str
+    model_family: str
+    model_specs: list[AIModelSpecs]
+    chat_template: str|None
+    stop_token_ids: None
+    stop: None
+    cache_config: None
+    virtualenv: AiModelVirtualEnvironment
+    is_builtin: bool
+
+    reasoning_start_tag: str|None
+    reasoning_end_tag: str|None
+
+
+class AiModelConfig(BaseModel):
+    # The name of the model to launch
+    model_name: str
+
+    # An easy alias for the model
+    model_alias: str
+
+    # The type of the model.
+    model_type: Literal["LLM", "embedding", "image", "audio", "video"]
+
+    # The size of the model in case multiple are available. e.G. gemma4 with 12b vs 31b
+    size: str | int | None = None
+
+    # The quantization of the model to use. Keep None for default.
+    quantization: str | None = None
+
+    # the context window of the model to use. if None it chooses default
+    context_window: int | None = None
+
+    # thinking
+    enable_thinking: bool | None = None
+
+    # engine configuration
+    model_engine: Literal["MLX", "vLLM"] | None = None
+    model_format: Literal["mlx", "vLLM"] | None = None
+
+    registration: AiModelRegistration | None

lange_python-0.5.0/lange/contracts/mesh/ai/chat.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+from typing import Literal
+
+class ChatMessage(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: list[ChatMessage]
+
+class ChatResponse(BaseModel):
+    message: ChatMessage

lange_python-0.5.0/lange/contracts/mesh/ai/embeddings.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class EmbeddingRequest(BaseModel):
+    data: list[str]
+    model: str
+
+class EmbeddingResponse(BaseModel):
+    embeddings: list[list[float]]

lange_python-0.5.0/lange/contracts/mesh/ai/worker_config.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+
+from .ai_model import AiModelConfig
+
+
+class MeshAiWorkerConfig(BaseModel):
+    host: str = "0.0.0.0"
+    port: int = 8001
+
+    # inference config
+    chat_model: AiModelConfig | None = None
+    image_model: AiModelConfig | None = None
+    embedding_model: AiModelConfig | None = None
+
+
+

lange_python-0.5.0/lange/contracts/mesh/relay/__init__.py

@@ -0,0 +1,9 @@
+from ._rest import MeshRelayRequest, MeshRelayResponse
+from ._worker_config import MeshRelayWorkerConfig, MeshRelayWorkerRegistration
+
+__all__ = [
+    "MeshRelayRequest",
+    "MeshRelayResponse",
+    "MeshRelayWorkerConfig",
+    "MeshRelayWorkerRegistration",
+]

lange_python-0.5.0/lange/contracts/mesh/relay/_rest.py

@@ -0,0 +1,41 @@
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MeshRelayRequest(BaseModel):
+    """REST request payload sent to a mesh relay worker."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    method: str
+    path: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    body: str | None = None
+    body_encoding: Literal["base64"] | None = Field(
+        default=None,
+        validation_alias="bodyEncoding",
+        serialization_alias="bodyEncoding",
+    )
+    query_params: dict[str, list[str]] = Field(
+        default_factory=dict,
+        validation_alias="queryParams",
+        serialization_alias="queryParams",
+    )
+    query_string: str | None = None
+
+
+class MeshRelayResponse(BaseModel):
+    """REST response payload returned by a mesh compute worker."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    status: int
+    headers: dict[str, str] = Field(default_factory=dict)
+    body: str | None = None
+    body_encoding: Literal["base64"] | None = Field(
+        default=None,
+        validation_alias="bodyEncoding",
+        serialization_alias="bodyEncoding",
+    )
+    error: str | None = None

lange_python-0.5.0/lange/contracts/mesh/relay/_worker_config.py

@@ -0,0 +1,31 @@
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MeshRelayWorkerRegistration(BaseModel):
+    """Registration payload sent by a mesh relay worker during hello.
+
+    :param key: Public relay key owned by the worker.
+    :param request_timeout_seconds: Maximum seconds the relay should wait for
+        one worker-owned downstream request.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    key: str
+    request_timeout_seconds: float = Field(
+        validation_alias="requestTimeoutSeconds",
+        serialization_alias="requestTimeoutSeconds",
+    )
+
+
+class MeshRelayWorkerConfig(BaseModel):
+    """Runtime relay configuration returned by the API to a registered worker.
+
+    :param remote_relay_address: Public relay URL clients can call.
+    :param type: Relay protocol type.
+    """
+
+    remote_relay_address: str
+    type: Literal["REST"]

{lange_python-0.3.31 → lange_python-0.5.0}/lange/distribution/__init__.py

@@ -1,7 +1,3 @@
-import logging
-
-logger = logging.getLogger("lange.distribution")
-
 from ._client import DistributionClient
 
 __all__ = ["DistributionClient"]

lange_python-0.5.0/lange/mesh/__init__.py

@@ -0,0 +1,5 @@
+"""Mesh clients and helpers."""
+
+from . import relay
+
+__all__ = ["relay"]

lange_python-0.5.0/lange/mesh/relay/__init__.py

@@ -0,0 +1,18 @@
+"""Mesh relay client package."""
+
+from .client import MeshRelay
+
+from lange.contracts.mesh.relay import (
+    MeshRelayRequest,
+    MeshRelayResponse,
+    MeshRelayWorkerConfig,
+    MeshRelayWorkerRegistration,
+)
+
+__all__ = [
+    "MeshRelay",
+    "MeshRelayRequest",
+    "MeshRelayResponse",
+    "MeshRelayWorkerConfig",
+    "MeshRelayWorkerRegistration",
+]

lange_python-0.5.0/lange/mesh/relay/client/__init__.py

@@ -0,0 +1,5 @@
+"""Mesh relay worker client implementation."""
+
+from ._client import MeshRelay
+
+__all__ = ["MeshRelay"]