clams-python 1.7.2__tar.gz → 1.7.4__tar.gz

{clams_python-1.7.2 → clams_python-1.7.4}/CHANGELOG.md

@@ -1,4 +1,25 @@
 
+## releasing 1.7.3 (2026-07-09)
+### Overview
+This patch includes critical bugfixes. See changes below. 
+
+### Changes
+* fixes handling of error during `annotate()` (and `_annotate()`) when running an app via cli.py  (#297)
+* added the `useReasoning` common parameter for promptable apps (#299) Note that release 1.7.2 was supposed to include this parameter (and the release note says so), but it was omitted by mistake.
+
+
+## releasing 1.7.2 (2026-07-07)
+### Overview
+This patch adds experimental handling of "reasoning traces" of propmtable apps
+
+### Additions
+* common parameter `useReasoning` (bool) is added
+* when reasoning is on, in-line tagged reasoning traces (commonly within `<think>...</think>`) are separately stored in `modelReasoningTrace` of the TextDocument 
+
+> [!NOTE]
+> The new names are tentative and can be changed in the near future.
+
+
 ## releasing 1.7.1 (2026-06-19)
 ### Overview
 Updates the `mmif-python` SDK dependency to 1.5.1 to incorporate a bugfix in VDH, with some other minor documentation generation improvements.

{clams_python-1.7.2/clams_python.egg-info → clams_python-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clams-python
-Version: 1.7.2
+Version: 1.7.4
 Summary: A collection of APIs to develop CLAMS app for python
 License-Expression: Apache-2.0
 Project-URL: homepage, https://clams.ai
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mmif-python==1.5.1
+Requires-Dist: mmif-python==1.5.3
 Requires-Dist: Flask>=2
 Requires-Dist: Flask-RESTful>=0.3.9
 Requires-Dist: gunicorn>=20

{clams_python-1.7.2 → clams_python-1.7.4}/clams/app/__init__.py

@@ -49,6 +49,10 @@ falsy_values = [
 ]
 
 
+class EmptyOutputWarning(UserWarning):
+    """Raised when an app's ``_annotate()`` produces no non-empty views."""
+
+
 class ClamsApp(ABC):
     """
     An abstract class to define API's for ClamsApps. A CLAMS app should inherit
@@ -191,6 +195,15 @@ class ClamsApp(ABC):
         t = datetime.now()
         with warnings.catch_warnings(record=True) as ws:
             annotated, cuda_profiler = self._profile_cuda_memory(self._annotate)(mmif, **refined)
+            new_views = [v for v in annotated.views if v.id not in existing_view_ids]
+            is_empty = lambda v: len(v.annotations) == 0 and not v.has_error() and not v.has_warnings()
+            for v in new_views:
+                if is_empty(v):
+                    del annotated.views._items[v.id]  # no public API to remove a view (mmif-python)
+            if all(is_empty(v) for v in new_views):
+                warnings.warn(f'App "{self.metadata.identifier}" produced no annotations for this '
+                              f'input; the input may lack expected content, or there may genuinely '
+                              f'be nothing to annotate.', EmptyOutputWarning)
             if ws:
                 issued_warnings.extend(ws)
         if issued_warnings:
@@ -301,35 +314,81 @@ class ClamsApp(ABC):
         """
         A method to "sign" a new view that this app creates at the beginning of annotation.
         Signing will populate the view metadata with information and configuration of this app.
-        The parameters passed to the :meth:`~clams.app.ClamsApp._annotate` must be
-        passed to this method. This means all parameters for "common" configuration that
-        are consumed in :meth:`~clams.app.ClamsApp.annotate` should not be recorded in the
-        view metadata.
+
+        The ``runtime_conf`` argument can be either "refined" or "raw" parameters,
+        and what ends up recorded in the view metadata differs accordingly:
+
+        * "refined" params: the output of :meth:`~clams.app.ClamsApp._refine_params`,
+          identifiable by the presence of the internal ``_RAW_PARAMS_KEY`` marker.
+          These carry both the user's raw input and the fully resolved configuration
+          (declared parameters with their defaults filled in). Signing then populates
+          **two** metadata fields: ``parameters`` with the raw user input (before
+          defaults), and ``appConfiguration`` with the resolved configuration,
+          including the universal parameters (e.g. ``pretty``, ``runningTime``,
+          ``hwFetch``, ``tfSamplingMode``).
+        * "raw" params: an unrefined ``Dict[str, List[str]]``. Only the
+          ``parameters`` field is populated; there is no resolved configuration
+          to record. See :meth:`~clams.app.ClamsApp.add_parameters_to_metadata`
+          for the input channels these values come from and how each is recorded.
+
+        These two cases exist because of two distinct execution paths. On the normal
+        annotation path, :meth:`~clams.app.ClamsApp.annotate` refines the parameters
+        before invoking :meth:`~clams.app.ClamsApp._annotate`, so a well-behaved app
+        forwards those already-refined params here and gets the full two-field record.
+        On the error path (:meth:`~clams.app.ClamsApp.set_error_view`), refinement may
+        be exactly what failed (:meth:`~clams.app.ClamsApp._refine_params` raises on a
+        missing required parameter or an invalid choice) so the error view is signed
+        with the raw params to guarantee the error is still recorded.
+
         :param view: a view to sign
-        :param runtime_conf: runtime configuration of the app as k-v pairs
+        :param runtime_conf: runtime configuration of the app, either refined
+            (output of :meth:`~clams.app.ClamsApp._refine_params`) or raw k-v pairs
         """
         view.metadata.app = str(self.metadata.identifier)
         if self.metadata.app_tags:
             view.metadata.set_additional_property('appTags', list(self.metadata.app_tags))
-        params_map = {p.name: p for p in self.metadata.parameters}
         if self._RAW_PARAMS_KEY in runtime_conf:
             for k, v in runtime_conf.items():
                 if k == self._RAW_PARAMS_KEY:
-                    for orik, oriv in v.items():
-                        if orik in params_map and params_map[orik].multivalued:
-                            view.metadata.add_parameter(orik, str(oriv))
-                        else:
-                            view.metadata.add_parameter(orik, oriv[0])
+                    self.add_parameters_to_metadata(view, v)
                 else:
                     view.metadata.add_app_configuration(k, v)
         else:
-            # meaning the parameters directly from flask or argparser and values are in lists
-            for k, v in runtime_conf.items():
-                if k in params_map and params_map[k].multivalued:
-                    view.metadata.add_parameter(k, str(v))
-                else:
-                    view.metadata.add_parameter(k, v[0])
-        
+            # unrefined params passed directly (no _RAW_PARAMS_KEY marker), e.g.
+            # the error path; values are lists
+            self.add_parameters_to_metadata(view, runtime_conf)
+
+    def add_parameters_to_metadata(self, view: View, parameters: dict):
+        """
+        Record raw runtime parameters into the view's ``parameters`` metadata.
+
+        The ``parameters`` argument reaches an app through one of three channels:
+
+        #. a query string, when the app runs as an HTTP server (``app.py``, via
+           :class:`~clams.restify.Restifier`);
+        #. shell arguments, when the app runs as a CLI program (``cli.py``);
+        #. a JSON envelope built with the ``clams envelop`` command (see
+           :mod:`clams.envelop`), whose values are flattened by
+           :func:`~clams.envelop.normalize_params`.
+
+        In every case the values arrive as ``List[str]`` (the shape
+        :meth:`~clams.app.ClamsApp._refine_params` consumes). A single value is
+        recorded bare with the ``List`` wrapper stripped, multiple values as the
+        serialized list, and an empty list skipped as unset (only an envelope
+        such as ``{"x": []}`` produces one, guarding against an ``IndexError``
+        on ``v[0]``).
+
+        :param view: the view being signed
+        :param parameters: raw runtime parameters as ``Dict[str, List[str]]``
+        """
+        for k, v in parameters.items():
+            if len(v) == 0:
+                continue
+            elif len(v) == 1:
+                view.metadata.add_parameter(k, v[0])
+            else:
+                view.metadata.add_parameter(k, str(v))
+
     def set_error_view(self, mmif: Union[str, dict, Mmif], **runtime_conf: List[str]) -> Mmif:
         """
         A method to record an error instead of annotation results in the view
@@ -711,6 +770,26 @@ class ClamsPromptableApp(ClamsApp):
                 'values grow the KV cache linearly and increase GPU memory '
                 'usage; reduce if VRAM is constrained.',
         },
