Reorganize project structure: move public files to public/ directory

public/languages/python/aiohttp/Dockerfile

@@ -0,0 +1,13 @@
+# Pin to specific Python version (checked 2025-10-13: python:3.13-alpine is latest stable)
+FROM python:3.13-alpine
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+COPY uncloseai.py /app/uncloseai.py
+
+RUN chmod +x /app/uncloseai.py
+
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+CMD ["python3", "/app/uncloseai.py"]

public/languages/python/aiohttp/requirements.txt

@@ -0,0 +1,2 @@
+# aiohttp (checked 2025-10-13: aiohttp==3.13.0 is latest)
+aiohttp==3.13.0

public/languages/python/aiohttp/uncloseai.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""
+uncloseai. - Async Python Client (aiohttp)
+A Python async client library for OpenAI-compatible APIs with streaming support
+Compatible with vLLM, Ollama, and OpenAI-compatible endpoints
+"""
+
+import asyncio
+import aiohttp
+import json
+import os
+from typing import List, Dict, Optional, AsyncIterator
+
+
+class uncloseai:
+    """Async client for OpenAI-compatible API endpoints with streaming support"""
+
+    def __init__(
+        self,
+        model_endpoints: Optional[List[str]] = None,
+        tts_endpoints: Optional[List[str]] = None,
+        api_key: Optional[str] = None,
+        timeout: float = 30.0
+    ):
+        """
+        Initialize uncloseai. async client
+
+        Args:
+            model_endpoints: List of model endpoint URLs (defaults to MODEL_ENDPOINT_* env vars)
+            tts_endpoints: List of TTS endpoint URLs (defaults to TTS_ENDPOINT_* env vars)
+            api_key: Optional API key for authentication
+            timeout: Request timeout in seconds
+        """
+        self.timeout = timeout
+        self.api_key = api_key
+        self.models: List[Dict] = []
+        self.tts_endpoints: List[str] = []
+        self._initialized = False
+        self._model_endpoints = model_endpoints or self._discover_env_endpoints("MODEL_ENDPOINT")
+        self._tts_endpoints = tts_endpoints or self._discover_env_endpoints("TTS_ENDPOINT")
+
+    def _discover_env_endpoints(self, prefix: str) -> List[str]:
+        """Discover endpoints from environment variables like PREFIX_1, PREFIX_2, ..."""
+        endpoints = []
+        for i in range(1, 10000):
+            endpoint = os.getenv(f"{prefix}_{i}")
+            if not endpoint:
+                break
+            endpoints.append(endpoint)
+        return endpoints
+
+    async def _ensure_initialized(self):
+        """Ensure client is initialized with model discovery"""
+        if self._initialized:
+            return
+
+        async with aiohttp.ClientSession() as session:
+            for endpoint in self._model_endpoints:
+                await self._discover_models_from_endpoint(session, endpoint)
+
+        self.tts_endpoints = self._tts_endpoints
+        self._initialized = True
+
+    async def _discover_models_from_endpoint(self, session: aiohttp.ClientSession, endpoint: str) -> None:
+        """Discover available models from an endpoint"""
+        try:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+
+            async with session.get(
+                f"{endpoint}/models",
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    for model in data.get("data", []):
+                        model_id = model["id"]
+
+                        # Filter out modelperm-* and chatcmpl-* entries
+                        if model_id.startswith("modelperm-") or model_id.startswith("chatcmpl-"):
+                            continue
+
+                        self.models.append({
+                            "id": model_id,
+                            "endpoint": endpoint,
+                            "max_tokens": model.get("max_model_len", 8192)
+                        })
+        except Exception:
+            # Silently skip failed endpoints
+            pass
+
+    async def list_models(self) -> List[Dict]:
+        """Return list of discovered models with their metadata"""
+        await self._ensure_initialized()
+        return self.models.copy()
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 100,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Dict:
+        """
+        Non-streaming chat completion
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model ID (defaults to first available model)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+
+        Returns:
+            Response dict with 'choices' containing the completion
+        """
+        await self._ensure_initialized()
+        model_info = self._get_model_info(model)
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model_info["id"],
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": False,
+            **kwargs
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{model_info['endpoint']}/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=self.timeout)
+            ) as response:
+                response.raise_for_status()
+                return await response.json()
+
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 500,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> AsyncIterator[Dict]:
+        """
+        Streaming chat completion using Server-Sent Events
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model ID (defaults to first available model)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+
+        Yields:
+            Chunk dicts with 'choices' containing delta content
+        """
+        await self._ensure_initialized()
+        model_info = self._get_model_info(model)
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model_info["id"],
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": True,
+            **kwargs
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{model_info['endpoint']}/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=self.timeout)
+            ) as response:
+                response.raise_for_status()
+
+                async for line in response.content:
+                    line_str = line.decode('utf-8').strip()
+
+                    if not line_str:
+                        continue
+
+                    # SSE format: "data: {...}"
+                    if line_str.startswith('data: '):
+                        data = line_str[6:]
+
+                        # Check for stream termination
+                        if data.strip() == '[DONE]':
+                            break
+
+                        try:
+                            chunk = json.loads(data)
+                            yield chunk
+                        except json.JSONDecodeError:
+                            continue
+
+    async def tts(
+        self,
+        text: str,
+        voice: str = "alloy",
+        model: str = "tts-1",
+        response_format: str = "mp3"
+    ) -> bytes:
+        """
+        Generate speech from text
+
+        Args:
+            text: Input text to convert to speech
+            voice: Voice name (alloy, echo, fable, onyx, nova, shimmer)
+            model: TTS model (tts-1 or tts-1-hd)
+            response_format: Audio format (mp3, opus, aac, flac)
+
+        Returns:
+            Audio data as bytes
+        """
+        await self._ensure_initialized()
+
+        if not self.tts_endpoints:
+            raise ValueError("No TTS endpoints available")
+
+        endpoint = self.tts_endpoints[0]
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model,
+            "voice": voice,
+            "input": text,
+            "response_format": response_format
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{endpoint}/audio/speech",
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=self.timeout)
+            ) as response:
+                response.raise_for_status()
+                return await response.read()
+
+    def _get_model_info(self, model: Optional[str] = None) -> Dict:
+        """Get model info by ID or return first available model"""
+        if not self.models:
+            raise ValueError("No models available. Check endpoint configuration.")
+
+        if model is None:
+            return self.models[0]
+
+        for m in self.models:
+            if m["id"] == model:
+                return m
+
+        raise ValueError(f"Model '{model}' not found in discovered models")
+
+
+# Demo usage when run as script
+async def main():
+    print("=== uncloseai. Python Async Client (aiohttp) ===\n")
+
+    # Initialize client (auto-discovers from environment)
+    client = uncloseai()
+
+    models = await client.list_models()
+    if not models:
+        print("ERROR: No models discovered. Set environment variables:")
+        print("  MODEL_ENDPOINT_1, MODEL_ENDPOINT_2, etc.")
+        return
+
+    print(f"Discovered {len(models)} model(s)")
+    for model in models:
+        print(f"  - {model['id']} (max_tokens: {model['max_tokens']})")
+    print()
+
+    # Non-streaming chat example
+    print("=== Non-Streaming Chat ===")
+    response = await client.chat(
+        messages=[
+            {"role": "system", "content": "You are a helpful AI assistant."},
+            {"role": "user", "content": "Explain quantum computing in one sentence."}
+        ],
+        max_tokens=100
+    )
+    print(f"Model: {response['model']}")
+    print(f"Response: {response['choices'][0]['message']['content']}\n")
+
+    # Streaming chat example
+    print("=== Streaming Chat ===")
+    model_id = models[1]["id"] if len(models) > 1 else None
+    print(f"Model: {model_id or models[0]['id']}")
+    print("Response: ", end="", flush=True)
+
+    async for chunk in client.chat_stream(
+        messages=[
+            {"role": "system", "content": "You are a coding assistant."},
+            {"role": "user", "content": "Write an async Python function to fetch multiple URLs"}
+        ],
+        model=model_id,
+        max_tokens=200
+    ):
+        if chunk.get("choices") and len(chunk["choices"]) > 0:
+            delta = chunk["choices"][0].get("delta", {})
+            content = delta.get("content", "")
+            if content:
+                print(content, end="", flush=True)
+
+    print("\n")
+
+    # TTS example
+    if client.tts_endpoints:
+        print("=== TTS Speech Generation ===")
+        audio_data = await client.tts(
+            text="Hello from uncloseai. Python async client with aiohttp! This demonstrates text to speech with streaming support.",
+            voice="alloy"
+        )
+
+        with open("speech.mp3", "wb") as f:
+            f.write(audio_data)
+
+        print(f"[OK] Speech file created: speech.mp3 ({len(audio_data)} bytes)\n")
+
+    print("=== Examples Complete ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

public/languages/python/httpx-async/Dockerfile

@@ -0,0 +1,13 @@
+# Pin to specific Python version (checked 2025-10-12: python:3.13-alpine is latest stable)
+FROM python:3.13-alpine
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+COPY uncloseai.py /app/uncloseai.py
+
+RUN chmod +x /app/uncloseai.py
+
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+CMD ["python3", "/app/uncloseai.py"]

public/languages/python/httpx-async/requirements.txt

@@ -0,0 +1,2 @@
+# Async HTTP library (checked 2025-10-12)
+httpx==0.28.1

public/languages/python/httpx-async/uncloseai.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+uncloseai. - Async Python Client (httpx)
+A Python async client for OpenAI-compatible APIs with streaming support
+"""
+
+import httpx
+import json
+import os
+import asyncio
+from typing import List, Dict, Optional, AsyncIterator
+
+
+class uncloseai:
+    """Async client for OpenAI-compatible API endpoints with streaming support"""
+
+    def __init__(
+        self,
+        model_endpoints: Optional[List[str]] = None,
+        tts_endpoints: Optional[List[str]] = None,
+        api_key: Optional[str] = None,
+        timeout: float = 30.0
+    ):
+        self.timeout = timeout
+        self.api_key = api_key
+        self.models: List[Dict] = []
+        self.tts_endpoints: List[str] = []
+        self._initialized = False
+        self._model_endpoints = model_endpoints or self._discover_env_endpoints("MODEL_ENDPOINT")
+        self._tts_endpoints = tts_endpoints or self._discover_env_endpoints("TTS_ENDPOINT")
+
+    def _discover_env_endpoints(self, prefix: str) -> List[str]:
+        endpoints = []
+        for i in range(1, 10000):
+            endpoint = os.getenv(f"{prefix}_{i}")
+            if not endpoint:
+                break
+            endpoints.append(endpoint)
+        return endpoints
+
+    async def _ensure_initialized(self):
+        if self._initialized:
+            return
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            for endpoint in self._model_endpoints:
+                await self._discover_models_from_endpoint(client, endpoint)
+
+        self.tts_endpoints = self._tts_endpoints
+        self._initialized = True
+
+    async def _discover_models_from_endpoint(self, client: httpx.AsyncClient, endpoint: str) -> None:
+        try:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+
+            response = await client.get(f"{endpoint}/models", headers=headers)
+
+            if response.status_code == 200:
+                data = response.json()
+                for model in data.get("data", []):
+                    self.models.append({
+                        "id": model["id"],
+                        "endpoint": endpoint,
+                        "max_tokens": model.get("max_model_len", 8192)
+                    })
+        except Exception as e:
+            print(f"Warning: Failed to discover models from {endpoint}: {e}")
+
+    async def list_models(self) -> List[Dict]:
+        await self._ensure_initialized()
+        return self.models.copy()
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 100,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Dict:
+        await self._ensure_initialized()
+        model_info = self._get_model_info(model)
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model_info["id"],
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": False,
+            **kwargs
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(
+                f"{model_info['endpoint']}/chat/completions",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 500,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> AsyncIterator[Dict]:
+        await self._ensure_initialized()
+        model_info = self._get_model_info(model)
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model_info["id"],
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": True,
+            **kwargs
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            async with client.stream(
+                "POST",
+                f"{model_info['endpoint']}/chat/completions",
+                headers=headers,
+                json=payload
+            ) as response:
+                response.raise_for_status()
+
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+
+                    if line.startswith('data: '):
+                        data = line[6:]
+
+                        if data.strip() == '[DONE]':
+                            break
+
+                        try:
+                            chunk = json.loads(data)
+                            yield chunk
+                        except json.JSONDecodeError:
+                            continue
+
+    async def tts(
+        self,
+        text: str,
+        voice: str = "alloy",
+        model: str = "tts-1",
+        response_format: str = "mp3"
+    ) -> bytes:
+        await self._ensure_initialized()
+
+        if not self.tts_endpoints:
+            raise ValueError("No TTS endpoints available")
+
+        endpoint = self.tts_endpoints[0]
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model,
+            "voice": voice,
+            "input": text,
+            "response_format": response_format
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(
+                f"{endpoint}/audio/speech",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.content
+
+    def _get_model_info(self, model: Optional[str] = None) -> Dict:
+        if not self.models:
+            raise ValueError("No models available. Check endpoint configuration.")
+
+        if model is None:
+            return self.models[0]
+
+        for m in self.models:
+            if m["id"] == model:
+                return m
+
+        raise ValueError(f"Model '{model}' not found in discovered models")
+
+
+async def main():
+    print("=== uncloseai. Python Async Client (httpx) ===\n")
+
+    client = uncloseai()
+
+    models = await client.list_models()
+    if not models:
+        print("ERROR: No models discovered. Set environment variables:")
+        print("  MODEL_ENDPOINT_1, MODEL_ENDPOINT_2, etc.")
+        return
+
+    print(f"Discovered {len(models)} model(s)")
+    for model in models:
+        print(f"  - {model['id']} (max_tokens: {model['max_tokens']})")
+    print()
+
+    # Non-streaming chat
+    print("=== Non-Streaming Chat ===")
+    response = await client.chat(
+        messages=[
+            {"role": "system", "content": "You are a helpful AI assistant."},
+            {"role": "user", "content": "Explain quantum computing in one sentence."}
+        ],
+        max_tokens=100
+    )
+    print(f"Model: {response['model']}")
+    print(f"Response: {response['choices'][0]['message']['content']}\n")
+
+    # Streaming chat
+    print("=== Streaming Chat ===")
+    model_id = models[1]["id"] if len(models) > 1 else None
+    print(f"Model: {model_id or models[0]['id']}")
+    print("Response: ", end="", flush=True)
+
+    async for chunk in client.chat_stream(
+        messages=[
+            {"role": "system", "content": "You are a coding assistant."},
+            {"role": "user", "content": "Write a Python async function to fetch multiple URLs"}
+        ],
+        model=model_id,
+        max_tokens=200
+    ):
+        if chunk.get("choices") and len(chunk["choices"]) > 0:
+            delta = chunk["choices"][0].get("delta", {})
+            content = delta.get("content", "")
+            if content:
+                print(content, end="", flush=True)
+
+    print("\n")
+
+    # TTS
+    if client.tts_endpoints:
+        print("=== TTS Speech Generation ===")
+        audio_data = await client.tts(
+            text="Hello from uncloseai. Python async client! This demonstrates text to speech with streaming support.",
+            voice="alloy"
+        )
+
+        with open("speech.mp3", "wb") as f:
+            f.write(audio_data)
+
+        print(f"[OK] Speech file created: speech.mp3 ({len(audio_data)} bytes)\n")
+
+    print("=== Examples Complete ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

public/languages/python/openai/Dockerfile

@@ -0,0 +1,13 @@
+# Pin to specific Python version (checked 2025-10-12: python:3.13-alpine is latest stable)
+FROM python:3.13-alpine
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+COPY uncloseai.py /app/uncloseai.py
+
+RUN chmod +x /app/uncloseai.py
+
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+CMD ["python3", "/app/uncloseai.py"]

public/languages/python/openai/requirements.txt

@@ -0,0 +1,2 @@
+openai==2.3.0
+requests==2.32.5

public/languages/python/openai/uncloseai.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""
+uncloseai. - Python Client using OpenAI SDK
+A Python client library for OpenAI-compatible APIs with streaming support
+Compatible with vLLM, Ollama, and OpenAI-compatible endpoints
+"""
+
+from openai import OpenAI
+import os
+import requests
+from typing import List, Dict, Optional, Iterator
+
+
+class uncloseai:
+    """Client for OpenAI-compatible API endpoints using OpenAI SDK"""
+
+    def __init__(
+        self,
+        model_endpoints: Optional[List[str]] = None,
+        tts_endpoints: Optional[List[str]] = None,
+        api_key: str = "dummy-key",
+        timeout: int = 30
+    ):
+        """
+        Initialize uncloseai. client with automatic model discovery
+
+        Args:
+            model_endpoints: List of model endpoint URLs (defaults to MODEL_ENDPOINT_* env vars)
+            tts_endpoints: List of TTS endpoint URLs (defaults to TTS_ENDPOINT_* env vars)
+            api_key: API key for authentication (default: "dummy-key")
+            timeout: Request timeout in seconds
+        """
+        self.timeout = timeout
+        self.api_key = api_key
+        self.models: List[Dict] = []
+        self.tts_endpoints: List[str] = []
+
+        # Discover endpoints from environment or use provided
+        if model_endpoints is None:
+            model_endpoints = self._discover_env_endpoints("MODEL_ENDPOINT")
+        if tts_endpoints is None:
+            tts_endpoints = self._discover_env_endpoints("TTS_ENDPOINT")
+
+        # Discover models from each endpoint
+        for endpoint in model_endpoints:
+            self._discover_models_from_endpoint(endpoint)
+
+        self.tts_endpoints = tts_endpoints
+
+    def _discover_env_endpoints(self, prefix: str) -> List[str]:
+        """Discover endpoints from environment variables like PREFIX_1, PREFIX_2, ..."""
+        endpoints = []
+        for i in range(1, 10000):
+            endpoint = os.getenv(f"{prefix}_{i}")
+            if not endpoint:
+                break
+            endpoints.append(endpoint)
+        return endpoints
+
+    def _discover_models_from_endpoint(self, endpoint: str) -> None:
+        """Discover available models from an endpoint"""
+        try:
+            response = requests.get(f"{endpoint}/models", timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                for model in data.get("data", []):
+                    model_id = model["id"]
+
+                    # Filter out modelperm-* and chatcmpl-* entries
+                    if model_id.startswith("modelperm-") or model_id.startswith("chatcmpl-"):
+                        continue
+
+                    self.models.append({
+                        "id": model_id,
+                        "endpoint": endpoint,
+                        "max_tokens": model.get("max_model_len", 8192)
+                    })
+        except Exception:
+            # Silently skip failed endpoints
+            pass
+
+    def list_models(self) -> List[Dict]:
+        """Return list of discovered models with their metadata"""
+        return self.models.copy()
+
+    def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 100,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Dict:
+        """
+        Non-streaming chat completion
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model ID (defaults to first available model)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+
+        Returns:
+            Response dict with 'choices' containing the completion
+        """
+        model_info = self._get_model_info(model)
+
+        client = OpenAI(
+            base_url=model_info['endpoint'],
+            api_key=self.api_key,
+            timeout=self.timeout
+        )
+
+        response = client.chat.completions.create(
+            model=model_info["id"],
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            **kwargs
+        )
+
+        # Convert OpenAI response to dict format
+        return {
+            "id": response.id,
+            "model": response.model,
+            "choices": [
+                {
+                    "index": choice.index,
+                    "message": {
+                        "role": choice.message.role,
+                        "content": choice.message.content
+                    },
+                    "finish_reason": choice.finish_reason
+                }
+                for choice in response.choices
+            ],
+            "usage": {
+                "prompt_tokens": response.usage.prompt_tokens,
+                "completion_tokens": response.usage.completion_tokens,
+                "total_tokens": response.usage.total_tokens
+            }
+        }
+
+    def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 500,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Iterator[str]:
+        """
+        Streaming chat completion using OpenAI SDK
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model ID (defaults to first available model)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+
+        Yields:
+            Content strings as they arrive
+        """
+        model_info = self._get_model_info(model)
+
+        client = OpenAI(
+            base_url=model_info['endpoint'],
+            api_key=self.api_key,
+            timeout=self.timeout
+        )
+
+        stream = client.chat.completions.create(
+            model=model_info["id"],
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stream=True,
+            **kwargs
+        )
+
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+
+    def tts(
+        self,
+        text: str,
+        voice: str = "alloy",
+        model: str = "tts-1",
+        output_file: str = "speech.mp3"
+    ) -> str:
+        """
+        Generate speech from text
+
+        Args:
+            text: Input text to convert to speech
+            voice: Voice name (alloy, echo, fable, onyx, nova, shimmer)
+            model: TTS model (tts-1 or tts-1-hd)
+            output_file: Path to save the audio file
+
+        Returns:
+            Path to the saved audio file
+        """
+        if not self.tts_endpoints:
+            raise ValueError("No TTS endpoints available")
+
+        endpoint = self.tts_endpoints[0]
+
+        client = OpenAI(
+            base_url=endpoint,
+            api_key=self.api_key,
+            timeout=self.timeout
+        )
+
+        with client.audio.speech.with_streaming_response.create(
+            model=model,
+            voice=voice,
+            input=text
+        ) as response:
+            response.stream_to_file(output_file)
+
+        return output_file
+
+    def _get_model_info(self, model: Optional[str] = None) -> Dict:
+        """Get model info by ID or return first available model"""
+        if not self.models:
+            raise ValueError("No models available. Check endpoint configuration.")
+
+        if model is None:
+            return self.models[0]
+
+        for m in self.models:
+            if m["id"] == model:
+                return m
+
+        raise ValueError(f"Model '{model}' not found in discovered models")
+
+
+# Demo usage when run as script
+if __name__ == "__main__":
+    print("=== uncloseai. Python Client (OpenAI SDK) ===\n")
+
+    # Initialize client (auto-discovers from environment)
+    client = uncloseai()
+
+    if not client.models:
+        print("ERROR: No models discovered. Set environment variables:")
+        print("  MODEL_ENDPOINT_1, MODEL_ENDPOINT_2, etc.")
+        exit(1)
+
+    print(f"Discovered {len(client.models)} model(s)")
+    for model in client.models:
+        print(f"  - {model['id']} (max_tokens: {model['max_tokens']})")
+    print()
+
+    # Non-streaming chat example
+    print("=== Non-Streaming Chat ===")
+    response = client.chat(
+        messages=[
+            {"role": "system", "content": "You are a helpful AI assistant."},
+            {"role": "user", "content": "Explain quantum computing in one sentence."}
+        ],
+        max_tokens=100
+    )
+    print(f"Model: {response['model']}")
+    print(f"Response: {response['choices'][0]['message']['content']}\n")
+
+    # Streaming chat example
+    print("=== Streaming Chat ===")
+    if len(client.models) > 1:
+        model_id = client.models[1]["id"]
+    else:
+        model_id = None
+
+    print(f"Model: {model_id or client.models[0]['id']}")
+    print("Response: ", end="", flush=True)
+
+    for content in client.chat_stream(
+        messages=[
+            {"role": "system", "content": "You are a coding assistant."},
+            {"role": "user", "content": "Write a Python function to check if a number is prime"}
+        ],
+        model=model_id,
+        max_tokens=200
+    ):
+        print(content, end="", flush=True)
+
+    print("\n")
+
+    # TTS example
+    if client.tts_endpoints:
+        print("=== TTS Speech Generation ===")
+        output_path = client.tts(
+            text="Hello from uncloseai. Python client with OpenAI SDK! This demonstrates text to speech with streaming support.",
+            voice="alloy",
+            output_file="speech.mp3"
+        )
+
+        if os.path.exists(output_path):
+            file_size = os.path.getsize(output_path)
+            print(f"[OK] Speech file created: {output_path} ({file_size} bytes)\n")
+
+    print("=== Examples Complete ===")

public/languages/python/requests/Dockerfile

@@ -0,0 +1,13 @@
+# Pin to specific Python version (checked 2025-10-12: python:3.13-alpine is latest stable)
+FROM python:3.13-alpine
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+COPY uncloseai.py /app/uncloseai.py
+
+RUN chmod +x /app/uncloseai.py
+
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+CMD ["python3", "/app/uncloseai.py"]

public/languages/python/requests/requirements.txt

@@ -0,0 +1,2 @@
+# Python HTTP library (checked 2025-10-12)
+requests==2.32.5

public/languages/python/requests/uncloseai.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+uncloseai - Python client library for OpenAI-compatible APIs
+Supports streaming and non-streaming chat, model discovery, and TTS
+Compatible with vLLM, Ollama, and OpenAI-compatible endpoints
+"""
+
+import requests
+import json
+import os
+from typing import List, Dict, Optional, Iterator, Union
+
+
+class uncloseai:
+    """Client for OpenAI-compatible API endpoints with streaming support"""
+
+    def __init__(
+        self,
+        model_endpoints: Optional[List[str]] = None,
+        tts_endpoints: Optional[List[str]] = None,
+        api_key: Optional[str] = None,
+        timeout: int = 30
+    ):
+        """
+        Initialize uncloseai. client with automatic model discovery
+
+        Args:
+            model_endpoints: List of model endpoint URLs (defaults to MODEL_ENDPOINT_* env vars)
+            tts_endpoints: List of TTS endpoint URLs (defaults to TTS_ENDPOINT_* env vars)
+            api_key: Optional API key for authentication
+            timeout: Request timeout in seconds
+        """
+        self.timeout = timeout
+        self.api_key = api_key
+        self.models: List[Dict] = []
+        self.tts_endpoints: List[str] = []
+
+        # Discover endpoints from environment or use provided
+        if model_endpoints is None:
+            model_endpoints = self._discover_env_endpoints("MODEL_ENDPOINT")
+        if tts_endpoints is None:
+            tts_endpoints = self._discover_env_endpoints("TTS_ENDPOINT")
+
+        # Discover models from each endpoint
+        for endpoint in model_endpoints:
+            self._discover_models_from_endpoint(endpoint)
+
+        self.tts_endpoints = tts_endpoints
+
+    def _discover_env_endpoints(self, prefix: str) -> List[str]:
+        """Discover endpoints from environment variables like PREFIX_1, PREFIX_2, ..."""
+        endpoints = []
+        for i in range(1, 10000):
+            endpoint = os.getenv(f"{prefix}_{i}")
+            if not endpoint:
+                break
+            endpoints.append(endpoint)
+        return endpoints
+
+    def _discover_models_from_endpoint(self, endpoint: str) -> None:
+        """Discover available models from an endpoint"""
+        try:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+
+            response = requests.get(
+                f"{endpoint}/models",
+                headers=headers,
+                timeout=self.timeout
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                for model in data.get("data", []):
+                    self.models.append({
+                        "id": model["id"],
+                        "endpoint": endpoint,
+                        "max_tokens": model.get("max_model_len", 8192)
+                    })
+        except Exception as e:
+            print(f"Warning: Failed to discover models from {endpoint}: {e}")
+
+    def list_models(self) -> List[Dict]:
+        """Return list of discovered models with their metadata"""
+        return self.models.copy()
+
+    def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 100,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Dict:
+        """
+        Non-streaming chat completion
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model ID (defaults to first available model)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+
+        Returns:
+            Response dict with 'choices' containing the completion
+        """
+        model_info = self._get_model_info(model)
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model_info["id"],
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": False,
+            **kwargs
+        }
+
+        response = requests.post(
+            f"{model_info['endpoint']}/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=self.timeout
+        )
+        response.raise_for_status()
+
+        return response.json()
+
+    def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: int = 500,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Iterator[Dict]:
+        """
+        Streaming chat completion using Server-Sent Events
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model ID (defaults to first available model)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+
+        Yields:
+            Chunk dicts with 'choices' containing delta content
+        """
+        model_info = self._get_model_info(model)
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model_info["id"],
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": True,
+            **kwargs
+        }
+
+        response = requests.post(
+            f"{model_info['endpoint']}/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=self.timeout,
+            stream=True
+        )
+        response.raise_for_status()
+
+        # Parse SSE stream
+        for line in response.iter_lines():
+            if not line:
+                continue
+
+            line = line.decode('utf-8')
+
+            # SSE format: "data: {...}"
+            if line.startswith('data: '):
+                data = line[6:]  # Remove "data: " prefix
+
+                # Check for stream termination
+                if data.strip() == '[DONE]':
+                    break
+
+                try:
+                    chunk = json.loads(data)
+                    yield chunk
+                except json.JSONDecodeError:
+                    continue
+
+    def tts(
+        self,
+        text: str,
+        voice: str = "alloy",
+        model: str = "tts-1",
+        response_format: str = "mp3"
+    ) -> bytes:
+        """
+        Generate speech from text
+
+        Args:
+            text: Input text to convert to speech
+            voice: Voice name (alloy, echo, fable, onyx, nova, shimmer)
+            model: TTS model (tts-1 or tts-1-hd)
+            response_format: Audio format (mp3, opus, aac, flac)
+
+        Returns:
+            Audio data as bytes
+        """
+        if not self.tts_endpoints:
+            raise ValueError("No TTS endpoints available")
+
+        endpoint = self.tts_endpoints[0]
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        payload = {
+            "model": model,
+            "voice": voice,
+            "input": text,
+            "response_format": response_format
+        }
+
+        response = requests.post(
+            f"{endpoint}/audio/speech",
+            headers=headers,
+            json=payload,
+            timeout=self.timeout
+        )
+        response.raise_for_status()
+
+        return response.content
+
+    def _get_model_info(self, model: Optional[str] = None) -> Dict:
+        """Get model info by ID or return first available model"""
+        if not self.models:
+            raise ValueError("No models available. Check endpoint configuration.")
+
+        if model is None:
+            return self.models[0]
+
+        for m in self.models:
+            if m["id"] == model:
+                return m
+
+        raise ValueError(f"Model '{model}' not found in discovered models")
+
+
+# Demo usage when run as script
+if __name__ == "__main__":
+    print("=== uncloseai. Python Client (with Streaming) ===\n")
+
+    # Initialize client (auto-discovers from environment)
+    client = uncloseai()
+
+    if not client.models:
+        print("ERROR: No models discovered. Set environment variables:")
+        print("  MODEL_ENDPOINT_1, MODEL_ENDPOINT_2, etc.")
+        exit(1)
+
+    print(f"Discovered {len(client.models)} model(s)")
+    for model in client.models:
+        print(f"  - {model['id']} (max_tokens: {model['max_tokens']})")
+    print()
+
+    # Non-streaming chat example
+    print("=== Non-Streaming Chat ===")
+    response = client.chat(
+        messages=[
+            {"role": "system", "content": "You are a helpful AI assistant."},
+            {"role": "user", "content": "Explain quantum computing in one sentence."}
+        ],
+        max_tokens=100
+    )
+    print(f"Model: {response['model']}")
+    print(f"Response: {response['choices'][0]['message']['content']}\n")
+
+    # Streaming chat example
+    print("=== Streaming Chat ===")
+    if len(client.models) > 1:
+        model_id = client.models[1]["id"]
+    else:
+        model_id = None
+
+    print(f"Model: {model_id or client.models[0]['id']}")
+    print("Response: ", end="", flush=True)
+
+    for chunk in client.chat_stream(
+        messages=[
+            {"role": "system", "content": "You are a coding assistant."},
+            {"role": "user", "content": "Write a Python function to check if a number is prime"}
+        ],
+        model=model_id,
+        max_tokens=200
+    ):
+        if chunk.get("choices") and len(chunk["choices"]) > 0:
+            delta = chunk["choices"][0].get("delta", {})
+            content = delta.get("content", "")
+            if content:
+                print(content, end="", flush=True)
+
+    print("\n")
+
+    # TTS example
+    if client.tts_endpoints:
+        print("=== TTS Speech Generation ===")
+        audio_data = client.tts(
+            text="Hello from uncloseai. Python client! This demonstrates text to speech with streaming support.",
+            voice="alloy"
+        )
+
+        with open("speech.mp3", "wb") as f:
+            f.write(audio_data)
+
+        print(f"[OK] Speech file created: speech.mp3 ({len(audio_data)} bytes)\n")
+
+    print("=== Examples Complete ===")