ziomek 0.1.1__tar.gz

ziomek-0.1.1/.gitignore

@@ -0,0 +1,21 @@
+out/
+node_modules/
+*.vsix
+.DS_Store
+build/
+__pycache__/
+.venv/
+**/.venv/
+*.pyc
+*.egg-info/
+IDEAS.md
+ISSUES.md
+.worktrees/
+
+# Internal docs
+docs/internal/
+
+# Cache
+.mypy_cache/
+.ruff_cache/
+

ziomek-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bartlomiej Cieszkowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ziomek-0.1.1/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: ziomek
+Version: 0.1.1
+Summary: ziomek - Humanize AI
+Project-URL: Homepage, https://github.com/bartlomiejcieszkowski/ziomek
+Project-URL: Bug Tracker, https://github.com/bartlomiejcieszkowski/ziomek/issues
+License: MIT License
+        
+        Copyright (c) 2026 Bartlomiej Cieszkowski
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: agent,ai,llm,skill
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.100
+Requires-Dist: numpy>=1.24
+Requires-Dist: pillow>=10.0
+Requires-Dist: pocket-tts>=3.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pygame-ce>=2.5.8
+Requires-Dist: requests>=2.31
+Requires-Dist: safetensors>=0.4
+Requires-Dist: scipy>=1.10
+Requires-Dist: sounddevice>=0.4
+Requires-Dist: soundfile>=0.12
+Requires-Dist: torch>=2.0
+Requires-Dist: uvicorn[standard]>=0.23
+Provides-Extra: dev
+Requires-Dist: httpx2>=2.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'

ziomek-0.1.1/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "ziomek"
+description = "ziomek - Humanize AI"
+dynamic = ["version"]
+author = [
+    {name = "Bartlomiej Cieszkowski", email = "bartlomiej.cieszkowski@gmail.com"}
+]
+requires-python = ">=3.10"
+keywords = ["llm", "ai", "agent", "skill"]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+dependencies = [
+    "pocket-tts>=3.0", "torch>=2.0", "numpy>=1.24", "scipy>=1.10",
+    "sounddevice>=0.4", "soundfile>=0.12", "safetensors>=0.4",
+    "fastapi>=0.100", "uvicorn[standard]>=0.23", "pydantic>=2.0",
+    "pillow>=10.0", "requests>=2.31",
+    "pygame-ce>=2.5.8",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/bartlomiejcieszkowski/ziomek"
+"Bug Tracker" = "https://github.com/bartlomiejcieszkowski/ziomek/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-asyncio>=0.21", "httpx2>=2.0", "ruff>=0.1"]
+
+[project.scripts]
+ziomek = "ziomek.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+only-packages = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ziomek"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["I"]
+
+[tool.hatch.version]
+path = "src/ziomek/__init__.py"
+
+[tool.pytest.ini_options]
+log_cli = true
+log_level = "NOTSET"

ziomek-0.1.1/src/ziomek/__init__.py

@@ -0,0 +1,2 @@
+"""ziomek — Humanize AI backend server."""
+__version__ = "0.1.1"

ziomek-0.1.1/src/ziomek/api/__init__.py

@@ -0,0 +1 @@
+"""ziomek API package."""

ziomek-0.1.1/src/ziomek/api/avatar.py