+        {
+            'name': 'useReasoning', 'type': 'boolean', 'default': False,
+            'description':
+                'Request the model\'s reasoning ("thinking") mode. Off by '
+                'default. Honored only by apps whose backing model has a '
+                'distinct reasoning mode; apps without one ignore it. When '
+                'honored and enabled, the reasoning trace is split from the '
+                'answer and stored in the ``modelReasoningTrace`` property of '
+                'the output ``TextDocument`` (kept out of the document text). '
+                'Reasoning is markedly slower and far more token-hungry: the '
+                'whole trace is generated before the answer and drawn from the '
+                'same budget capped by ``maxNewTokens``, so raise '
+                '``maxNewTokens`` substantially (thousands of tokens, not '
+                'hundreds) when enabling this, or the trace may consume the '
+                'entire budget and the answer be truncated or empty. Small '
+                'reasoning models (as a rule of thumb, roughly 4B parameters '
+                'and under) are especially prone to non-terminating "thinking '
+                'loops" that exhaust the budget without producing an answer; '
+                'validate termination per model before relying on it.',
+        },
         {
             'name': 'temperature', 'type': 'number', 'default': 0.0,
             'description':
@@ -1109,37 +1188,56 @@ class ClamsPromptableApp(ClamsApp):
             text: str,
             open_tag: str = '<think>',
             close_tag: str = '</think>',
+            assume_open: bool = False,
     ) -> Tuple[str, Optional[str]]:
         """
         Split a reasoning model's output into ``(answer, trace)`` for the
-        inline XML-tag style: a single reasoning block delimited by
-        ``open_tag`` / ``close_tag`` (default ``<think>`` / ``</think>``)
-        embedded in the decoded text, e.g. as emitted by DeepSeek-R1 or
-        Qwen3.
-
-        It does NOT handle models that isolate reasoning in a separate
-        token-delimited channel rather than an inline tag block (e.g.
-        gpt-oss, Gemma 4); those need their own parsing in the app. Trace
-        handling is the app's responsibility either way -- call this when
-        the model fits the inline-tag style, or parse it yourself.
-
-        ``answer`` is everything after the final ``close_tag`` (stripped);
-        ``trace`` is the text between the tags, or ``None`` when no closed
-        block is present -- so it is safe to call on non-reasoning output,
-        which returns ``(text.strip(), None)``.
+        inline XML-tag style: a reasoning block delimited by ``open_tag`` /
+        ``close_tag`` (default ``<think>`` / ``</think>``), e.g. as emitted
+        by DeepSeek-R1 or Qwen3.5.
+
+        Prefilled opening tags: some chat templates inject the OPENING tag
+        into the prompt when reasoning is enabled (Qwen3.5 does this), so the
+        decoded output carries only the CLOSING tag -- the model never emits
+        the opener. Pass ``assume_open=True`` in that situation (typically
+        wired to the app's reasoning toggle) so the trace is still recovered.
+        The cases:
+
+        * close tag present: ``answer`` is the text after it; ``trace`` is the
+          text between the tags, or everything before the close tag when the
+          opening tag is absent (prefilled).
+        * close tag absent, ``assume_open=True``: the output is unterminated
+          reasoning (e.g. the trace overran ``maxNewTokens`` before closing) --
+          there is no answer, so returns ``('', text.strip())``.
+        * close tag absent, ``assume_open=False`` (default): treated as a
+          plain, non-reasoning answer -- returns ``(text.strip(), None)``.
+
+        Only the inline-tag style is handled; models that isolate reasoning in
+        a separate token-delimited channel (e.g. gpt-oss, Gemma) need their own
+        parsing in the app.
 
         :param text: raw decoded model output.
         :param open_tag: opening marker of the inline reasoning block.
         :param close_tag: closing marker of the inline reasoning block.
+        :param assume_open: treat the text as the body of a reasoning block
+            whose opening tag was prefilled into the prompt, so a missing close
+            tag means unterminated reasoning (empty answer) rather than a plain
+            answer.
         :return: ``(answer, trace_or_None)``.
         """
         ci = text.rfind(close_tag)
         if ci == -1:
