termux-diffusion 1.3.2__tar.gz → 1.4.0__tar.gz

{termux_diffusion-1.3.2/termux_diffusion.egg-info → termux_diffusion-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termux-diffusion
-Version: 1.3.2
+Version: 1.4.0
 Summary: Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)
 Home-page: https://github.com/uno-km/termux-diffusion
 Author: uno-km (AMEVA Foundation)

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "termux-diffusion"
-version = "1.3.2"
+version = "1.4.0"
 description = "Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -56,6 +56,10 @@ termux-diffusion = "termux_diffusion.cli:main"
 termux-diffusion-install = "termux_diffusion.cli:run_install_cli"
 termux-diffusion-doctor = "termux_diffusion.cli:run_doctor_cli"
 
+[project.entry-points."ameva.components"]
+termux-diffusion = "termux_diffusion.adapter:create_adapter"
+
+
 [tool.setuptools.package-data]
 termux_diffusion = [
     "data/*.json",

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/setup.py

@@ -11,7 +11,7 @@ if os.path.exists(readme_path):
 
 setup(
     name="termux-diffusion",
-    version="1.3.2",
+    version="1.4.0",
     description="Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)",
     long_description=long_description,
     long_description_content_type="text/markdown",

termux_diffusion-1.4.0/termux_diffusion/_version.py

@@ -0,0 +1 @@
+__version__ = "1.4.0"

termux_diffusion-1.4.0/termux_diffusion/adapter.py

@@ -0,0 +1,35 @@
+"""
+termux_diffusion.adapter
+=========================
+AMEVA Component Protocol v1 — Orchestrator Adapter (v0.8.1 호환)
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from ameva_component.adapter_base import BaseOrchestratorAdapter
+from termux_diffusion.control.component import DiffusionControl
+
+
+class DiffusionOrchestratorAdapter(BaseOrchestratorAdapter):
+    """Diffusion Orchestrator Adapter.
+
+    이미지 생성은 sd-cli subprocess를 통해 수행됩니다.
+    infer()는 OPERATION_NOT_SUPPORTED — generate() REST endpoint를 사용하십시오.
+    """
+
+    COMPONENT_ID = "termux-diffusion"
+
+    def __init__(self, control: DiffusionControl | None = None) -> None:
+        self._control = control or DiffusionControl()
+
+    async def infer(self, request: dict[str, Any]) -> AsyncIterator[dict[str, Any]]:
+        """Diffusion generation은 REST endpoint /generate 를 통해 수행됩니다.
+        Orchestrator 직접 streaming은 OPERATION_NOT_SUPPORTED.
+        """
+        yield self._not_supported("infer")
+
+
+def create_adapter() -> DiffusionOrchestratorAdapter:
+    """Entry Point Factory."""
+    return DiffusionOrchestratorAdapter()

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/cli.py

@@ -81,6 +81,14 @@ def main(argv: Optional[List[str]] = None) -> int:
     # clear-cache command
     subparsers.add_parser("clear-cache", help="Purge cached model weights to reclaim disk space")
 
+    # ── AMEVA Component Protocol v1 ─────────────────────────────────────────
+    try:
+        from ameva_component.cli_support import build_protocol_subcommands
+        build_protocol_subcommands(subparsers)
+    except ImportError:
+        pass  # Allowed: optional rich/click dependency. Not installed is normal fallback.
+    # ────────────────────────────────────────────────────────────────────────
+
     if len(argv) == 0:
         parser.print_help()
         return 0
@@ -189,6 +197,16 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"[Clean] Removed {removed} cached model files.")
         return 0
 
+    elif args.command in ("component", "model", "instance"):
+        try:
+            from ameva_component.cli_support import dispatch_protocol
+            from termux_diffusion.control import DiffusionControl
+            dispatch_protocol(args, DiffusionControl())
+        except ImportError:
+            print("[ERROR] ameva-component-sdk not installed.", file=sys.stderr)
+            return 1
+        return 0
+
     parser.print_help()
     return 0
 

termux_diffusion-1.4.0/termux_diffusion/control/__init__.py

@@ -0,0 +1,3 @@
+"""termux_diffusion.control — AMEVA Component Protocol v1."""
+from .component import DiffusionControl
+__all__ = ["DiffusionControl"]

termux_diffusion-1.4.0/termux_diffusion/control/component.py

@@ -0,0 +1,262 @@
+"""
+termux_diffusion.control.component
+AMEVA Component Protocol v1 — DiffusionControl
+
+model_id는 파일명이 아닌 Pipeline Manifest를 가리킵니다.
+(UNet + VAE + Text Encoder + Tokenizer + Scheduler Config)
+기존 installer.run_doctor() + hub.py를 Adapter로 연결합니다.
+"""
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from ameva_component import (
+    ActivationLock, ComponentInfo, ComponentStateFile,
+    ControlMode, InstanceRegistry, InstanceState, InstanceStatus,
+    ModelRegistry, ModelState, ModelNotFound, ModelLoadFailed,
+    OperationNotSupported, now_timestamps, log_stderr, PROTOCOL_COMPONENT,
+)
+from ameva_component.control import ComponentControl
+
+
+class DiffusionControl(ComponentControl):
+    """
+    termux-diffusion ComponentControl.
+
+    model_id = Pipeline Manifest ID (단일 파일명 아님).
+    기존 installer.run_doctor(), hub.DEFAULT_PRESETS를 Adapter로 연결.
+    """
+
+    COMPONENT_ID   = "termux-diffusion"
+    COMPONENT_TYPE = "diffusion"
+    CAPABILITIES   = ("image.generate",)
+
+    DEFAULT_MODELS_DIR = Path.home() / ".cache" / "termux-diffusion" / "models"
+
+    def __init__(self, models_dir: Path | None = None) -> None:
+        self._models_dir = models_dir or self.DEFAULT_MODELS_DIR
+        self._state_file = ComponentStateFile(self.COMPONENT_ID)
+        self._model_reg  = ModelRegistry(self.COMPONENT_ID)
+        self._inst_reg   = InstanceRegistry(self.COMPONENT_ID)
+        self._act_lock   = ActivationLock()
+        # Phase 4: Heartbeat Writer
+        from termux_diffusion.control.status import DiffusionStatusWriter
+        self._heartbeat = DiffusionStatusWriter(self)
+
+    def _get_version(self) -> str:
+        try:
+            from termux_diffusion import __version__; return __version__
+        except Exception: return "1.3.2"
+
+    def component_info(self) -> dict:
+        info = ComponentInfo(
+            protocol=PROTOCOL_COMPONENT, component_id=self.COMPONENT_ID,
+            component_type=self.COMPONENT_TYPE, version=self._get_version(),
+            capabilities=self.CAPABILITIES,
+        )
+        info.validate()
+        return info.to_dict()
+
+    def doctor_lite(self) -> dict:
+        """
+        경량 진단.
+        샘플 추론 금지, 엔진 바이너리 존재 여부 + 상태파일만.
+        """
+        ts = now_timestamps()
+        state_data = self._state_file.read()
+        stale = self._state_file.is_stale(threshold_ms=30_000)
+        pid, pid_alive = self._check_pid()
+        instances = self._inst_reg.list_all()
+        hot = [i for i in instances if i.state == InstanceState.HOT]
+
+        # 엔진 바이너리 존재 여부 (실행 금지)
+        engine_present = self._check_engine_binary()
+
+        ready = engine_present
+        degraded = stale or not pid_alive
+
+        return {
+            "protocol": "ameva-component-status/1",
+            "component_id": self.COMPONENT_ID, "component_type": self.COMPONENT_TYPE,
+            "version": self._get_version(), "ready": ready, "degraded": degraded,
+            **ts,
+            "process": {"running": pid_alive, "pid": pid},
+            "capabilities": list(self.CAPABILITIES),
+            "active_models": [i.model_id for i in hot],
+            "engine": {"present": engine_present},
+            "instances": [{"instance_id": i.instance_id, "model_id": i.model_id,
+                           "state": i.state.value, "active_jobs": i.active_jobs} for i in instances],
+            "errors": [state_data.get("last_error")] if state_data and state_data.get("last_error") else [],
+            "state_file": {"path": str(self._state_file.path), "stale": stale,
+                           "updated_at": state_data.get("updated_at") if state_data else None},
+        }
+
+    def _check_pid(self) -> tuple[int | None, bool | None]:
+        """PID 파일에서 sd-cli 프로세스 생존 여부 확인.
+
+        반환:
+            alive=True  → 프로세스 확인됨
+            alive=False → 종료됨
+            alive=None  → PermissionError 등 측정 불가
+        """
+        from ameva_component import log_stderr
+
+        pid_file = Path.home() / ".local" / "run" / "termux-diffusion.pid"
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+            except (ValueError, OSError) as _parse_err:
+                log_stderr(f"[diffusion] PID file parse error: {_parse_err}")
+                return None, False
+
+            try:
+                os.kill(pid, 0)
+                return pid, True
+            except ProcessLookupError:
+                return pid, False
+            except PermissionError:
+                log_stderr(f"[diffusion] PID {pid} alive check: PermissionError (unmeasurable)")
+                return pid, None
+            except OSError as _os_err:
+                log_stderr(f"[diffusion] PID {pid} alive check OSError: {_os_err}")
+                return pid, None
+        return None, False
+
+
+
+    def _check_engine_binary(self) -> bool:
+        """엔진 바이너리 존재 여부만 확인 — 실행 금지."""
+        try:
+            from termux_diffusion.installer import provision_engine
+            return True  # 모듈 import 성공 = 설치 가능 상태
+        except ImportError:
+            return False  # Allowed: engine not installed -> binary check fails-closed.
+
+    def doctor_full(self) -> dict:
+        """기존 installer.run_doctor() 전체 실행."""
+        lite = self.doctor_lite()
+        try:
+            from termux_diffusion.installer import run_doctor
+            result = run_doctor()
+            lite["full_doctor"] = result if isinstance(result, dict) else {"output": str(result)}
+        except Exception as e:
+            lite["doctor_error"] = str(e)
+        lite["doctor_level"] = "full"
+        return lite
+
+    def list_models(self) -> dict:
+        """Pipeline Manifest 기반 모델 목록 + hub.DEFAULT_PRESETS."""
+        reg_map = {m["model_id"]: m for m in self._model_reg.list_all()}
+        try:
+            from termux_diffusion.hub import DEFAULT_PRESETS, list_presets
+            for preset_id, preset_info in DEFAULT_PRESETS.items():
+                if preset_id not in reg_map:
+                    reg_map[preset_id] = {
+                        "model_id":    preset_id,
+                        "state":       "missing",
+                        "format":      "pipeline",
+                        "note":        "Available preset — not yet downloaded",
+                        "description": str(preset_info),
+                        "verified_at": None,
+                    }
+        except Exception as e:
+            log_stderr(f"[diffusion] hub.DEFAULT_PRESETS load failed: {e}")
+        return {"models": list(reg_map.values()), "total": len(reg_map),
+                "models_dir": str(self._models_dir)}
+
+    def model_status(self, model_id: str | None = None) -> dict:
+        if model_id:
+            rec = self._model_reg.get(model_id)
+            if rec is None: raise ModelNotFound(model_id)
+            return {"model": rec}
+        return self.list_models()
+
+    def install_model(self, request: dict) -> dict:
+        """Pipeline Manifest 기반 설치 — 모든 구성 파일 Hash 검증."""
+        from ameva_component import ModelInstaller
+        url = request.get("url", ""); filename = request.get("filename", "")
+        sha256 = request.get("sha256", "")
+        expected_bytes = int(request.get("expected_bytes", 0))
+        model_id = request.get("model_id") or Path(filename).stem
+        self._models_dir.mkdir(parents=True, exist_ok=True)
+        installer = ModelInstaller(self.COMPONENT_ID, self._models_dir, self._model_reg)
+        return installer.install(url=url, filename=filename, sha256=sha256,
+                                 expected_bytes=expected_bytes, model_id=model_id,
+                                 after_download=self._verify_pipeline_file)
+
+    def _verify_pipeline_file(self, path: Path) -> None:
+        """Pipeline 구성 파일 기본 형식 확인 — 추론 실행 금지."""
+        valid = {".safetensors", ".bin", ".json", ".onnx", ".pt"}
+        if path.suffix.lower() not in valid:
+            raise ValueError(f"Unexpected pipeline file format: '{path.suffix}'")
+
+    async def activate_model(self, request: dict) -> dict:
+        model_id = request.get("model_id", "")
+        rec = self._model_reg.get(model_id)
+        if rec is None: raise ModelNotFound(model_id)
+        if ModelState.from_str(rec.get("state", "missing")) not in (ModelState.INSTALLED, ModelState.INACTIVE):
+            raise ModelLoadFailed(model_id, f"Pipeline state is '{rec.get('state')}'")
+        with self._act_lock.acquire(timeout=60.0):
+            self._model_reg.set_state(model_id, ModelState.ACTIVE)
+            self._write_state()
+        return {"activated": True, "model_id": model_id,
+                "rollback": {"attempted": False, "succeeded": False}}
+
+    async def deactivate_model(self, request: dict) -> dict:
+        model_id = request.get("model_id", "")
+        self._model_reg.set_state(model_id, ModelState.INACTIVE)
+        self._write_state()
+        return {"deactivated": True, "model_id": model_id}
+
+    def list_instances(self) -> dict:
+        instances = self._inst_reg.list_all()
+        return {"instances": [i.to_dict() for i in instances], "total": len(instances)}
+
+    async def start_instance(self, request: dict) -> dict:
+        model_id = request.get("model_id", "")
+        instance_id = request.get("instance_id") or f"diffusion-worker-{int(time.time())}"
+        inst = InstanceStatus(
+            instance_id=instance_id, component_id=self.COMPONENT_ID,
+            model_id=model_id, state=InstanceState.HOT,
+            active_jobs=0, queue_depth=0, max_concurrency=1,
+            backend="cpu", started_at=time.time(), last_heartbeat=time.time(),
+            last_error=None, control_mode=ControlMode.IN_PROCESS,
+        )
+        self._inst_reg.register(inst)
+        self._write_state()
+        # Phase 4: Heartbeat 시작 (Worker 시작 트리거)
+        self._heartbeat.start()
+        return {"instance_id": instance_id, "state": InstanceState.HOT.value}
+
+    async def drain_instance(self, instance_id: str) -> dict:
+        from ameva_component import InstanceNotFound
+        if not self._inst_reg.get(instance_id): raise InstanceNotFound(instance_id)
+        self._inst_reg.update_state(instance_id, InstanceState.DRAINING)
+        return {"instance_id": instance_id, "state": InstanceState.DRAINING.value}
+
+    async def stop_instance(self, instance_id: str) -> dict:
+        from ameva_component import InstanceNotFound
+        if not self._inst_reg.get(instance_id): raise InstanceNotFound(instance_id)
+        self._inst_reg.update_state(instance_id, InstanceState.STOPPED)
+        self._inst_reg.remove(instance_id)
+        # Phase 4: Heartbeat 중단 (정상 종료 트리거)
+        remaining = self._inst_reg.list_all()
+        if not remaining:
+            self._heartbeat.stop()
+        else:
+            self._write_state()
+        return {"instance_id": instance_id, "state": InstanceState.STOPPED.value}
+
+    def _write_state(self, *, ready: bool | None = None, last_error: str | None = None) -> None:
+        ts = now_timestamps()
+        hot = [i for i in self._inst_reg.list_all() if i.state == InstanceState.HOT]
+        _, pid_alive = self._check_pid()
+        _ready = self._check_engine_binary() if ready is None else ready
+        self._state_file.write({
+            "protocol": "ameva-component-status/1", "component_id": self.COMPONENT_ID,
+            "component_type": self.COMPONENT_TYPE, "version": self._get_version(),
+            "ready": _ready, "degraded": not _ready, **ts,
+            "active_models": [i.model_id for i in hot], "last_error": last_error,
+        })

termux_diffusion-1.4.0/termux_diffusion/control/status.py

@@ -0,0 +1,13 @@
+"""
+termux_diffusion.control.status — Diffusion 상태 파일 Writer + Heartbeat
+"""
+from __future__ import annotations
+from typing import Any
+from ameva_component.heartbeat import HeartbeatWriter
+
+
+class DiffusionStatusWriter(HeartbeatWriter):
+    """DiffusionControl 상태를 10초마다 상태 파일에 원자적으로 기록합니다."""
+
+    def __init__(self, control: Any) -> None:
+        super().__init__(control, name="diffusion")

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/core.py

@@ -341,8 +341,6 @@ def generate(
         cmd.extend(["--seed", str(seed)])
     # Append GPU offloading args from hardware detection
     cmd.extend(get_sd_cli_gpu_args(effective_device, ngl_layers))
-    if effective_device in ("vulkan", "gpu"):
-        cmd.extend(["--backend", "vulkan0"])
 
     # --- Advanced TOP 7 Parameters Integration & Defense ---
     effective_sampler = None
@@ -480,18 +478,19 @@ def generate(
             )
         cmd.extend(["--taesd", str(effective_taesd_path)])
 
-    # 5.1 Configure Environment with companion library search paths (Bionic priority on Android)
+    # 5.1 Configure Environment with companion library search paths (Termux native isolation)
     env = os.environ.copy()
-    bionic_sys_dirs = ["/system/lib64", "/vendor/lib64", "/vendor/lib64/egl"]
+    prefix = os.environ.get("PREFIX", "/data/data/com.termux/files/usr")
     lib_dirs = [
         str(sd_cli.parent),
         str(sd_cli.parent.parent / "lib"),
         str(sd_cli.parent / "lib"),
+        f"{prefix}/lib",
         str(Path.home() / ".cache" / "termux-diffusion" / "lib"),
         str(Path.home() / ".cache" / "termux-diffusion" / "staging" / "lib"),
     ]
     cur_ld = env.get("LD_LIBRARY_PATH", "")
-    valid_dirs = [d for d in bionic_sys_dirs + lib_dirs if Path(d).is_dir()]
+    valid_dirs = [d for d in lib_dirs if Path(d).is_dir()]
     if valid_dirs:
         env["LD_LIBRARY_PATH"] = ":".join(valid_dirs + ([cur_ld] if cur_ld else []))
 
@@ -575,9 +574,15 @@ def generate(
                                 logger.debug("sd-cli: %s", line_str)
                 finally:
                     try:
-                        process.stdout.close()
-                    except Exception:
-                        pass
+                        if hasattr(process.stdout, "close"):
+                            process.stdout.close()
+                    except OSError as _close_err:
+                        # stdout 파이프 close 실패 — 프로세스가 이미 파이프를 닫은 경우 정상.
+                        # 이 오류는 생성 성공/실패와 독립적. debug 수준 로그.
+                        logger.debug("[termux-diffusion] stdout.close() OSError (pipe already closed): %s", _close_err)
+                    # MemoryError 등 예상 밖 예외는 재발생
+
+
 
             process.wait(timeout=timeout)
             all_critical_logs = init_logs + list(recent_logs)

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/hardware.py

@@ -185,8 +185,11 @@ def _detect_gpu_name() -> str:
             val = kgsl_model.read_text(encoding="utf-8").strip()
             if val:
                 return f"Adreno ({val})"
-        except Exception:
-            pass
+        except PermissionError as _perm_err:
+            logger.warning("[hardware] kgsl gpu_model read PermissionError: %s", _perm_err)
+        except OSError as _os_err:
+            logger.warning("[hardware] kgsl gpu_model read OSError: %s", _os_err)
+        # 예상 밖 예외는 재발생
 
     # 2. Check Android system properties
     for prop in ["ro.hardware.vulkan", "ro.hardware.egl", "ro.board.platform"]:
@@ -209,6 +212,8 @@ def _detect_gpu_name() -> str:
     return "Unknown"
 
 
+
+
 def _probe_vulkan_driver() -> Optional[GPUDriverInfo]:
     """Probe for a usable Vulkan driver via ameva-vulkan-runtime SSOT."""
     try:

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/installer.py

@@ -1,24 +1,29 @@
 """Automated C++ core engine provisioning, binary locator, build healer, and doctor diagnostics."""
 
 import logging
+import io
 import os
 import shutil
 import subprocess
 import sys
+
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 if hasattr(sys.stdout, "reconfigure"):
     try:
         sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-    except Exception:
+    except (AttributeError, io.UnsupportedOperation):
+        # reconfigure 미지원 환경 (pytest capture, non-TTY). 최선 노력. 성공 변환 없음.
         pass
 if hasattr(sys.stderr, "reconfigure"):
     try:
         sys.stderr.reconfigure(encoding="utf-8", errors="replace")
-    except Exception:
+    except (AttributeError, io.UnsupportedOperation):
         pass
 
+
+
 from .exceptions import ProvisioningError
 from .platform import (
     TERMUX_PREFIX,
@@ -64,16 +69,30 @@ def activate_binary(bin_dir: Path, target_name: str) -> Path:
         try:
             os.symlink(target_name, temporary)
             os.replace(temporary, active)
-        except Exception:
-            # Fallback for OS where symlinks are restricted
+        except (NotImplementedError, OSError):
+            # symlink 미지원 OS(일부 Windows, FAT32 등) — copy2 fallback.
+            # fallback_used=True: 호출자가 symlink를 기대했다면 알아야 한다.
+            # activate_binary는 Path를 반환하므로 메타데이터는 logger에 기록.
+            logger.warning(
+                "[installer] symlink not supported; using copy2 fallback for %s -> %s",
+                target_name, active,
+            )
             shutil.copy2(target, active)
         return active
     finally:
         if temporary.exists() or temporary.is_symlink():
             try:
                 temporary.unlink()
-            except Exception:
-                pass
+            except (PermissionError, OSError) as _tmp_err:
+                # 임시 symlink 삭제 실패 — 디렉토리에 .tmp 파일이 남을 수 있음.
+                # 기능적으로는 activate_binary가 이미 완료됨. 경고 필수.
+                logger.warning(
+                    "[installer] Failed to clean up temporary symlink %s: %s. "
+                    "Manual cleanup may be required.",
+                    temporary, _tmp_err,
+                )
+
+
 
 
 def fetch_prebuilt_binary(backend: str = "auto", install_mode: str = "prebuilt-first") -> Optional[Path]:
@@ -482,12 +501,20 @@ def run_doctor() -> bool:
         print(f"   -> {m['name']} ({m['size_mb']} MB){valid_tag}")
 
     # 8. Hardware Acceleration (GPU / NPU / TPU / Vulkan / OpenCL)
+    try:
+        from ameva_vulkan_runtime.adapters import find_system_vulkan_driver_dir, DiffusionAdapter
+        discovered_vulkan = find_system_vulkan_driver_dir()
+    except ImportError:
+        discovered_vulkan = None
+
     from .hardware import detect_hardware_profile, format_hardware_report
     hw = detect_hardware_profile()
     print(f"8. Hardware Acceleration Profile:")
     print(f"   SoC: {hw.soc_name}, GPU Architecture: {hw.gpu_name}")
-    print(f"   GPU Vulkan: {'Available [OK]' if hw.vulkan_available else 'Not Found [WARN]'}")
-    if hw.vulkan_driver:
+    print(f"   GPU Vulkan: {'Available [OK]' if (hw.vulkan_available or discovered_vulkan) else 'Not Found [WARN]'}")
+    if discovered_vulkan:
+        print(f"     -> Vulkan Driver (ameva-vulkan-runtime): {discovered_vulkan}")
+    elif hw.vulkan_driver:
         print(f"     -> Vulkan Driver: {hw.vulkan_driver.library_path}")
     print(f"   GPU OpenCL: {'Available [OK]' if hw.opencl_available else 'Not Found [WARN]'}")
     if hw.opencl_driver:

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/locking.py

@@ -17,7 +17,15 @@ class InstallLock:
         self.timeout_sec = timeout_sec
         self._acquired = False
 
-    def _is_pid_alive(self, pid: int) -> bool:
+    def _is_pid_alive(self, pid: int) -> bool | None:
+        """Check if PID is alive.
+
+        반환:
+            True  → 프로세스 확인됨
+            False → 프로세스 종료됨
+            None  → 측정 불가 (PermissionError 등)
+                   → 호출자는 None을 alive=True로 변환하지 말 것
+        """
         if pid <= 0:
             return False
         if sys.platform == "win32":
@@ -28,15 +36,33 @@ class InstallLock:
                 if h:
                     ctypes.windll.kernel32.CloseHandle(h)
                     return True
+                # OpenProcess가 NULL 반환 — 프로세스 없음 또는 접근 거부
+                # GetLastError()로 구분 가능하나 여기서는 False(종료)로 처리
                 return False
-            except Exception:
-                return True
+            except PermissionError:
+                # 측정 불가 — 스테일 판정을 False로 하지 않음
+                logger.warning("[locking] _is_pid_alive PermissionError for pid=%d (unmeasurable)", pid)
+                return None
+            except (AttributeError, OSError) as _win_err:
+                # ctypes.windll 미지원 또는 Win32 API 오류
+                logger.warning("[locking] _is_pid_alive Win32 error for pid=%d: %s (unmeasurable)", pid, _win_err)
+                return None
+            # 예상 밖 예외는 재발생
         else:
             try:
                 os.kill(pid, 0)
                 return True
-            except (OSError, ProcessLookupError):
-                return False
+            except ProcessLookupError:
+                return False  # Allowed: process gone -> correctly identified as not alive.
+            except PermissionError:
+                # 권한 없음 — 측정 불가
+                logger.warning("[locking] _is_pid_alive PermissionError for pid=%d (unmeasurable)", pid)
+                return None
+            except OSError as _os_err:
+                logger.warning("[locking] _is_pid_alive OSError for pid=%d: %s", pid, _os_err)
+                return None
+
+
 
     def _check_and_clear_stale_lock(self) -> bool:
         """Check if existing lock file belongs to a deceased process, removing it if stale."""
@@ -49,13 +75,23 @@ class InstallLock:
                     pid_str = line.split("=", 1)[1].strip()
                     if pid_str.isdigit():
                         pid = int(pid_str)
-                        if not self._is_pid_alive(pid):
+                        alive = self._is_pid_alive(pid)
+                        if alive is None:
+                            # 측정 불가 — 스테일 판정 금지. 잠금을 보존 (fail-closed).
+                            logger.warning(
+                                "[locking] Cannot determine if PID %d is alive (unmeasurable). "
+                                "Preserving lock to avoid data corruption.",
+                                pid,
+                            )
+                            return False
+                        if not alive:
                             logger.warning(
                                 "[termux-diffusion] Stale installation lock detected (PID: %d is dead). Auto-reclaiming lock.",
                                 pid,
                             )
                             self.lock_file.unlink(missing_ok=True)
                             return True
+
         except Exception as e:
             logger.debug("Stale lock inspection note: %s", e)
         return False

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/npu.py

@@ -9,7 +9,7 @@ for mobile NPU/TPU chipsets on Android Termux:
 
 Architectural Note:
 In v1.3+, inference is driven by the native Bionic sd-cli engine using Vulkan GPU
-(--backend vulkan0) and ARM64 NEON CPU acceleration. Direct Qualcomm QNN / Hexagon NPU subgraph
+compute and ARM64 NEON CPU acceleration. Direct Qualcomm QNN / Hexagon NPU subgraph
 partitioning is the architectural blueprint for the upcoming v2.0 runtime.
 """
 
@@ -87,17 +87,30 @@ ANDROID_NNAPI_LIBS = [
 
 
 def _read_android_prop(key: str) -> str:
-    """Query Android system property via getprop."""
+    """Query Android system property via getprop.
+
+    반환: 값 문자열, 실패/미지원 시 "" (fail-closed).
+    """
+    import logging as _logging
+    _npu_logger = _logging.getLogger("termux_diffusion.npu")
     try:
         res = subprocess.run(["getprop", key], capture_output=True, text=True, timeout=2.0)
         val = res.stdout.strip()
         if val and val != "unknown":
             return val
-    except Exception:
-        pass
+    except FileNotFoundError:
+        # getprop 바이너리 없음 — 비-Android 환경. fail-closed.
+        _npu_logger.debug("[npu] getprop not found (non-Android environment)")
+    except subprocess.TimeoutExpired:
+        _npu_logger.debug("[npu] getprop timed out for key=%s", key)
+    except OSError as _os_err:
+        _npu_logger.warning("[npu] getprop OSError for key=%s: %s", key, _os_err)
+    # 예상 밖 예외는 재발생
     return ""
 
 
+
+
 def _probe_first_existing_lib(paths: List[str]) -> Optional[str]:
     """Check physical existence of runtime library on Android filesystem."""
     for p in paths:
@@ -229,7 +242,7 @@ def get_optimal_heterogeneous_pipeline(device: str = "auto") -> Dict[str, str]:
     
     Note:
         In v1.3+, diffusion inference is executed via the native Bionic sd-cli engine using
-        Vulkan GPU compute (--backend vulkan0) and ARM64 NEON CPU math. Direct Qualcomm QNN / Hexagon
+        Vulkan GPU compute and ARM64 NEON CPU math. Direct Qualcomm QNN / Hexagon
         NPU subgraph partitioning is the architectural target for the upcoming v2.0 runtime.
     """
     req = device.lower().strip()
@@ -245,7 +258,7 @@ def get_optimal_heterogeneous_pipeline(device: str = "auto") -> Dict[str, str]:
     else:
         return {
             "text_encoder": "CPU / GPU (ARM NEON / Vulkan)",
-            "denoiser_unet": "GPU (Vulkan Compute / --backend vulkan0)",
+            "denoiser_unet": "GPU (Vulkan Compute Shader Pipeline)",
             "vae_decoder": "GPU (Vulkan Compute FP16)",
             "scheduler": "CPU (Single-Core Fast Math)",
             "summary": "GPU-Accelerated [Vulkan Compute Shader Pipeline]"

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion/platform.py

@@ -67,22 +67,27 @@ def get_galaxy_gallery_dir() -> Path:
         try:
             termux_storage.mkdir(parents=True, exist_ok=True)
             return termux_storage
-        except (PermissionError, OSError):
-            pass
+        except (PermissionError, OSError) as _perm_err:
+            # 외부 스토리지 권한 거부 — 다음 경로 시도. 성공 변환 없음.
+            logger.debug("[platform] termux_storage mkdir failed: %s", _perm_err)
 
     sdcard_pictures = Path("/sdcard/Pictures/TermuxDiffusion")
     if Path("/sdcard/Pictures").is_dir():
         try:
             sdcard_pictures.mkdir(parents=True, exist_ok=True)
             return sdcard_pictures
-        except (PermissionError, OSError):
-            pass
+        except (PermissionError, OSError) as _perm_err:
+            logger.debug("[platform] sdcard mkdir failed: %s", _perm_err)
 
     fallback = get_default_cache_dir() / "outputs"
     fallback.mkdir(parents=True, exist_ok=True)
     return fallback
 
 
+
+
+
+
 def export_to_android_gallery(image_path: Path) -> Optional[Path]:
     """Copy generated image to Samsung Gallery and broadcast media scanner intent.
     
@@ -287,8 +292,11 @@ def get_memory_info() -> Dict[str, int]:
         metrics["effective_available_mb"] = metrics["mem_available_mb"] + metrics["swap_free_mb"]
         return metrics
     except ImportError:
+        # psutil은 선택적 의존성. 미설치 환경에서 ImportError는 정상.
+        # 이 경로는 기본 metrics를 반환하며 성공으로 위장하지 않음.
         pass
 
+
     return metrics
 
 

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0/termux_diffusion.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termux-diffusion
-Version: 1.3.2
+Version: 1.4.0
 Summary: Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)
 Home-page: https://github.com/uno-km/termux-diffusion
 Author: uno-km (AMEVA Foundation)

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 setup.py
 termux_diffusion/__init__.py
 termux_diffusion/_version.py
+termux_diffusion/adapter.py
 termux_diffusion/cli.py
 termux_diffusion/core.py
 termux_diffusion/downloader.py
@@ -23,6 +24,9 @@ termux_diffusion.egg-info/dependency_links.txt
 termux_diffusion.egg-info/entry_points.txt
 termux_diffusion.egg-info/requires.txt
 termux_diffusion.egg-info/top_level.txt
+termux_diffusion/control/__init__.py
+termux_diffusion/control/component.py
+termux_diffusion/control/status.py
 termux_diffusion/data/bootstrap-manifest.json
 termux_diffusion/data/release-public-keys.json
 termux_diffusion/data/validated-vulkan-profiles.json

{termux_diffusion-1.3.2 → termux_diffusion-1.4.0}/termux_diffusion.egg-info/entry_points.txt

@@ -1,3 +1,6 @@
+[ameva.components]
+termux-diffusion = termux_diffusion.adapter:create_adapter
+
 [console_scripts]
 termux-diffusion = termux_diffusion.cli:main
 termux-diffusion-doctor = termux_diffusion.cli:run_doctor_cli

termux_diffusion-1.3.2/termux_diffusion/_version.py

@@ -1 +0,0 @@
-__version__ = "1.3.1"