@@ -0,0 +1,136 @@
+"""ziomek avatar API endpoints."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+
+from ziomek.avatar.state_machine import AvatarInput
+from ziomek.avatar.sprites import sprite_to_base64
+
+
+router = APIRouter()
+
+# Path to the shared HTML renderer
+_renderer_html = Path(__file__).parent.parent / "client" / "resources" / "renderer.html"
+
+
+def _not_initialized(msg: str) -> JSONResponse:
+    return JSONResponse(status_code=503, content={"error": msg})
+
+
+@router.get("/api/avatar/view")
+async def get_avatar_view() -> HTMLResponse:
+    """Serve the avatar renderer HTML (fetched by client from server)."""
+    if not _renderer_html.exists():
+        return HTMLResponse(
+            content="<html><body><h1>Renderer not found</h1></body></html>",
+            status_code=404,
+        )
+    return HTMLResponse(content=_renderer_html.read_text())
+
+
+@router.get("/api/avatar/state")
+async def get_state() -> Any:
+    """Get current avatar state."""
+    from ziomek.server import _state_machine
+    if _state_machine is None:
+        return JSONResponse(status_code=503, content={"error": "State machine not initialized"})
+    state = _state_machine.tick(16)
+    return {
+        "expression": state.expressionName,
+        "cycleIndex": state.cycleIndex,
+        "message": state.message,
+        "messageExpiry": state.messageExpiry,
+    }
+
+
+@router.post("/api/avatar/input")
+async def set_input(request: Request) -> Any:
+    """Feed gamepad/VSCode state to the state machine."""
+    from ziomek.server import _state_machine
+    if _state_machine is None:
+        return JSONResponse(status_code=503, content={"error": "State machine not initialized"})
+    body = await request.json()
+    inp = AvatarInput(
+        buttons=body.get("buttons", []),
+        axes=body.get("axes", [0, 0, 0]),
+        connected=body.get("connected", False),
+        streaming=body.get("streaming", False),
+        chatFocused=body.get("chatFocused", False),
+        errorState=body.get("errorState", False),
+    )
+    _state_machine.update(inp)
+    state = _state_machine.tick(16)
+    return {"expression": state.expressionName, "cycleIndex": state.cycleIndex}
+
+
+@router.post("/api/avatar/expression")
+async def set_expression(request: Request) -> Any:
+    """Force-set an expression."""
+    from ziomek.server import _state_machine
+    if _state_machine is None:
+        return JSONResponse(status_code=503, content={"error": "State machine not initialized"})
+    body = await request.json()
+    name = body.get("name", "")
+    duration_ms = body.get("duration_ms")
+    ok = _state_machine.setExpression(name, duration_ms)
+    return {"ok": ok}
+
+
+@router.post("/api/avatar/speak")
+async def speak(request: Request) -> Any:
+    """Generate speech and optionally set an expression."""
+    from ziomek.server import _tts_model, _voice_cache, _audio_player, _state_machine
+    from ziomek.tts.generate import generate_wav
+
+    body = await request.json()
+    text = body.get("text", "")
+    voice = body.get("voice", "default")
+    expression = body.get("expression")
+
+    if _tts_model is None or not _tts_model.ready:
+        return JSONResponse(status_code=503, content={"error": "TTS not ready"})
+    if _state_machine is None:
+        return JSONResponse(status_code=503, content={"error": "State machine not initialized"})
+    if _voice_cache is None:
+        return JSONResponse(status_code=503, content={"error": "Voice cache not initialized"})
+    if expression:
+        _state_machine.setExpression(expression)
+    audio_b64, duration, sample_rate = generate_wav(_tts_model, _voice_cache, text, voice)
+    import base64
+    wav_bytes = base64.b64decode(audio_b64)
+    if _audio_player is not None:
+        _audio_player.play(wav_bytes, sample_rate)
+    return {
+        "status": "playing",
+        "duration": duration,
+        "sample_rate": sample_rate,
+        "channels": 1,
+        "bit_depth": 16,
+        "voice": voice,
+    }
+
+
+@router.get("/api/avatar/sprite")
+async def get_sprite() -> Any:
+    """Get sprite sheet for client rendering."""
+    from ziomek.server import _skin_registry
+    if _skin_registry is None:
+        return JSONResponse(status_code=503, content={"error": "Skin registry not initialized"})
+    skin = _skin_registry.get("single-frame")
+    if skin is None:
+        return JSONResponse(status_code=404, content={"error": "No default skin"})
+    try:
+        sprite_data = sprite_to_base64(skin.getSpriteBuffer())
+    except FileNotFoundError:
+        return JSONResponse(status_code=404, content={"error": "Sprite file not found"})
+    return {
+        "sprite_b64": sprite_data,
+        "width": skin.spriteWidth,
+        "height": skin.spriteHeight,
+        "frameWidth": skin.frameWidth,
+        "frameHeight": skin.frameHeight,
+    }

ziomek-0.1.1/src/ziomek/api/health.py

@@ -0,0 +1,37 @@
+"""ziomek health endpoints."""
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from ziomek.server import _tts_model
+
+
+router = APIRouter(prefix="/api")
+
+
+@router.get("/status")
+async def status():
+    """Get server health status."""
+    ready = _tts_model is not None and _tts_model.ready
+    model_loaded = _tts_model is not None and _tts_model.ready
+    return {
+        "ready": ready,
+        "model_loaded": model_loaded,
+        "endpoints": {
+            "tts": ["POST /api/tts/generate", "POST /api/tts/speak", "GET /api/tts/status", "GET /api/tts/voices"],
+            "avatar": ["POST /api/avatar/input", "GET /api/avatar/state", "POST /api/avatar/expression", "GET /api/avatar/sprite", "POST /api/avatar/speak", "GET /api/avatar/view"],
+        },
+    }
+
+
+@router.get("/")
+async def root() -> dict:
+    """Server root endpoint."""
+    return {
+        "name": "ziomek",
+        "version": "0.1.0",
+        "endpoints": {
+            "generate": "POST /api/tts/generate",
+            "status": "GET /api/status",
+        },
+    }

ziomek-0.1.1/src/ziomek/api/tts.py

@@ -0,0 +1,71 @@
+"""ziomek TTS API endpoints."""
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+router = APIRouter(prefix="/api/tts")
+
+
+@router.get("/status")
+async def tts_status() -> dict:
+    """Get TTS server status."""
+    from ziomek.server import _tts_model
+    ready = _tts_model is not None and _tts_model.ready  # type: ignore[arg-type]
+    return {"ready": ready, "voices": ["cosette", "marius", "javert", "alba"]}
+
+
+@router.get("/voices")
+async def list_voices() -> dict:
+    """List available voices."""
+    return {
+        "voices": ["cosette", "marius", "javert", "alba", "jean", "anna", "vera", "fantine",
+                   "charles", "paul", "eponine", "azelma", "george", "mary", "jane",
+                   "michael", "eve", "bill_boerst", "peter_yearsley", "stuart_bell",
+                   "caro_davy", "giovanni", "lola", "juergen", "rafael", "estelle"],
+        "default": "cosette",
+    }
+
+
+@router.post("/generate")
+async def tts_generate(request: Request) -> dict:
+    """Generate WAV audio from text."""
+    from ziomek.server import _tts_model, _voice_cache
+    if _tts_model is None or not _tts_model.ready:
+        return JSONResponse(status_code=503, content={"error": "TTS model not loaded"})
+    body = await request.json()
+    text = body.get("text", "")
+    voice = body.get("voice", "default")
+    from ziomek.tts.generate import generate_wav
+    audio_b64, duration, sample_rate = generate_wav(_tts_model, _voice_cache, text, voice)
+    return {
+        "audio_b64": audio_b64,
+        "duration": duration,
+        "sample_rate": sample_rate,
+        "channels": 1,
+        "bit_depth": 16,
+        "voice": voice,
+    }
+
+
+@router.post("/speak")
+async def tts_speak(request: Request) -> dict:
+    """Generate and play audio."""
+    from ziomek.server import _tts_model, _voice_cache, _audio_player
+    if _tts_model is None or not _tts_model.ready:
+        return JSONResponse(status_code=503, content={"error": "TTS not ready"})
+    body = await request.json()
+    text = body.get("text", "")
+    voice = body.get("voice", "default")
+    from ziomek.tts.generate import generate_wav
+    audio_b64, duration, sample_rate = generate_wav(_tts_model, _voice_cache, text, voice)
+    import base64
+    wav_bytes = base64.b64decode(audio_b64)
+    if _audio_player is not None:  # type: ignore[arg-type]
+        _audio_player.play(wav_bytes, sample_rate)
+    return {
+        "status": "playing",
+        "duration": duration,
+        "sample_rate": sample_rate,
+        "channels": 1,
+        "bit_depth": 16,
+        "voice": voice,
+    }

ziomek-0.1.1/src/ziomek/avatar/__init__.py

@@ -0,0 +1 @@
+"""ziomek avatar package."""

ziomek-0.1.1/src/ziomek/avatar/skins.py

@@ -0,0 +1,127 @@
+"""ziomek avatar skin registry — ported from TypeScript."""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Row index map: expression name → sprite sheet row
+_ROW_MAP: dict[str, int] = {
+    "happy": 0,
+    "surprised": 1,
+    "curious": 2,
+    "looking": 2,
+    "thinking": 2,
+    "focused": 3,
+    "bored": 3,
+    "dying": 4,
+    "neutral": 1,
+}
+
+
+@dataclass
+class SingleFrameSkin:
+    """A skin that uses a single frame per expression."""
+
+    name: str
+    _sprite_path: str  # path to PNG file
+    _sprite_buffer: bytes | None = field(default=None, repr=False)
+
+    _sprite_width: int = 0
+    _sprite_height: int = 0
+    _frame_width: int = 0
+    _frame_height: int = 0
+
+    @property
+    def sprite_path(self) -> str:
+        return self._sprite_path
+
+    def _parse_png(self) -> None:
+        """Parse PNG header to extract dimensions and compute frame size."""
+        if not self._sprite_buffer:
+            return
+        # Width: bytes 16-19 (big-endian)
+        self._sprite_width = int.from_bytes(self._sprite_buffer[16:20], "big")
+        # Height: bytes 20-23 (big-endian)
+        self._sprite_height = int.from_bytes(self._sprite_buffer[20:24], "big")
+        # Auto-calculate rows from sprite ratio (single column)
+        rows = max(1, round(self._sprite_height / self._sprite_width))
+        self._frame_width = self._sprite_width
+        self._frame_height = self._sprite_height // rows
+
+    def _load_sprite(self) -> None:
+        """Load sprite sheet from disk."""
+        if self._sprite_buffer is not None:
+            return
+        path = Path(self._sprite_path)
+        if path.is_file():
+            try:
+                with open(path, "rb") as f:
+                    self._sprite_buffer = f.read()
+                self._parse_png()
+            except OSError as exc:
+                logger.warning("Failed to load sprite %s: %s", self._sprite_path, exc)
+
+    def getFrameRow(self, expression_name: str, cycle_index: int) -> int:
+        """Get the sprite sheet row index for an expression."""
+        return _ROW_MAP.get(expression_name, _ROW_MAP.get("neutral", 1))
+
+    def getFrameCount(self, expression_name: str) -> int:
+        """Get number of frames for an expression."""
+        return 1  # single frame per expression
+
+    def getExpressionNames(self) -> list[str]:
+        return sorted(_ROW_MAP.keys())
+
+    def getSpriteBuffer(self) -> bytes:
+        self._load_sprite()
+        if self._sprite_buffer is None:
+            raise FileNotFoundError(f"Sprite sheet not found: {self._sprite_path}")
+        return self._sprite_buffer
+
+    @property
+    def spriteWidth(self) -> int:
+        return self._sprite_width
+
+    @property
+    def spriteHeight(self) -> int:
+        return self._sprite_height
+
+    @property
+    def frameWidth(self) -> int:
+        return self._frame_width
+
+    @property
+    def frameHeight(self) -> int:
+        return self._frame_height
+
+
+class SkinRegistry:
+    """Registry of avatar skins."""
+
+    _instance: SkinRegistry | None = None
+
+    def __init__(self) -> None:
+        self._skins: dict[str, SingleFrameSkin] = {}
+        self._register_default()
+
+    @classmethod
+    def getInstance(cls) -> SkinRegistry:
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def _register_default(self) -> None:
+        default_path = str(Path(__file__).parent.parent / "resources" / "single_frame_sprite_sheet.png")
+        self._skins["single-frame"] = SingleFrameSkin(
+            name="single-frame",
+            _sprite_path=default_path,
+        )
+
+    def get(self, name: str) -> SingleFrameSkin | None:
+        return self._skins.get(name)
+
+    def list(self) -> list[str]:
+        return list(self._skins.keys())

ziomek-0.1.1/src/ziomek/avatar/sprites.py

@@ -0,0 +1,48 @@
+"""ziomek avatar sprite sheet parser."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SpriteMetadata:
+    spriteWidth: int
+    spriteHeight: int
+    frameWidth: int
+    frameHeight: int
+    rows: int
+
+
+def parse_png_sprite(data: bytes) -> SpriteMetadata:
+    """Parse a PNG sprite sheet.
+
+    Extracts dimensions from the PNG header (bytes 16-23 for width/height),
+    then calculates frame count from the height/width ratio.
+
+    Same logic as avatar-panel.ts `_loadSprite()`.
+    """
+    if len(data) < 24:
+        raise ValueError("PNG file too small")
+    if data[0] != 0x89 or data[1] != 0x50:  # 'P' in PNG magic
+        raise ValueError("Not a valid PNG file")
+
+    sprite_width = (data[16] << 24) | (data[17] << 16) | (data[18] << 8) | data[19]
+    sprite_height = (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23]
+
+    rows = max(1, round(sprite_height / sprite_width))
+    frame_width = sprite_width // 1  # single column
+    frame_height = sprite_height // rows
+
+    return SpriteMetadata(
+        spriteWidth=sprite_width,
+        spriteHeight=sprite_height,
+        frameWidth=frame_width,
+        frameHeight=frame_height,
+        rows=rows,
+    )
+
+
+def sprite_to_base64(data: bytes) -> str:
+    import base64
+    return f"data:image/png;base64,{base64.b64encode(data).decode('utf-8')}"