-            return text.strip(), None
+            return ('', text.strip()) if assume_open else (text.strip(), None)
         answer = text[ci + len(close_tag):].strip()
         oi = text.find(open_tag)
-        trace = (text[oi + len(open_tag):ci].strip()
-                 if oi != -1 and oi < ci else None)
+        if oi != -1 and oi < ci:
+            trace = text[oi + len(open_tag):ci].strip()
+        elif assume_open:
+            # opening tag was prefilled into the prompt (not generated), so the
+            # trace is everything up to the close tag
+            trace = text[:ci].strip()
+        else:
+            trace = None
         return answer, trace
 class ClamsHFPromptableApp(ClamsPromptableApp):
     """
@@ -1511,10 +1609,13 @@ class ClamsHFPromptableApp(ClamsPromptableApp):
         implementation returns ``{}``.
 
         Override to inject model-specific chat-template controls without
-        having to reimplement :py:meth:`generate`. Common cases:
+        having to reimplement :py:meth:`generate`. This is where an app
+        honors the SDK ``useReasoning`` parameter, mapping it onto the
+        backend's reasoning switch. Common cases:
 
-        * ``{'enable_thinking': False}`` to run a reasoning ("thinking")
-          model in non-thinking mode;
+        * ``{'enable_thinking': bool(generation_params.get('use_reasoning'))}``
+          to bind ``useReasoning`` to a reasoning ("thinking") model's
+          template switch;
         * ``{'tools': [...]}`` or ``{'documents': [...]}`` for tool-use /
           RAG chat templates.
 

{clams_python-1.7.2 → clams_python-1.7.4}/clams/develop/templates/app/Containerfile.template

@@ -3,7 +3,7 @@ FROM ghcr.io/clamsproject/clams-python:$CLAMS_VERSION
 # See https://github.com/orgs/clamsproject/packages?tab=packages&q=clams-python for more base images
 # IF you want to automatically publish this image to the clamsproject organization,
 # 1. you should have generated this template without --no-github-actions flag
-# 1. to add arm64 support, change relevant line in .github/workflows/container.yml
+# 1. to add arm64 support, set `arm64: true` in .github/workflows/publish.yml
 #     * NOTE that a lots of software doesn't install/compile or run on arm64 architecture out of the box
 #     * make sure you locally test the compatibility of all software dependencies before using arm64 support
 # 1. use a git tag to trigger the github action. You need to use git tag to properly set app version anyway

{clams_python-1.7.2 → clams_python-1.7.4}/clams/develop/templates/app/cli.py.template

@@ -6,13 +6,17 @@ DO NOT CHANGE the name of the file
 """
 
 import argparse
