hugpy-media 0.2.2__tar.gz

hugpy_media-0.2.2/LICENSE

@@ -0,0 +1,41 @@
+hugpy — Source-Available License
+
+Copyright (c) 2026 putkoff (hugpy.ai). All rights reserved.
+
+Permission is granted, free of charge, to use this software ("hugpy") for
+personal and non-commercial purposes, and for time-limited commercial
+evaluation, subject to the following conditions:
+
+1. Non-commercial use means use by an individual for personal purposes, or
+   use by a non-profit or educational institution for its own internal
+   purposes. Any use by, for, or on behalf of a for-profit business or in
+   connection with revenue-generating activity is commercial use — including
+   internal business use, use in producing goods or services, and use on
+   paid engagements.
+
+2. Commercial use requires a commercial license from the copyright holder.
+   Exception: a business may evaluate the software internally for up to
+   thirty (30) days free of charge; continued use after that requires a
+   commercial license.
+
+3. Redistribution of this software, in source or binary form, modified or
+   unmodified, is not permitted without prior written permission from the
+   copyright holder. Downloading the software from an official distribution
+   channel (PyPI, npm, hugpy.ai) is not redistribution.
+
+4. Modification for personal use or internal evaluation is permitted;
+   distribution of modified versions is not.
+
+5. This notice must be retained in all copies or substantial portions of
+   the software.
+
+6. Any use outside these terms automatically terminates this license.
+
+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
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+For commercial licensing or redistribution permission: https://hugpy.ai

hugpy_media-0.2.2/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: hugpy-media
+Version: 0.2.2
+Summary: Hugpy media: engine task plugins for speech recognition, TTS, embeddings, keywords, summaries, vision, image generation, ComfyUI and document/URL extraction
+Author-email: putkoff <support@hugpy.ai>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://hugpy.ai
+Project-URL: Documentation, https://github.com/hugpy/hugpy/blob/main/py/inference/hugpy_media/README.md
+Project-URL: Repository, https://github.com/hugpy/hugpy
+Project-URL: Source, https://github.com/hugpy/hugpy/tree/main/py/inference/hugpy_media
+Project-URL: Issues, https://github.com/hugpy/hugpy/issues
+Project-URL: Changelog, https://github.com/hugpy/hugpy/releases
+Project-URL: Architecture, https://github.com/hugpy/hugpy/blob/main/PARTITION.md
+Keywords: hugpy,llm,self-hosted,whisper,embeddings,vision,image-generation,tts,media-intelligence
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: hugpy-platform
+Requires-Dist: hugpy-storage
+Requires-Dist: hugpy-engine
+Requires-Dist: abstract_essentials
+Requires-Dist: pydantic>=2
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: PyPDF2
+Requires-Dist: pdfplumber
+Requires-Dist: pillow
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Provides-Extra: audio
+Requires-Dist: openai-whisper; extra == "audio"
+Provides-Extra: imagegen
+Requires-Dist: diffusers>=0.39; extra == "imagegen"
+Requires-Dist: accelerate; extra == "imagegen"
+Requires-Dist: transformers>=5.12; extra == "imagegen"
+Requires-Dist: bitsandbytes>=0.48.0; extra == "imagegen"
+Provides-Extra: embed
+Requires-Dist: sentence-transformers; extra == "embed"
+Provides-Extra: transformers
+Requires-Dist: torch; extra == "transformers"
+Requires-Dist: transformers; extra == "transformers"
+Requires-Dist: accelerate; extra == "transformers"
+Requires-Dist: sentencepiece; extra == "transformers"
+Requires-Dist: timm; extra == "transformers"
+Provides-Extra: vision
+Requires-Dist: opencv-python-headless; extra == "vision"
+Requires-Dist: onnxruntime; extra == "vision"
+Requires-Dist: aiohttp; extra == "vision"
+Provides-Extra: extract
+Requires-Dist: python-docx; extra == "extract"
+Requires-Dist: openpyxl; extra == "extract"
+Requires-Dist: brotli; extra == "extract"
+Requires-Dist: zstandard; extra == "extract"
+Provides-Extra: keywords
+Requires-Dist: keybert; extra == "keywords"
+Provides-Extra: tts
+Requires-Dist: chatterbox-tts; extra == "tts"
+Provides-Extra: comfy
+Requires-Dist: aiohttp; extra == "comfy"
+Provides-Extra: all
+Requires-Dist: hugpy-media[audio,comfy,embed,extract,imagegen,keywords,transformers,vision]; extra == "all"
+Dynamic: license-file
+
+# hugpy-media
+
+`hugpy_media` — extracted from `abstract_hugpy_dev` as part of the Hugpy
+partition. Ownership and allowed dependencies are declared in
+`py/partition.toml`; see `PARTITION.md` at the workspace root.
+
+Allowed Python dependencies inside the ecosystem: hugpy_platform, hugpy_storage, hugpy_engine.
+
+Register the media tasks with the engine via `hugpy_media.plugin.register()` (also the `hugpy_engine.tasks` entry point `media`). Heavy stacks are extras: `keywords`, `audio`, `imagegen`, `embed`, `transformers`, `vision`, `extract`, `tts`, `comfy`, umbrella `all`.

