lange-python 0.1.0__py3-none-any.whl

lange/__init__.py

@@ -0,0 +1,5 @@
+"""Public package exports for lange-python."""
+
+from .tunnel import Tunnel
+
+__all__ = ["Tunnel"]

lange/__main__.py

@@ -0,0 +1,7 @@
+"""Module entrypoint for ``python -m lange``."""
+
+from .cli import cli
+
+
+if __name__ == "__main__":
+    cli()

lange/cli.py

@@ -0,0 +1,264 @@
+"""CLI commands for the ``lange`` Python package."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+import json
+import os
+from pathlib import Path
+import subprocess
+from typing import Literal, cast
+
+import click
+
+from lange.services_schema import Project, Service
+
+SUPPORTED_EXTENSIONS: tuple[str, ...] = (".py", ".tsx", ".js", ".jsx", ".ts", ".html", ".css")
+IGNORED_DIRECTORIES: tuple[str, ...] = (".venv", "node_modules", ".git", ".next")
+SERVICES_FILE_NAME = "services.json"
+
+
+def count_lines_by_extension(root: Path, extensions: Iterable[str]) -> dict[str, int]:
+    """
+    Count file lines recursively grouped by file ending.
+
+    :param root: Directory that should be scanned recursively.
+    :param extensions: Allowed file endings, including the leading dot.
+    :returns: Mapping from file ending to counted LOC.
+    """
+    normalized_extensions = tuple(extension.lower() for extension in extensions)
+    counts = {extension: 0 for extension in normalized_extensions}
+
+    for current_root, directories, files in os.walk(root, topdown=True):
+        directories[:] = [name for name in directories if name not in IGNORED_DIRECTORIES]
+
+        for file_name in files:
+            suffix = Path(file_name).suffix.lower()
+            if suffix not in counts:
+                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)
+
+    return counts
+
+
+def render_stats_table(stats: dict[str, int]) -> str:
+    """
+    Render LOC statistics as an ASCII box table.
+
+    :param stats: Mapping from file ending to line count.
+    :returns: Table string with file type, LOC and percentage values.
+    """
+    total = sum(stats.values())
+    rows: list[tuple[str, str, str]] = []
+
+    for extension, loc in sorted(stats.items(), key=lambda item: (-item[1], item[0])):
+        percentage = (loc / total * 100.0) if total else 0.0
+        rows.append((extension, str(loc), f"{percentage:.2f}%"))
+
+    total_percentage = 100.0 if total else 0.0
+    rows.append(("TOTAL", str(total), f"{total_percentage:.2f}%"))
+
+    headers = ("File-Type", "LOC", "Percentage")
+    col_widths = [
+        max(len(headers[index]), max((len(row[index]) for row in rows), default=0))
+        for index in range(3)
+    ]
+
+    border = "+" + "+".join("-" * (width + 2) for width in col_widths) + "+"
+
+    def _render_row(values: tuple[str, str, str]) -> str:
+        padded = [value.ljust(col_widths[index]) for index, value in enumerate(values)]
+        return "| " + " | ".join(padded) + " |"
+
+    lines = [border, _render_row(headers), border]
+    lines.extend(_render_row(row) for row in rows)
+    lines.append(border)
+    return "\n".join(lines)
+
+
+def services_file_path(root: Path) -> Path:
+    """
+    Build the absolute path to ``services.json`` in a workspace root.
+
+    :param root: Workspace root directory.
+    :returns: Absolute path to ``services.json``.
+    """
+    return root / SERVICES_FILE_NAME
+
+
+def load_project_config(root: Path) -> Project:
+    """
+    Load a project config from ``services.json`` when available.
+
+    :param root: Workspace root directory.
+    :returns: Parsed project config. Defaults to an empty project.
+    """
+    path = services_file_path(root)
+    if not path.exists():
+        return Project(services=[])
+
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return Project.model_validate(data)
+
+
+def save_project_config(root: Path, project: Project) -> Path:
+    """
+    Persist project config to ``services.json``.
+
+    :param root: Workspace root directory.
+    :param project: Project data to store.
+    :returns: Written file path.
+    """
+    path = services_file_path(root)
+    path.write_text(project.model_dump_json(indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+@click.group()
+def cli() -> None:
+    """
+    Lange CLI entrypoint.
+
+    :returns: ``None``.
+    """
+
+
+@cli.group()
+def code() -> None:
+    """
+    Group for source-code related commands.
+
+    :returns: ``None``.
+    """
+
+
+@cli.command("init")
+def init_workspace() -> None:
+    """
+    Initialize local ``.lange`` workspace artifacts.
+
+    Creates ``.lange/.gitignore`` and ``.lange/secrets.json`` in the current
+    directory.
+
+    :returns: ``None``.
+    """
+    lange_directory = Path.cwd() / ".lange"
+    lange_directory.mkdir(parents=True, exist_ok=True)
+    gitignore_file = lange_directory / ".gitignore"
+    gitignore_file.write_text("*\n", encoding="utf-8")
+    secrets_file = lange_directory / "secrets.json"
+    secrets_file.write_text("{}\n", encoding="utf-8")
+    click.echo(f"Initialized {gitignore_file}")
+
+
+@cli.command("create")
+def create_service() -> None:
+    """
+    Interactively add a service entry to ``services.json``.
+
+    :returns: ``None``.
+    """
+    root = Path.cwd()
+    project = load_project_config(root)
+
+    name = click.prompt("Service name", type=str).strip()
+    path = click.prompt("Service path", type=str, default=".", show_default=True).strip()
+    build_type = click.prompt(
+        "Build type",
+        type=click.Choice(["docker", "pyinstall"], case_sensitive=False),
+        default="docker",
+        show_default=True,
+    ).lower()
+    publish_path_input = click.prompt("Publish path (optional)", default="", show_default=False).strip()
+
+    service = Service(
+        name=name,
+        path=path,
+        build_type=cast(Literal["docker", "pyinstall"], build_type),
+        publish_path=publish_path_input or None,
+    )
+    project.services.append(service)
+
+    config_path = save_project_config(root, project)
+    click.echo(f"Added service '{service.name}' to {config_path}")
+
+
+def _iter_services_for_build(project: Project, target_name: str | None) -> list[Service]:
+    """
+    Select services for a build operation.
+
+    :param project: Parsed project configuration.
+    :param target_name: Optional service name filter.
+    :returns: Services to build.
+    :raises click.ClickException: Raised when no services can be built.
+    """
+    if target_name is None:
+        services = project.services
+    else:
+        services = [service for service in project.services if service.name == target_name]
+
+    if not services:
+        if target_name:
+            raise click.ClickException(f"Service '{target_name}' not found in {SERVICES_FILE_NAME}.")
+        raise click.ClickException(f"No services configured in {SERVICES_FILE_NAME}.")
+
+    return services
+
+
+@cli.command("build")
+@click.argument("service_name", required=False)
+def build_services(service_name: str | None) -> None:
+    """
+    Build configured services from ``services.json``.
+
+    Only docker build logic is implemented at the moment.
+
+    :param service_name: Optional single service name to build.
+    :returns: ``None``.
+    """
+    root = Path.cwd()
+    project = load_project_config(root)
+    services = _iter_services_for_build(project, service_name)
+
+    for service in services:
+        if service.build_type != "docker":
+            click.echo(f"Skipping '{service.name}' (build_type={service.build_type} not implemented).")
+            continue
+
+        context_path = service.resolve_path(root)
+        dockerfile_path = context_path / "Dockerfile"
+        if not dockerfile_path.exists():
+            raise click.ClickException(f"Missing Dockerfile for service '{service.name}' at {dockerfile_path}")
+
+        image_name = service.publish_path or service.name
+        click.echo(f"Building '{service.name}' as image '{image_name}' from {context_path}")
+        subprocess.run(
+            [
+                "docker",
+                "build",
+                "-t",
+                image_name,
+                "-f",
+                str(dockerfile_path),
+                str(context_path),
+            ],
+            check=True,
+        )
+
+
+@code.command("stats")
+def code_stats() -> None:
+    """
+    Print LOC statistics for the current working directory.
+
+    :returns: ``None``.
+    """
+    stats = count_lines_by_extension(Path.cwd(), SUPPORTED_EXTENSIONS)
+    click.echo()
+    click.echo()
+    click.echo(f"Recognized file endings: {' '.join(SUPPORTED_EXTENSIONS)}")
+    click.echo(f"Ignored folders: {' '.join(IGNORED_DIRECTORIES)}")
+    click.echo(render_stats_table(stats))

lange/services_schema.py

@@ -0,0 +1,50 @@
+"""Pydantic schemas for ``services.json`` project configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Service(BaseModel):
+    """
+    Service definition stored in ``services.json``.
+
+    :param name: Human-readable service name.
+    :param path: Relative or absolute directory path for this service.
+    :param build_type: Build strategy, either docker or pyinstall.
+    :param publish_path: Optional publish target or image name.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    path: str
+    build_type: Literal["docker", "pyinstall"]
+    publish_path: str | None = None
+
+    def resolve_path(self, root: Path) -> Path:
+        """
+        Resolve the service path relative to a workspace root.
+
+        :param root: Workspace root directory.
+        :returns: Absolute service path.
+        """
+        path = Path(self.path)
+        if path.is_absolute():
+            return path
+        return (root / path).resolve()
+
+
+class Project(BaseModel):
+    """
+    Project configuration for service-based operations.
+
+    :param services: Configured services in this project.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    services: list[Service]