+import json
 import sys
 from contextlib import redirect_stdout
 
+import jsonschema
+
 import app
 
 import clams.app
 from clams import AppMetadata
+from clams.envelop import EnvelopeError
 
 
 def metadata_to_argparser(app_metadata: AppMetadata) -> argparse.ArgumentParser:
@@ -81,11 +85,24 @@ if __name__ == "__main__":
                 params[pname] = pvalue
             else:
                 params[pname] = [pvalue]
-        if args.OUT_MMIF_FILE.name == '<stdout>':
-            with redirect_stdout(sys.stderr):
+        # Mirror the HTTP server's error handling (see clams.restify): an invalid
+        # input is reported and exits non-zero, while an app-level failure is
+        # recorded as an error view instead of crashing with a raw traceback.
+        try:
+            if args.OUT_MMIF_FILE.name == '<stdout>':
+                with redirect_stdout(sys.stderr):
+                    out_mmif = clamsapp.annotate(in_data, **params)
+            else:
                 out_mmif = clamsapp.annotate(in_data, **params)
-        else:
-            out_mmif = clamsapp.annotate(in_data, **params)
+        except (jsonschema.exceptions.ValidationError, json.JSONDecodeError, EnvelopeError) as e:
+            detail = e.message if isinstance(e, jsonschema.exceptions.ValidationError) else str(e)
+            print(f"Invalid input data. See below for validation error.\n\n{detail}", file=sys.stderr)
+            sys.exit(1)
+        except Exception:
+            clamsapp.logger.exception("Error in annotation")
+            out_mmif = clamsapp.record_error(in_data, **params).serialize(pretty=True)
+            args.OUT_MMIF_FILE.write(out_mmif)
+            sys.exit(1)
         args.OUT_MMIF_FILE.write(out_mmif)
     else:
         arg_parser.print_help()

