lange-python 0.2.0__tar.gz → 0.3.0__tar.gz

{lange_python-0.2.0 → lange_python-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lange-python
-Version: 0.2.0
+Version: 0.3.0
 Summary: A bundeld set of tools, clients for the lange-suite of tools and more.
 Author: contact@robertlange.me
 Requires-Python: >=3.13
@@ -23,8 +23,9 @@ Python helpers and clients for Lange services.
 from lange.tunnel import Tunnel
 
 tunnel = Tunnel(
-    host="example.com",
-    secret="your-bearer-token",
+    host="wss://tunnel.lange-labs.com",
+    secret_key="your-bearer-token",
+    tunnel_name="dev-edge",  # Optional but recommended when one key is linked to multiple tunnels.
     target="http://localhost:3000",
 )
 

{lange_python-0.2.0 → lange_python-0.3.0}/README.md

@@ -8,8 +8,9 @@ Python helpers and clients for Lange services.
 from lange.tunnel import Tunnel
 
 tunnel = Tunnel(
-    host="example.com",
-    secret="your-bearer-token",
+    host="wss://tunnel.lange-labs.com",
+    secret_key="your-bearer-token",
+    tunnel_name="dev-edge",  # Optional but recommended when one key is linked to multiple tunnels.
     target="http://localhost:3000",
 )
 

{lange_python-0.2.0 → lange_python-0.3.0}/lange/cli/__init__.py

@@ -9,6 +9,7 @@ import click
 
 
 @click.group()
+@click.version_option(package_name="lange-python", message="%(version)s")
 def cli() -> None:
     """
     Lange CLI entrypoint.

{lange_python-0.2.0 → lange_python-0.3.0}/lange/cli/build/_command.py

@@ -9,6 +9,7 @@ import click
 
 from ._discovery import (
     detect_available_build_systems,
+    list_buildable_folders,
     prompt_for_build_system_selection,
     resolve_build_folder,
 )
@@ -39,18 +40,66 @@ def build_command(
     """
     _validate_force_flags(force_docker=force_docker, force_poetry=force_poetry)
 
-    target_folder = resolve_build_folder(folder_name=folder_name, root=Path.cwd())
+    if folder_name:
+        target_folder = resolve_build_folder(folder_name=folder_name, root=Path.cwd())
+        _run_build_for_folder(
+            folder=target_folder,
+            publish=publish,
+            force_docker=force_docker,
+            force_poetry=force_poetry,
+            allow_prompt=True,
+        )
+        return
+
+    target_folders = list_buildable_folders(
+        root=Path.cwd(),
+        force_docker=force_docker,
+        force_poetry=force_poetry,
+    )
+    if not target_folders:
+        raise click.ClickException(
+            "No buildable services were found in the current directory."
+        )
+
+    for target_folder in target_folders:
+        _run_build_for_folder(
+            folder=target_folder,
+            publish=publish,
+            force_docker=force_docker,
+            force_poetry=force_poetry,
+            allow_prompt=False,
+        )
+
+
+def _run_build_for_folder(
+    folder: Path,
+    publish: bool,
+    force_docker: bool,
+    force_poetry: bool,
+    allow_prompt: bool,
+) -> None:
+    """
+    Resolve build system and run the matching build flow for one folder.
+
+    :param folder: Folder to build.
+    :param publish: Whether publishing is enabled via flag.
+    :param force_docker: Force docker build system.
+    :param force_poetry: Force poetry build system.
+    :param allow_prompt: Whether interactive system selection is allowed.
+    :returns: ``None``.
+    """
     build_system = resolve_build_system(
-        folder=target_folder,
+        folder=folder,
         force_docker=force_docker,
         force_poetry=force_poetry,
+        allow_prompt=allow_prompt,
     )
 
     if build_system == DOCKER_BUILD_SYSTEM:
-        _run_docker_flow(folder=target_folder, publish=publish)
+        _run_docker_flow(folder=folder, publish=publish)
         return
 
-    _run_poetry_flow(folder=target_folder, publish=publish)
+    _run_poetry_flow(folder=folder, publish=publish)
 
 
 def _validate_force_flags(force_docker: bool, force_poetry: bool) -> None:
@@ -69,6 +118,7 @@ def resolve_build_system(
     folder: Path,
     force_docker: bool,
     force_poetry: bool,
+    allow_prompt: bool = True,
 ) -> BuildSystem:
     """
     Resolve the build system from force flags or discovered files.
@@ -76,6 +126,7 @@ def resolve_build_system(
     :param folder: Folder that should be built.
     :param force_docker: Whether docker was forced.
     :param force_poetry: Whether poetry was forced.
+    :param allow_prompt: Whether selection prompts are allowed for ambiguity.
     :returns: Resolved build system value.
     """
     if force_docker:
@@ -102,6 +153,8 @@ def resolve_build_system(
         )
     if len(detected_systems) == 1:
         return detected_systems[0]
+    if not allow_prompt:
+        return detected_systems[0]
     return prompt_for_build_system_selection(detected_systems)
 
 

{lange_python-0.2.0 → lange_python-0.3.0}/lange/cli/build/_discovery.py

@@ -67,6 +67,29 @@ def resolve_build_folder(folder_name: str | None, root: Path) -> Path:
     return prompt_for_folder_selection(folders).resolve()
 
 
+def list_buildable_folders(
+    root: Path,
+    force_docker: bool,
+    force_poetry: bool,
+) -> list[Path]:
+    """
+    List top-level folders that are buildable for the selected mode.
+
+    :param root: Directory that should be scanned.
+    :param force_docker: Whether docker mode was explicitly forced.
+    :param force_poetry: Whether poetry mode was explicitly forced.
+    :returns: Sorted list of buildable folders.
+    """
+    candidates = list_candidate_folders(root)
+    if force_docker:
+        return [folder for folder in candidates if (folder / "Dockerfile").is_file()]
+    if force_poetry:
+        return [folder for folder in candidates if (folder / "pyproject.toml").is_file()]
+    return [
+        folder for folder in candidates if detect_available_build_systems(folder)
+    ]
+
+
 def detect_available_build_systems(folder: Path) -> list[BuildSystem]:
     """
     Detect supported build systems available in the given folder.

{lange_python-0.2.0 → lange_python-0.3.0}/lange/cli/code/__init__.py

@@ -10,4 +10,4 @@ def code_group() -> None:
     :returns: ``None``.
     """
 
-code_group.add_command(code_stats,"code_stats")
+code_group.add_command(code_stats,"stats")

{lange_python-0.2.0 → lange_python-0.3.0}/lange/cli/code/_stats.py

@@ -3,8 +3,60 @@ from typing import Iterable
 import os
 import click
 
-SUPPORTED_EXTENSIONS: tuple[str, ...] = (".py", ".tsx", ".js", ".jsx", ".ts", ".html", ".css")
-IGNORED_DIRECTORIES: tuple[str, ...] = (".venv", "node_modules", ".git", ".next")
+SUPPORTED_EXTENSIONS: tuple[str, ...] = (
+    # Python
+    ".py",
+    # JavaScript / TypeScript / React
+    ".js", ".jsx", ".ts", ".tsx",
+    # Web (Markup / Styling)
+    ".html", ".css", ".scss", ".sass", ".less",
+    # Shell / Bash
+    ".sh", ".bash", ".zsh",
+    # C / C++
+    ".c", ".h", ".cpp", ".hpp", ".cc", ".cxx",
+    # Java
+    ".java",
+    # C#
+    ".cs",
+    # Ruby
+    ".rb",
+    # PHP
+    ".php",
+    # Go
+    ".go",
+    # Rust
+    ".rs",
+    # Swift
+    ".swift",
+    # Kotlin
+    ".kt",
+    # Dart
+    ".dart",
+    # Lua
+    ".lua",
+    # SQL
+    ".sql",
+    # R
+    ".r",
+    # Perl
+    ".pl",
+    # Scala
+    ".scala",
+)
+
+IGNORED_DIRECTORIES: tuple[str, ...] = (
+    ".venv", "venv", "env",
+    "node_modules",
+    ".git",
+    ".next",
+    "__pycache__",
+    "build",
+    "dist",
+    "target",
+    "vendor",
+    ".idea",
+    ".vscode"
+)
 
 
 def _render_stats_table(stats: dict[str, int]) -> str:
@@ -18,6 +70,10 @@ def _render_stats_table(stats: dict[str, int]) -> str:
     rows: list[tuple[str, str, str]] = []
 
     for extension, loc in sorted(stats.items(), key=lambda item: (-item[1], item[0])):
+        # Skip extensions with 0 lines to keep the table clean
+        if loc == 0:
+            continue
+
         percentage = (loc / total * 100.0) if total else 0.0
         rows.append((extension, str(loc), f"{percentage:.2f}%"))
 
@@ -41,6 +97,7 @@ def _render_stats_table(stats: dict[str, int]) -> str:
     lines.append(border)
     return "\n".join(lines)
 
+
 def _count_lines_by_extension(root: Path, extensions: Iterable[str]) -> dict[str, int]:
     """
     Count file lines recursively grouped by file ending.
@@ -61,11 +118,16 @@ def _count_lines_by_extension(root: Path, extensions: Iterable[str]) -> dict[str
                 continue
 
             file_path = Path(current_root) / file_name
-            with file_path.open("r", encoding="utf-8", errors="ignore") as file_handle:
-                counts[suffix] += sum(1 for _ in file_handle)
+            try:
+                with file_path.open("r", encoding="utf-8", errors="ignore") as file_handle:
+                    counts[suffix] += sum(1 for _ in file_handle)
+            except Exception:
+                # Silently skip files that can't be opened (e.g., permissions issues)
+                pass
 
     return counts
 
+
 @click.command("stats")
 def code_stats() -> None:
     """
@@ -74,8 +136,16 @@ def code_stats() -> None:
     :returns: ``None``.
     """
     stats = _count_lines_by_extension(Path.cwd(), SUPPORTED_EXTENSIONS)
+
+    # Filter out empty languages for the recognized printout so it's not overwhelming
+    active_extensions = [ext for ext, count in stats.items() if count > 0]
+
     click.echo()
     click.echo()
-    click.echo(f"Recognized file endings: {' '.join(SUPPORTED_EXTENSIONS)}")
+    click.echo(f"Recognized file endings found: {' '.join(active_extensions) if active_extensions else 'None'}")
     click.echo(f"Ignored folders: {' '.join(IGNORED_DIRECTORIES)}")
-    click.echo(_render_stats_table(stats))
+    click.echo(_render_stats_table(stats))
+
+
+if __name__ == '__main__':
+    code_stats()

{lange_python-0.2.0 → lange_python-0.3.0}/lange/tunnel/__init__.py

@@ -6,6 +6,7 @@ import asyncio
 import base64
 import json
 import logging
+import os
 import ssl
 import threading
 from typing import Any, Optional
@@ -26,35 +27,40 @@ class Tunnel(threading.Thread):
     proxy messages to a local HTTP target.
 
     :param host: Base service URL, e.g. ``wss://example.com``.
-    :param secret: Bearer token used for worker authentication.
+    :param secret_key: Bearer token used for worker authentication.
+    :param tunnel_name: Optional explicit tunnel subdomain for keys linked to multiple tunnels.
     :param target: Local HTTP target URL to forward tunnel traffic to.
     :param verify_ssl: Whether to verify TLS certificates for ``wss://`` hosts.
     :param max_retries: Maximum reconnect attempts, ``0`` for infinite retries.
     :param retry_delay: Initial reconnect delay in seconds.
+    :param open_timeout: Timeout in seconds for the WebSocket opening handshake.
     :param daemon: Whether the worker thread is daemonized.
-    :raises ValueError: If ``secret`` is empty.
+    :raises ValueError: If secret key is unavailable or empty.
     """
 
     def __init__(
         self,
-        host: str,
-        secret: str,
+        host: str = "wss://tunnel.lange-labs.com",
+        secret_key: str | None = None,
+        tunnel_name: str | None = None,
         target: str = "http://localhost:80",
         verify_ssl: bool = True,
         max_retries: int = 5,
         retry_delay: float = 5.0,
+        open_timeout: float = 20.0,
         daemon: bool = True,
     ) -> None:
-        if not secret.strip():
-            raise ValueError("A non-empty secret is required for tunnel worker authentication.")
+        resolved_secret_key = _resolve_secret_key(secret_key)
 
         super().__init__(daemon=daemon)
         self.host = host.rstrip("/")
-        self.secret = secret.strip()
+        self.secret_key = resolved_secret_key
+        self.tunnel_name = tunnel_name.strip().lower() if tunnel_name and tunnel_name.strip() else None
         self.target = target.rstrip("/")
         self.verify_ssl = verify_ssl
         self.max_retries = max_retries
         self.retry_delay = retry_delay
+        self.open_timeout = open_timeout
 
         self._max_retry_delay = 60.0
         self._stop_event = threading.Event()
@@ -168,20 +174,20 @@ class Tunnel(threading.Thread):
             except Exception as exc:  # pragma: no cover - best-effort close path
                 logger.debug("Failed to close websocket during reconnect: %s", exc)
 
-    def set_secret(self, secret: str, reconnect: bool = False) -> None:
+    def set_secret_key(self, secret_key: str, reconnect: bool = False) -> None:
         """
         Replace the bearer token used for future connections.
 
-        :param secret: New non-empty bearer token.
+        :param secret_key: New non-empty bearer token.
         :param reconnect: Whether to reconnect immediately to apply the token.
         :returns: ``None``.
-        :raises ValueError: If ``secret`` is empty.
+        :raises ValueError: If ``secret_key`` is empty.
         """
-        if not secret.strip():
-            raise ValueError("A non-empty secret is required for tunnel worker authentication.")
+        if not secret_key.strip():
+            raise ValueError("A non-empty secret_key is required for tunnel worker authentication.")
 
         with self._lock:
-            self.secret = secret.strip()
+            self.secret_key = secret_key.strip()
 
         if reconnect:
             self.reconnect()
@@ -209,6 +215,8 @@ class Tunnel(threading.Thread):
                     tunnel_url,
                     additional_headers=headers,
                     ssl=ssl_context,
+                    proxy=None,
+                    open_timeout=self.open_timeout,
                 ) as ws:
                     with self._lock:
                         self._active_ws = ws