lange/tunnel.py

@@ -0,0 +1,446 @@
+"""Tunnel worker client implementation for the Lange tunnel service."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import logging
+import ssl
+import threading
+from typing import Any, Optional
+from urllib.parse import urljoin
+
+import httpx
+import websockets
+from httpx import Timeout
+
+logger = logging.getLogger("lange.tunnel")
+
+
+class Tunnel(threading.Thread):
+    """
+    Thread-based tunnel worker client.
+
+    Connects to the tunnel runtime WebSocket endpoint and forwards incoming
+    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 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 daemon: Whether the worker thread is daemonized.
+    :raises ValueError: If ``secret`` is empty.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        secret: str,
+        target: str = "http://localhost:80",
+        verify_ssl: bool = True,
+        max_retries: int = 5,
+        retry_delay: float = 5.0,
+        daemon: bool = True,
+    ) -> None:
+        if not secret.strip():
+            raise ValueError("A non-empty secret is required for tunnel worker authentication.")
+
+        super().__init__(daemon=daemon)
+        self.host = host.rstrip("/")
+        self.secret = secret.strip()
+        self.target = target.rstrip("/")
+        self.verify_ssl = verify_ssl
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+
+        self._max_retry_delay = 60.0
+        self._stop_event = threading.Event()
+        self._reconnect_event = threading.Event()
+        self._connected = False
+        self._remote_address: Optional[str] = None
+        self._remote_address_roundrobin: Optional[str] = None
+        self._worker_index = -1
+        self._pool_size = 0
+        self._reconnect_count = 0
+        self._lock = threading.Lock()
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._active_ws: Any = None
+
+    @property
+    def connected(self) -> bool:
+        """
+        Get current connection state.
+
+        :returns: ``True`` when a worker socket is currently active.
+        """
+        with self._lock:
+            return self._connected
+
+    @property
+    def remote_address(self) -> Optional[str]:
+        """
+        Get worker-specific public address when provided by the server.
+
+        :returns: Worker URL or ``None`` when unavailable.
+        """
+        with self._lock:
+            return self._remote_address
+
+    @property
+    def remote_address_roundrobin(self) -> Optional[str]:
+        """
+        Get round-robin public address when provided by the server.
+
+        :returns: Pool URL or ``None`` when unavailable.
+        """
+        with self._lock:
+            return self._remote_address_roundrobin
+
+    @property
+    def worker_index(self) -> int:
+        """
+        Get current worker index from the latest welcome payload.
+
+        :returns: Worker index, ``-1`` when disconnected.
+        """
+        with self._lock:
+            return self._worker_index
+
+    @property
+    def pool_size(self) -> int:
+        """
+        Get current worker pool size from the latest welcome payload.
+
+        :returns: Worker pool size, ``0`` when disconnected.
+        """
+        with self._lock:
+            return self._pool_size
+
+    @property
+    def reconnect_count(self) -> int:
+        """
+        Get number of reconnect attempts after the last successful connection.
+
+        :returns: Reconnect counter.
+        """
+        with self._lock:
+            return self._reconnect_count
+
+    def run(self) -> None:
+        """
+        Start the worker loop inside the thread.
+
+        :returns: ``None``.
+        """
+        asyncio.run(self._run_async())
+
+    def stop(self) -> None:
+        """
+        Request a graceful shutdown.
+
+        :returns: ``None``.
+        """
+        self._stop_event.set()
+
+    def reconnect(self) -> None:
+        """
+        Force a full reconnect cycle.
+
+        :returns: ``None``.
+        """
+        self._set_connected(False)
+        with self._lock:
+            self._reconnect_count = 0
+            ws = self._active_ws
+            loop = self._loop
+        self._reconnect_event.set()
+
+        if ws is not None and loop is not None and loop.is_running():
+            try:
+                future = asyncio.run_coroutine_threadsafe(
+                    ws.close(code=1012, reason="Client reconnect"),
+                    loop,
+                )
+                future.result(timeout=2)
+            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:
+        """
+        Replace the bearer token used for future connections.
+
+        :param secret: New non-empty bearer token.
+        :param reconnect: Whether to reconnect immediately to apply the token.
+        :returns: ``None``.
+        :raises ValueError: If ``secret`` is empty.
+        """
+        if not secret.strip():
+            raise ValueError("A non-empty secret is required for tunnel worker authentication.")
+
+        with self._lock:
+            self.secret = secret.strip()
+
+        if reconnect:
+            self.reconnect()
+
+    async def _run_async(self) -> None:
+        """
+        Run the worker connection loop with reconnect backoff.
+
+        :returns: ``None``.
+        """
+        tunnel_url = self._build_tunnel_url()
+        ssl_context = self._build_ssl_context(tunnel_url)
+
+        with self._lock:
+            self._loop = asyncio.get_running_loop()
+
+        current_delay = self.retry_delay
+
+        while not self._stop_event.is_set():
+            headers = self._build_connection_headers()
+
+            try:
+                logger.info("Connecting to %s", tunnel_url)
+                async with websockets.connect(
+                    tunnel_url,
+                    additional_headers=headers,
+                    ssl=ssl_context,
+                ) as ws:
+                    with self._lock:
+                        self._active_ws = ws
+
+                    current_delay = self.retry_delay
+                    await self._consume_welcome(ws)
+
+                    with self._lock:
+                        self._reconnect_count = 0
+
+                    try:
+                        await self._handle_messages(ws)
+                    finally:
+                        with self._lock:
+                            self._active_ws = None
+                        self._set_connected(False)
+            except websockets.exceptions.ConnectionClosed as exc:
+                self._set_connected(False)
+                logger.warning("Connection closed: %s", exc)
+            except Exception as exc:  # pragma: no cover - network error path
+                self._set_connected(False)
+                logger.error("Connection error: %s", exc)
+            finally:
+                with self._lock:
+                    self._active_ws = None
+
+            if self._stop_event.is_set():
+                break
+
+            if self._reconnect_event.is_set():
+                self._set_connected(False)
+                with self._lock:
+                    self._reconnect_count = 0
+                self._reconnect_event.clear()
+                current_delay = self.retry_delay
+                logger.info("Manual reconnect requested. Reconnecting now.")
+                continue
+
+            with self._lock:
+                self._reconnect_count += 1
+                attempt = self._reconnect_count
+
+            if self.max_retries > 0 and attempt > self.max_retries:
+                logger.error("Max reconnection attempts (%s) reached. Giving up.", self.max_retries)
+                break
+
+            logger.info("Reconnecting in %.1fs (attempt %s)", current_delay, attempt)
+
+            wait_time = 0.0
+            while (
+                wait_time < current_delay
+                and not self._stop_event.is_set()
+                and not self._reconnect_event.is_set()
+            ):
+                await asyncio.sleep(0.5)
+                wait_time += 0.5
+
+            if self._reconnect_event.is_set():
+                continue
+
+            current_delay = min(current_delay * 2, self._max_retry_delay)
+
+        with self._lock:
+            self._active_ws = None
+            self._loop = None
+
+        logger.info("Disconnected from server.")
+
+    async def _consume_welcome(self, ws: Any) -> None:
+        """
+        Read and process the initial welcome message when present.
+
+        :param ws: Active websocket client.
+        :returns: ``None``.
+        """
+        try:
+            welcome_message = await ws.recv()
+            welcome = json.loads(welcome_message)
+        except Exception:
+            self._set_connected(True)
+            return
+
+        if isinstance(welcome, dict) and welcome.get("type") == "welcome":
+            self._set_connected(
+                True,
+                remote_address=str(welcome.get("public_address") or "") or None,
+                remote_address_roundrobin=str(welcome.get("public_address_generic") or "") or None,
+                worker_index=int(welcome.get("worker_index", -1)),
+                pool_size=int(welcome.get("pool_size", 0)),
+            )
+            return
+
+        self._set_connected(True)
+
+    async def _handle_messages(self, ws: Any) -> None:
+        """
+        Handle request/response proxy messages over the worker websocket.
+
+        :param ws: Active websocket client.
+        :returns: ``None``.
+        """
+        async with httpx.AsyncClient(timeout=Timeout(timeout=15.0)) as http_client:
+            while not self._stop_event.is_set() and not self._reconnect_event.is_set():
+                try:
+                    message = await asyncio.wait_for(ws.recv(), timeout=1.0)
+                    request = json.loads(message)
+                    response = await self._forward_request(http_client, request)
+                    await ws.send(json.dumps(response))
+                except asyncio.TimeoutError:
+                    continue
+                except websockets.exceptions.ConnectionClosed:
+                    break
+                except Exception as exc:
+                    logger.error("Error handling message: %s", exc)
+
+    async def _forward_request(self, client: Any, request: dict[str, Any]) -> dict[str, Any]:
+        """
+        Forward a single proxied request to the configured local target.
+
+        :param client: HTTP client supporting ``request``.
+        :param request: Incoming tunnel request payload.
+        :returns: Tunnel response payload.
+        """
+        request_id = str(request.get("id", ""))
+        method = str(request.get("method", "GET"))
+        path = str(request.get("path", "/"))
+        headers = request.get("headers", {})
+        body_b64 = str(request.get("body", ""))
+
+        body = base64.b64decode(body_b64) if body_b64 else None
+
+        url = urljoin(f"{self.target}/", path.lstrip("/"))
+        filtered_headers = self._filter_hop_by_hop_headers(headers)
+
+        try:
+            response = await client.request(
+                method=method,
+                url=url,
+                headers=filtered_headers,
+                content=body,
+                follow_redirects=True,
+            )
+            return {
+                "id": request_id,
+                "status": response.status_code,
+                "headers": dict(response.headers.items()),
+                "body": base64.b64encode(response.content).decode("utf-8"),
+            }
+        except Exception as exc:
+            logger.error("Error forwarding request: %s", exc)
+            error_body = json.dumps({"error": str(exc)}).encode("utf-8")
+            return {
+                "id": request_id,
+                "status": 502,
+                "headers": {"Content-Type": "application/json"},
+                "body": base64.b64encode(error_body).decode("utf-8"),
+            }
+
+    def _build_tunnel_url(self) -> str:
+        """
+        Build the worker websocket URL.
+
+        :returns: WebSocket endpoint URL.
+        """
+        return f"{self.host}/api/tunnels/connection"
+
+    def _build_connection_headers(self) -> dict[str, str]:
+        """
+        Build outbound handshake headers.
+
+        :returns: Header dictionary with bearer authorization only.
+        """
+        with self._lock:
+            return {"Authorization": f"Bearer {self.secret}"}
+
+    def _set_connected(
+        self,
+        value: bool,
+        remote_address: Optional[str] = None,
+        remote_address_roundrobin: Optional[str] = None,
+        worker_index: int = -1,
+        pool_size: int = 0,
+    ) -> None:
+        """
+        Update connection state atomically.
+
+        :param value: New connected state.
+        :param remote_address: Worker URL from welcome message.
+        :param remote_address_roundrobin: Pool URL from welcome message.
+        :param worker_index: Worker index from welcome message.
+        :param pool_size: Pool size from welcome message.
+        :returns: ``None``.
+        """
+        with self._lock:
+            self._connected = value
+            self._remote_address = remote_address if value else None
+            self._remote_address_roundrobin = remote_address_roundrobin if value else None
+            self._worker_index = worker_index if value else -1
+            self._pool_size = pool_size if value else 0
+
+    def _build_ssl_context(self, tunnel_url: str) -> Optional[ssl.SSLContext]:
+        """
+        Create SSL context for secure websocket URLs.
+
+        :param tunnel_url: Resolved websocket URL.
+        :returns: SSL context for ``wss`` or ``None`` for plain ``ws``.
+        """
+        if not tunnel_url.startswith("wss://"):
+            return None
+
+        ssl_context = ssl.create_default_context()
+        if self.verify_ssl:
+            return ssl_context
+
+        ssl_context.check_hostname = False
+        ssl_context.verify_mode = ssl.CERT_NONE
+        return ssl_context
+
+    @staticmethod
+    def _filter_hop_by_hop_headers(headers: Any) -> dict[str, str]:
+        """
+        Remove hop-by-hop headers before forwarding to the local target.
+
+        :param headers: Request header mapping.
+        :returns: Filtered header mapping.
+        """
+        if not isinstance(headers, dict):
+            return {}
+
+        hop_by_hop = {"connection", "keep-alive", "transfer-encoding", "upgrade"}
+        return {
+            str(key): str(value)
+            for key, value in headers.items()
+            if str(key).lower() not in hop_by_hop
+        }