{clams_python-1.7.2 → clams_python-1.7.4/clams_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clams-python
-Version: 1.7.2
+Version: 1.7.4
 Summary: A collection of APIs to develop CLAMS app for python
 License-Expression: Apache-2.0
 Project-URL: homepage, https://clams.ai
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mmif-python==1.5.1
+Requires-Dist: mmif-python==1.5.3
 Requires-Dist: Flask>=2
 Requires-Dist: Flask-RESTful>=0.3.9
 Requires-Dist: gunicorn>=20

{clams_python-1.7.2 → clams_python-1.7.4}/clams_python.egg-info/requires.txt

@@ -1,4 +1,4 @@
-mmif-python==1.5.1
+mmif-python==1.5.3
 Flask>=2
 Flask-RESTful>=0.3.9
 gunicorn>=20

{clams_python-1.7.2 → clams_python-1.7.4}/clams_python.egg-info/scm_file_list.json

@@ -1,96 +1,96 @@
 {
   "files": [
-    "README.md",
-    "LICENSE",
-    "pyproject.toml",
+    ".github/workflows/codecov.yml",
+    ".github/workflows/container.yml",
+    ".github/workflows/containers.yml",
+    ".github/workflows/issue-assign.yml",
+    ".github/workflows/issue-close.yml",
+    ".github/workflows/issue-infra-project.yml",
+    ".github/workflows/publish.yml",
+    ".github/workflows/release-check.yml",
+    ".gitignore",
     ".pytype.cfg",
     "CHANGELOG.md",
     "CONTRIBUTING.md",
-    ".gitignore",
-    "build-tools/publish.py",
-    "build-tools/prep_release.py",
+    "LICENSE",
+    "README.md",
     "build-tools/build.py",
-    "build-tools/docs.py",
     "build-tools/clean.py",
+    "build-tools/docs.py",
+    "build-tools/prep_release.py",
+    "build-tools/publish.py",
     "build-tools/test.py",
     "clams/__init__.py",
+    "clams/app/__init__.py",
+    "clams/appmetadata/__init__.py",
+    "clams/backends/__init__.py",
+    "clams/backends/hf.py",
     "clams/develop/__init__.py",
+    "clams/develop/templates/app/.dockerignore.template",
+    "clams/develop/templates/app/.gitignore.template",
+    "clams/develop/templates/app/Containerfile.template",
+    "clams/develop/templates/app/LICENSE.template",
+    "clams/develop/templates/app/README.md.template",
+    "clams/develop/templates/app/app.py.template",
+    "clams/develop/templates/app/cli.py.template",
+    "clams/develop/templates/app/metadata.py.template",
+    "clams/develop/templates/app/requirements.txt.template",
     "clams/develop/templates/gha/for-clams-team.md.template",
-    "clams/develop/templates/gha/workflows/issue-assign.yml.template",
-    "clams/develop/templates/gha/workflows/publish.yml.template",
     "clams/develop/templates/gha/workflows/issue-apps-project.yml.template",
+    "clams/develop/templates/gha/workflows/issue-assign.yml.template",
     "clams/develop/templates/gha/workflows/issue-close.yml.template",
+    "clams/develop/templates/gha/workflows/publish.yml.template",
     "clams/develop/templates/utl-tf/__init__.py.template",
     "clams/develop/templates/utl-tf/timeframe.py.template",
-    "clams/develop/templates/app/Containerfile.template",
-    "clams/develop/templates/app/metadata.py.template",
-    "clams/develop/templates/app/README.md.template",
-    "clams/develop/templates/app/.dockerignore.template",
-    "clams/develop/templates/app/requirements.txt.template",
-    "clams/develop/templates/app/LICENSE.template",
-    "clams/develop/templates/app/.gitignore.template",
-    "clams/develop/templates/app/app.py.template",
-    "clams/develop/templates/app/cli.py.template",
-    "clams/restify/__init__.py",
     "clams/envelop/__init__.py",
-    "clams/appmetadata/__init__.py",
-    "clams/app/__init__.py",
+    "clams/restify/__init__.py",
     "clams/serve/__init__.py",
     "clams/ver/__init__.py",
-    "clams/backends/__init__.py",
-    "clams/backends/hf.py",
-    "documentation/modules.rst",
-    "documentation/target-versions.csv",
+    "container/Containerfile",
+    "container/ffmpeg-hf.containerfile",
+    "container/ffmpeg-hf4.containerfile",
+    "container/ffmpeg-hf5.containerfile",
+    "container/ffmpeg-tf2.containerfile",
+    "container/ffmpeg-torch2.containerfile",
+    "container/ffmpeg.containerfile",
+    "container/generate_containers_yml.py",
+    "container/hf.containerfile",
+    "container/hf4.containerfile",
+    "container/hf5.containerfile",
+    "container/jdk8.containerfile",
+    "container/opencv4-hf.containerfile",
+    "container/opencv4-hf4.containerfile",
+    "container/opencv4-hf5.containerfile",
+    "container/opencv4-tf2.containerfile",
+    "container/opencv4-torch2.containerfile",
+    "container/opencv4.containerfile",
+    "container/tf2.containerfile",
+    "container/torch2.containerfile",
     "documentation/app-baseclasses.rst",
-    "documentation/gpu-apps.rst",
-    "documentation/clamsapp.rst",
     "documentation/appdirectory.rst",
-    "documentation/index.rst",
-    "documentation/tutorial.md",
-    "documentation/introduction.rst",
     "documentation/appmetadata.rst",
-    "documentation/cli.rst",
-    "documentation/runtime-params.rst",
-    "documentation/input-output.rst",
-    "documentation/conf.py",
-    "documentation/autodoc/clams.restify.rst",
     "documentation/autodoc/clams.app.rst",
+    "documentation/autodoc/clams.appmetadata.rst",
     "documentation/autodoc/clams.backends.rst",
     "documentation/autodoc/clams.mmif_utils.rst",
-    "documentation/autodoc/clams.appmetadata.rst",
-    "tests/test_promptable.py",
+    "documentation/autodoc/clams.restify.rst",
+    "documentation/clamsapp.rst",
+    "documentation/cli.rst",
+    "documentation/conf.py",
+    "documentation/gpu-apps.rst",
+    "documentation/index.rst",
+    "documentation/input-output.rst",
+    "documentation/introduction.rst",
+    "documentation/modules.rst",
+    "documentation/runtime-params.rst",
+    "documentation/target-versions.csv",
+    "documentation/tutorial.md",
+    "pyproject.toml",
+    "tests/metadata.py",
     "tests/pillow-logo.png",
     "tests/test_backends_hf.py",
-    "tests/test_envelope.py",
-    "tests/metadata.py",
     "tests/test_clamsapp.py",
-    "container/tf2.containerfile",
-    "container/opencv4-hf.containerfile",
-    "container/torch2.containerfile",
-    "container/opencv4-hf4.containerfile",
-    "container/Containerfile",
-    "container/hf4.containerfile",
-    "container/ffmpeg-hf.containerfile",
-    "container/ffmpeg-tf2.containerfile",
-    "container/generate_containers_yml.py",
-    "container/opencv4-tf2.containerfile",
-    "container/opencv4-torch2.containerfile",
-    "container/hf.containerfile",
-    "container/jdk8.containerfile",
-    "container/hf5.containerfile",
-    "container/ffmpeg.containerfile",
-    "container/ffmpeg-hf5.containerfile",
-    "container/ffmpeg-hf4.containerfile",
-    "container/opencv4-hf5.containerfile",
-    "container/ffmpeg-torch2.containerfile",
-    "container/opencv4.containerfile",
-    ".github/workflows/container.yml",
-    ".github/workflows/containers.yml",
-    ".github/workflows/issue-close.yml",
-    ".github/workflows/codecov.yml",
-    ".github/workflows/release-check.yml",
-    ".github/workflows/issue-infra-project.yml",
-    ".github/workflows/issue-assign.yml",
-    ".github/workflows/publish.yml"
+    "tests/test_envelope.py",
+    "tests/test_promptable.py"
   ]
 }

clams_python-1.7.4/clams_python.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.7.4",
+  "distance": 0,
+  "node": "g4a9316fc63b59287b43542fd15047a9a28028510",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-01"
+}

