comfyui-workflow-templates-core 0.3.46__tar.gz

comfyui_workflow_templates_core-0.3.46/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: comfyui-workflow-templates-core
+Version: 0.3.46
+Summary: Core helpers for ComfyUI workflow templates
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/plain
+
+Core helpers for ComfyUI workflow templates.

comfyui_workflow_templates_core-0.3.46/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "comfyui-workflow-templates-core"
+version = "0.3.46"
+description = "Core helpers for ComfyUI workflow templates"
+readme = {text = "Core helpers for ComfyUI workflow templates.", content-type = "text/plain"}
+requires-python = ">=3.9"
+license = "MIT"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+comfyui_workflow_templates_core = ["manifest.json"]

comfyui_workflow_templates_core-0.3.46/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

comfyui_workflow_templates_core-0.3.46/src/comfyui_workflow_templates_core/__init__.py

@@ -0,0 +1,25 @@
+"""
+Core runtime helpers for ComfyUI workflow templates.
+
+This package is responsible for loading the manifest, resolving asset
+paths across media bundles, and exposing metadata that higher-level
+packages (e.g., the meta wrapper or ComfyUI itself) can consume.
+"""
+
+from .loader import (
+    get_asset_path,
+    get_template_entry,
+    iter_assets,
+    iter_templates,
+    load_manifest,
+    resolve_all_assets,
+)
+
+__all__ = [
+    "get_asset_path",
+    "get_template_entry",
+    "iter_assets",
+    "iter_templates",
+    "load_manifest",
+    "resolve_all_assets",
+]

comfyui_workflow_templates_core-0.3.46/src/comfyui_workflow_templates_core/loader.py

@@ -0,0 +1,129 @@
+"""
+Manifest loader and asset resolution helpers.
+
+The manifest is generated during the build step and embedded as package
+data in `comfyui_workflow_templates_core`. Each media bundle exposes its
+assets under a namespace package (e.g., `comfyui_workflow_templates_media_api`).
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from functools import lru_cache
+from importlib import resources
+from typing import Dict, Iterable, Iterator, List, Tuple
+
+MANIFEST_RESOURCE = "manifest.json"
+
+BUNDLE_PACKAGE_MAP = {
+    "media-api": "comfyui_workflow_templates_media_api",
+    "media-video": "comfyui_workflow_templates_media_video",
+    "media-image": "comfyui_workflow_templates_media_image",
+    "media-other": "comfyui_workflow_templates_media_other",
+}
+
+
+@dataclass(frozen=True)
+class TemplateAsset:
+    filename: str
+    sha256: str
+
+
+@dataclass(frozen=True)
+class TemplateEntry:
+    template_id: str
+    bundle: str
+    version: str
+    assets: List[TemplateAsset]
+
+
+@dataclass(frozen=True)
+class Manifest:
+    manifest_version: int
+    bundles: Dict[str, Dict[str, str]]
+    templates: Dict[str, TemplateEntry]
+
+
+def _parse_manifest(payload: str) -> Manifest:
+    raw = json.loads(payload)
+    templates: Dict[str, TemplateEntry] = {}
+    for entry in raw.get("templates", []):
+        assets = [
+            TemplateAsset(a["filename"], a["sha256"])
+            for a in entry.get("assets", [])
+        ]
+        templates[entry["id"]] = TemplateEntry(
+            template_id=entry["id"],
+            bundle=entry["bundle"],
+            version=entry.get("version", ""),
+            assets=assets,
+        )
+    return Manifest(
+        manifest_version=raw.get("manifest_version", 1),
+        bundles=raw.get("bundles", {}),
+        templates=templates,
+    )
+
+
+@lru_cache(maxsize=1)
+def load_manifest() -> Manifest:
+    """Load and cache the manifest from package data."""
+    data = resources.files(__package__).joinpath(MANIFEST_RESOURCE).read_text()
+    return _parse_manifest(data)
+
+
+def iter_templates() -> Iterable[TemplateEntry]:
+    """Iterate over all template entries."""
+    return load_manifest().templates.values()
+
+
+def get_template_entry(template_id: str) -> TemplateEntry:
+    """Return manifest entry for the given template id."""
+    try:
+        return load_manifest().templates[template_id]
+    except KeyError as exc:
+        raise KeyError(f"Template '{template_id}' not found in manifest") from exc
+
+
+def _bundle_package(bundle_name: str) -> str:
+    try:
+        return BUNDLE_PACKAGE_MAP[bundle_name]
+    except KeyError as exc:
+        raise KeyError(f"No package mapping defined for bundle '{bundle_name}'") from exc
+
+
+def get_asset_path(template_id: str, filename: str) -> str:
+    """
+    Resolve the absolute path for an asset belonging to `template_id`.
+
+    Raises:
+        FileNotFoundError: if the bundle package or asset is missing.
+    """
+    entry = get_template_entry(template_id)
+    package_name = _bundle_package(entry.bundle)
+    try:
+        package_files = resources.files(package_name)
+    except ModuleNotFoundError as exc:
+        raise FileNotFoundError(
+            f"Media package '{package_name}' is not installed for bundle '{entry.bundle}'"
+        ) from exc
+    asset = package_files / "templates" / filename
+    if not asset.exists():
+        raise FileNotFoundError(
+            f"Asset '{filename}' for template '{template_id}' not found in package '{package_name}'"
+        )
+    return str(asset)
+
+
+def resolve_all_assets(template_id: str) -> List[str]:
+    """Return absolute paths for every asset declared for the template."""
+    entry = get_template_entry(template_id)
+    return [get_asset_path(template_id, asset.filename) for asset in entry.assets]
+
+
+def iter_assets() -> Iterator[Tuple[str, str]]:
+    """Yield tuples of (relative_filename, absolute_path) for every asset."""
+    for entry in iter_templates():
+        for asset in entry.assets:
+            yield asset.filename, get_asset_path(entry.template_id, asset.filename)