lange_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: lange-python
+Version: 0.1.0
+Summary: A bundeld set of tools, clients for the lange-suite of tools and more.
+Author: contact@robertlange.me
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: click (>=8.3.1,<9.0.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: websockets (>=12.0,<20.0)
+Description-Content-Type: text/markdown
+
+# lange-python
+
+Python helpers and clients for Lange services.
+
+## Tunnel worker
+
+```python
+from lange.tunnel import Tunnel
+
+tunnel = Tunnel(
+    host="example.com",
+    secret="your-bearer-token",
+    target="http://localhost:3000",
+)
+
+tunnel.start()
+# ...
+tunnel.stop()
+```
+

lange_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+lange/__init__.py,sha256=rfB-SZY_9PXuWSyE329ceK7H49LNwmZ-83RTjEYNP_Y,97
+lange/__main__.py,sha256=es3-sJuP_NnS-se9FQ6n3taoNCcbu0yIh0zfcsZ1304,110
+lange/cli.py,sha256=PDw-50YeTP2DK2xW-r34q3fGWx45Exz8P4RZh4Qj8Ok,8317
+lange/services_schema.py,sha256=uRYME3BvqzNWjVOA04zEPBjCCoZb4smQ6AhRBHa5-tc,1290
+lange/tunnel.py,sha256=UGyne3tkQ8HWD6cJVRzDOBTEpzzRz1L_ryT9tP1EErc,14901
+lange_python-0.1.0.dist-info/METADATA,sha256=uYkVfnzCbf77CJtPsgJ_dn_9f8v0uWXfseAyo113jM0,820
+lange_python-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+lange_python-0.1.0.dist-info/entry_points.txt,sha256=lPudEWQJNXU-Gj3MVgIvdy-VLdjUNCLY7jwY1m8HY40,39
+lange_python-0.1.0.dist-info/RECORD,,

lange_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

lange_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+lange=lange.cli:cli
+