clams_python-1.7.4/container/ffmpeg-torch2.containerfile

@@ -0,0 +1,13 @@
+ARG clams_version
+FROM ghcr.io/clamsproject/clams-python-ffmpeg:$clams_version
+LABEL org.opencontainers.image.description="clams-python-ffmpeg-torch2 image is shipped with clams-python, ffmpeg, and PyTorch2"
+
+RUN pip install --no-cache-dir torch==2.*
+
+# PyTorch ships Triton, which JIT-compiles a small host-side CUDA driver shim
+# at runtime -- that needs a C compiler + libc headers. Keep it minimal
+# (gcc + libc6-dev); build-essential is not required.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends gcc libc6-dev \
+    && rm -rf /var/lib/apt/lists/*
+

clams_python-1.7.4/container/opencv4-torch2.containerfile

@@ -0,0 +1,13 @@
+ARG clams_version
+FROM ghcr.io/clamsproject/clams-python-opencv4:$clams_version
+LABEL org.opencontainers.image.description="clams-python-opencv4-torch2 image is shipped with clams-python, opencv4 (ffmpeg backend), and PyTorch2"
+
+RUN pip install --no-cache-dir torch==2.*
+
+# PyTorch ships Triton, which JIT-compiles a small host-side CUDA driver shim
+# at runtime -- that needs a C compiler + libc headers. Keep it minimal
+# (gcc + libc6-dev); build-essential is not required.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends gcc libc6-dev \
+    && rm -rf /var/lib/apt/lists/*
+

clams_python-1.7.4/container/torch2.containerfile

@@ -0,0 +1,13 @@
+ARG clams_version
+FROM ghcr.io/clamsproject/clams-python:$clams_version
+LABEL org.opencontainers.image.description="clams-python-torch2 image is shipped with clams-python and PyTorch2"
+
+RUN pip install --no-cache-dir torch==2.*
+
+# PyTorch ships Triton, which JIT-compiles a small host-side CUDA driver shim
+# at runtime -- that needs a C compiler + libc headers. Keep it minimal
+# (gcc + libc6-dev); build-essential is not required.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends gcc libc6-dev \
+    && rm -rf /var/lib/apt/lists/*
+