hugpy_media-0.2.2/README.md

@@ -0,0 +1,9 @@
+# hugpy-media
+
+`hugpy_media` — extracted from `abstract_hugpy_dev` as part of the Hugpy
+partition. Ownership and allowed dependencies are declared in
+`py/partition.toml`; see `PARTITION.md` at the workspace root.
+
+Allowed Python dependencies inside the ecosystem: hugpy_platform, hugpy_storage, hugpy_engine.
+
+Register the media tasks with the engine via `hugpy_media.plugin.register()` (also the `hugpy_engine.tasks` entry point `media`). Heavy stacks are extras: `keywords`, `audio`, `imagegen`, `embed`, `transformers`, `vision`, `extract`, `tts`, `comfy`, umbrella `all`.

hugpy_media-0.2.2/pyproject.toml

@@ -0,0 +1,96 @@
+[build-system]
+requires = ["setuptools>=77", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hugpy-media"
+dynamic = ["version"]
+description = "Hugpy media: engine task plugins for speech recognition, TTS, embeddings, keywords, summaries, vision, image generation, ComfyUI and document/URL extraction"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+authors = [{ name = "putkoff", email = "support@hugpy.ai" }]
+keywords = [
+    "hugpy",
+    "llm",
+    "self-hosted",
+    "whisper",
+    "embeddings",
+    "vision",
+    "image-generation",
+    "tts",
+    "media-intelligence",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+# Base = importable and able to build requests / run the model-less extractors
+# on any box. Every model stack is an extra, imported lazily inside its runner.
+dependencies = [
+    "hugpy-platform",
+    "hugpy-storage",
+    "hugpy-engine",
+    "abstract_essentials",   # derive_media_type / read_from_file / safe_dump_to_json
+    "pydantic>=2",
+    "requests",
+    "beautifulsoup4",        # url-extraction, seo/text helpers
+    "PyPDF2",                # pure-python PDF reading (pdfs/, text/)
+    "pdfplumber",            # document-extraction PDF page text
+    "pillow",                # image decoding in vision/imagegen request paths
+]
+
+[project.urls]
+Homepage = "https://hugpy.ai"
+Documentation = "https://github.com/hugpy/hugpy/blob/main/py/inference/hugpy_media/README.md"
+Repository = "https://github.com/hugpy/hugpy"
+Source = "https://github.com/hugpy/hugpy/tree/main/py/inference/hugpy_media"
+Issues = "https://github.com/hugpy/hugpy/issues"
+Changelog = "https://github.com/hugpy/hugpy/releases"
+Architecture = "https://github.com/hugpy/hugpy/blob/main/PARTITION.md"
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-timeout"]
+# Mirrors the monolith's extras, one per media stack.
+audio = ["openai-whisper"]
+imagegen = ["diffusers>=0.39", "accelerate", "transformers>=5.12", "bitsandbytes>=0.48.0"]
+embed = ["sentence-transformers"]
+transformers = ["torch", "transformers", "accelerate", "sentencepiece", "timm"]
+vision = ["opencv-python-headless", "onnxruntime", "aiohttp"]
+extract = ["python-docx", "openpyxl", "brotli", "zstandard"]
+keywords = ["keybert"]
+# tts is opt-in ONLY: chatterbox-tts pins torch/numpy/transformers versions that
+# conflict with the rest of this set (numpy<2 / transformers==5.2 vs >=5.12), so
+# `hugpy[gpu-worker]` (-> hugpy-media[all]) was unresolvable while it was in
+# `all` (found at the 0.2.0 worker cutover, 2026-09-23).
+tts = ["chatterbox-tts"]
+comfy = ["aiohttp"]
+all = ["hugpy-media[keywords,audio,imagegen,embed,transformers,vision,extract,comfy]"]
+
+[project.entry-points."hugpy_engine.tasks"]
+media = "hugpy_media.plugin:register"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+hugpy_media = ["py.typed", "**/*.json", "**/*.sh", "**/*.md", "**/*.txt"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+timeout = 120
+
+# ---------------------------------------------------------------------------
+# Lockstep workspace version (2026-09-22): every in-tree hugpy-* distribution
+# takes ONE version from the workspace git tag (vX.Y.Z at the repo root), so a
+# release is a tag and a build always carries the commit it came from
+# (X.Y.Z.devN+g<sha>[.dirty] between tags). A checkout without git metadata
+# builds as 0.0.0+unknown, which central refuses to advertise to workers.
+[tool.setuptools_scm]
+root = "../../.."
+fallback_version = "0.0.0+unknown"

hugpy_media-0.2.2/setup.cfg

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

hugpy_media-0.2.2/src/hugpy_media/__init__.py

@@ -0,0 +1,32 @@
+"""hugpy-media: task plugins for the Hugpy engine.
+
+Embeddings/similarity, summaries, keywords, speech recognition, TTS, vision
+chat, vision analysis, image generation, ComfyUI and document/URL extraction.
+Heavy frameworks are extras imported only inside the selected runner, so this
+package imports without torch, diffusers, whisper, keybert,
+sentence-transformers, OpenCV or llama.cpp installed.
+
+Wiring: ``hugpy_media.plugin.register()`` (also the ``hugpy_engine.tasks``
+entry point ``media``) puts every media task into ``hugpy_engine.tasks``;
+``hugpy_media.hooks`` is where the fleet worker observes spawned processes.
+"""
+
+from __future__ import annotations
+
+try:  # the installed distribution's version: the workspace tag/commit, never a literal
+    from importlib.metadata import version as _dist_version
+    __version__ = _dist_version("hugpy-media")
+except Exception:  # noqa: BLE001 — source tree without metadata
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["__version__", "hooks", "plugin", "extract", "chunking"]
+
+
+def __getattr__(name: str):
+    # Submodules are exposed by name but imported on demand, keeping
+    # ``import hugpy_media`` free of even the pydantic schema imports.
+    if name in ("hooks", "plugin", "extract", "chunking"):
+        import importlib
+
+        return importlib.import_module(f"hugpy_media.{name}")
+    raise AttributeError(f"module 'hugpy_media' has no attribute {name!r}")

hugpy_media-0.2.2/src/hugpy_media/chunking.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import re
+from typing import List, Optional
+
+from hugpy_platform.module_imports import get_tiktoken
+def get_encoder(model_name: str = "gpt-4", encoding_name: Optional[str] = None):
+    """Return a tiktoken encoder for your model/encoding, or None when tiktoken
+    isn't installed. The package lazy-imports tiktoken, so on lean installs
+    get_tiktoken() yields a stub whose calls return None — handle that here
+    rather than crashing downstream (callers fall back to a heuristic)."""
+    tiktoken = get_tiktoken()
+    try:
+        enc = (tiktoken.get_encoding(encoding_name) if encoding_name
+               else tiktoken.encoding_for_model(model_name))
+    except Exception:
+        return None
+    return enc if hasattr(enc, "encode") else None
+
+def count_tokens(text: str, encoder=None) -> int:
+    """Count how many tokens `text` encodes to. Falls back to a ~4-chars/token
+    heuristic when no usable encoder is available, so chunking (and the
+    summarizer that drives it) still works on installs without tiktoken."""
+    s = str(text)
+    enc = getattr(encoder, "encode", None)
+    if callable(enc):
+        try:
+            return len(enc(s))
+        except Exception:
+            pass
+    return max(len(s) // 4, len(s.split()), 1)
+
+def recursive_chunk(
+    text: str,
+    desired_tokens: int,
+    model_name: str = "gpt-4",
+    separators: Optional[List[str]] = None,
+    overlap: int = 0
+) -> List[str]:
+    """
+    Split `text` into chunks as close to `desired_tokens` tokens as possible,
+    preserving contiguous blocks via `separators`, and *only* splitting inside
+    a block if it can’t possibly fit otherwise.
+    
+    Args:
+        text: the full string to split
+        desired_tokens: target token count per chunk (never exceed)
+        encoder: a tiktoken encoder
+        separators: list of splitters, from largest to smallest logical unit
+        overlap: how many tokens to overlap between adjacent chunks
+    """
+    encoder = get_encoder(model_name)
+    if separators is None:
+        # from big (paragraphs) to small (words)
+        separators = ["\n\n", "\n", r"(?<=[\.\?\!])\s", ", ", " "]
+
+    # If it already fits, return it whole:
+    if count_tokens(text, encoder) <= desired_tokens:
+        return [text]
+
+    # Try splitting by each separator in turn
+    for sep in separators:
+        # use regex split when the separator is a lookbehind pattern
+        parts = re.split(sep, text) if sep.startswith("(?") else text.split(sep)
+        if len(parts) > 1:
+            chunks: List[str] = []
+            current = ""
+            current_tokens = 0
+
+            for part in parts:
+                part = part.strip()
+                if not part:
+                    continue
+                part_tokens = count_tokens(part, encoder)
+
+                # If this block alone is too big, recurse into it with the next-level separators
+                if part_tokens > desired_tokens:
+                    # flush current
+                    if current:
+                        chunks.extend(recursive_chunk(
+                            current, desired_tokens, model_name, separators[1:], overlap
+                        ))
+                        current, current_tokens = "", 0
+                    # now chunk the oversized block
+                    chunks.extend(recursive_chunk(
+                        part, desired_tokens, model_name, separators[1:], overlap
+                    ))
+                else:
+                    # can we add it to the current chunk?
+                    if current_tokens + part_tokens <= desired_tokens:
+                        # include the separator back in
+                        current = sep.join([current, part]) if current else part
+                        current_tokens += part_tokens
+                    else:
+                        # flush current, start new
+                        chunks.append(current)
+                        current, current_tokens = part, part_tokens
+
+            if current:
+                chunks.append(current)
+            return chunks
+
+    # Fallback: pure token sliding window (the only time we’ll split “inside” a block)
+    tokens = encoder.encode(text)
+    stride = desired_tokens - overlap
+    return [
+        encoder.decode(tokens[i : i + desired_tokens])
+        for i in range(0, len(tokens), stride)
+    ]
+
+

hugpy_media-0.2.2/src/hugpy_media/comfy/__init__.py

@@ -0,0 +1 @@
+from hugpy_media.comfy.comfy_runner import ComfyRunner