@@ -379,10 +387,14 @@ class Tunnel(threading.Thread):
         """
         Build outbound handshake headers.
 
-        :returns: Header dictionary with bearer authorization only.
+        :returns: Header dictionary with bearer authorization and optional tunnel name.
         """
         with self._lock:
-            return {"Authorization": f"Bearer {self.secret}"}
+            headers = {"Authorization": f"Bearer {self.secret_key}"}
+            if self.tunnel_name is not None:
+                headers["X-Tunnel-Name"] = self.tunnel_name
+
+            return headers
 
     def _set_connected(
         self,
@@ -420,6 +432,7 @@ class Tunnel(threading.Thread):
             return None
 
         ssl_context = ssl.create_default_context()
+        ssl_context.set_alpn_protocols(["http/1.1"])
         if self.verify_ssl:
             return ssl_context
 
@@ -444,3 +457,24 @@ class Tunnel(threading.Thread):
             for key, value in headers.items()
             if str(key).lower() not in hop_by_hop
         }
+
+
+def _resolve_secret_key(secret_key: str | None) -> str:
+    """
+    Resolve secret key from argument or environment.
+
+    :param secret_key: Optional direct secret key value.
+    :returns: Sanitized non-empty secret key.
+    :raises ValueError: If no non-empty secret key is available.
+    """
+    if secret_key is not None and secret_key.strip():
+        return secret_key.strip()
+
+    env_secret_key = os.getenv("LANGE_SECRET_KEY", "")
+    if env_secret_key.strip():
+        return env_secret_key.strip()
+
+    raise ValueError(
+        "A non-empty secret_key is required. "
+        "Pass secret_key directly or set LANGE_SECRET_KEY."
+    )

{lange_python-0.2.0 → lange_python-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lange-python"
-version = "0.2.0"
+version = "0.3.0"
 description = "A bundeld set of tools, clients for the lange-suite of tools and more."
 authors = [
     {name = "contact@robertlange.me"}