openjd-cli 0.7.4__tar.gz → 0.7.6__tar.gz

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openjd-cli
-Version: 0.7.4
+Version: 0.7.6
 Summary: Provides a command-line interface for working with Open Job Description templates.
 Project-URL: Homepage, https://github.com/OpenJobDescription/openjd-cli
 Project-URL: Source, https://github.com/OpenJobDescription/openjd-cli
@@ -22,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
-Requires-Dist: openjd-model<0.9,>=0.8
-Requires-Dist: openjd-sessions<0.11,>=0.10.3
+Requires-Dist: openjd-model<0.12,>=0.9
+Requires-Dist: openjd-sessions<0.11,>=0.10.11
 Description-Content-Type: text/markdown
 
 ## Open Job Description - CLI

openjd_cli-0.7.6/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.7.6'
+__version_tuple__ = version_tuple = (0, 7, 6)
+
+__commit_id__ = commit_id = None

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/hatch.toml

@@ -23,9 +23,6 @@ lint = [
 [[envs.all.matrix]]
 python = ["3.9", "3.10", "3.11", "3.12", "3.13"]
 
-[envs.codebuild.scripts]
-build = "hatch build"
-
 [envs.release]
 detached = true
 

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/hatch_version_hook.py

@@ -7,7 +7,6 @@ from dataclasses import dataclass
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
 from typing import Any, Optional
 
-
 _logger = logging.Logger(__name__, logging.INFO)
 _stdout_handler = logging.StreamHandler(sys.stdout)
 _stdout_handler.addFilter(lambda record: record.levelno <= logging.INFO)

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/pyproject.toml

@@ -29,8 +29,11 @@ classifiers = [
   "Intended Audience :: End Users/Desktop"
 ]
 dependencies = [
-  "openjd-sessions >= 0.10.3,< 0.11",
-  "openjd-model >= 0.8,< 0.9"
+  # 0.10.11 is the first release with `step_name` on both Session.run_task and
+  # Session.enter_environment (RFC 0007/0008). Below it, run_task() raises
+  # TypeError on every task run, since this CLI passes the keyword unconditionally.
+  "openjd-sessions >= 0.10.11,< 0.11",
+  "openjd-model >= 0.9,< 0.12"
 ]
 
 [project.urls]

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/__main__.py

@@ -2,5 +2,4 @@
 
 from .cli._create_argparser import main
 
-
 main()

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_check/_check_command.py

@@ -41,7 +41,10 @@ def do_check(args: Namespace) -> OpenJDCliResult:
         if TemplateSpecificationVersion.is_job_template(template_version):
             decode_job_template(template=template_object, supported_extensions=extensions)
         elif TemplateSpecificationVersion.is_environment_template(template_version):
-            decode_environment_template(template=template_object)
+            # Pass `extensions` so env templates can declare e.g.
+            # WRAP_ACTIONS (RFC 0008) — without this the model rejects
+            # the extension declaration even though the CLI accepts it.
+            decode_environment_template(template=template_object, supported_extensions=extensions)
         else:
             return OpenJDCliResult(
                 status="error",

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_common/_extensions.py

@@ -3,14 +3,23 @@
 from argparse import ArgumentParser
 from typing import Optional
 
-# This is the list of Open Job Description extensions with implemented support
-SUPPORTED_EXTENSIONS = ["TASK_CHUNKING", "REDACTED_ENV_VARS"]
+# This is the list of Open Job Description extensions with implemented support.
+# EXPR (RFCs 0005/0006) and WRAP_ACTIONS (RFC 0008) are added so the CLI can run
+# templates that declare them. WRAP_ACTIONS implies EXPR; the model library
+# handles that implication when it parses the template.
+SUPPORTED_EXTENSIONS = [
+    "TASK_CHUNKING",
+    "REDACTED_ENV_VARS",
+    "FEATURE_BUNDLE_1",
+    "EXPR",
+    "WRAP_ACTIONS",
+]
 
 
 def add_extensions_argument(run_parser: ArgumentParser):
     run_parser.add_argument(
         "--extensions",
-        help=f"A comma-separated list of Open Job Description extension names to enable. Defaults to all that are implemented: {','.join(SUPPORTED_EXTENSIONS)}",
+        help=f"A comma-separated list of Open Job Description extension names that the CLI will accept from job templates. Templates declare which extensions they use. Defaults to all that are implemented: {','.join(SUPPORTED_EXTENSIONS)}",
     )
 
 

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_common/_validation_utils.py

@@ -1,6 +1,6 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 
-from typing import Any
+from typing import Any, Optional
 from pathlib import Path
 
 from openjd.model import (
@@ -70,15 +70,29 @@ def read_job_template(template_file: Path, *, supported_extensions: list[str]) -
     return template
 
 
-def read_environment_template(template_file: Path) -> EnvironmentTemplate:
+def read_environment_template(
+    template_file: Path,
+    *,
+    supported_extensions: Optional[list[str]] = None,
+) -> EnvironmentTemplate:
     """Open a JSON or YAML-formatted file and attempt to parse it into an EnvironmentTemplate object.
     Raises a RuntimeError if the file doesn't exist or can't be opened, and raises a
     DecodeValidationError if its contents can't be parsed into a valid EnvironmentTemplate.
+
+    Environment templates may declare extensions just like job templates do
+    (e.g. ``WRAP_ACTIONS`` for RFC 0008's wrap hooks). Pass the CLI's allow-list
+    via ``supported_extensions`` so the model accepts those declarations;
+    omitting the argument preserves the legacy behavior of accepting only the
+    default model surface.
     """
     # Raises RuntimeError
     template_object = read_template(template_file)
 
+    decode_kwargs: dict[str, list[str]] = {}
+    if supported_extensions is not None:
+        decode_kwargs["supported_extensions"] = supported_extensions
+
     # Raises: DecodeValidationError
-    template = decode_environment_template(template=template_object)
+    template = decode_environment_template(template=template_object, **decode_kwargs)
 
     return template

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_create_argparser.py

@@ -14,7 +14,6 @@ from ._summary import populate_argparser as populate_summary_subparser
 from ._run import populate_argparser as populate_run_subparser
 from ._schema import populate_argparser as populate_schema_subparser
 
-
 # Our CLI subcommand construction requires that all leaf subcommands define a default
 # 'func' property which is a Callable[[],None] that implements the subcommand.
 # After parsing, we call that `func` argument of the resulting args object.

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_run/_local_session/_actions.py

@@ -1,6 +1,7 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 
 from enum import Enum
+from typing import Any, Optional
 
 from openjd.model import Step, TaskParameterSet
 from openjd.model.v2023_09 import Environment
@@ -47,7 +48,11 @@ class RunTaskAction(SessionAction):
 
     def run(self):
         self._session.run_task(
-            step_script=self._step.script, task_parameter_values=self._parameters
+            step_script=self._step.script,
+            task_parameter_values=self._parameters,
+            # RFC 0008: the step name feeds the WrappedStep.Name template
+            # variable inside an active onWrapTaskRun hook.
+            step_name=self._step.name,
         )
 
     def __str__(self):
@@ -58,14 +63,46 @@ class RunTaskAction(SessionAction):
 class EnterEnvironmentAction(SessionAction):
     _environment: Environment
     _id: str
-
-    def __init__(self, session: Session, environment: Environment, env_id: str):
+    _extra_let_bindings: Optional[list[str]]
+    _step_name: Optional[str]
+
+    def __init__(
+        self,
+        session: Session,
+        environment: Environment,
+        env_id: str,
+        extra_let_bindings: Optional[list[str]] = None,
+        step_name: Optional[str] = None,
+    ):
         super(EnterEnvironmentAction, self).__init__(session)
         self._environment = environment
         self._id = env_id
+        # RFC 0007: a step's environments are entered with the step-level
+        # `let` bindings so their variables/actions can reference them.
+        self._extra_let_bindings = extra_let_bindings
+        # RFC 0007 §7.3.1 (EXPR): the owning step's name seeds Step.Name for
+        # a step environment's `let` bindings, variables, and actions. Only
+        # step-environment enters carry a step name; job/external enters
+        # leave it None.
+        self._step_name = step_name
 
     def run(self):
-        self._session.enter_environment(environment=self._environment, identifier=self._id)
+        # Both keywords are guaranteed by this package's `openjd-sessions`
+        # floor (>= 0.10.11), so neither is feature-detected. They are still
+        # only forwarded when they carry something: a step with no `let`
+        # bindings means "no extra bindings", and job/external environment
+        # enters have no owning step, so `Step.Name` must stay undefined for
+        # them rather than being seeded with None.
+        optional_kwargs: dict[str, Any] = {}
+        if self._extra_let_bindings:
+            optional_kwargs["extra_let_bindings"] = self._extra_let_bindings
+        if self._step_name is not None:
+            optional_kwargs["step_name"] = self._step_name
+        self._session.enter_environment(
+            environment=self._environment,
+            identifier=self._id,
+            **optional_kwargs,
+        )
 
     def __str__(self):
         return f"Enter Environment '{self._environment.name}'"

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_run/_local_session/_session_manager.py

@@ -8,6 +8,7 @@ from types import FrameType, TracebackType
 from signal import signal, SIGINT, SIGTERM, SIG_DFL
 from itertools import islice
 from datetime import datetime, timedelta, timezone
+from math import isfinite
 
 from ._actions import (
     EnterEnvironmentAction,
@@ -49,6 +50,50 @@ class LocalSessionFailed(RuntimeError):
         super().__init__(f"Action failed: {failed_action}")
 
 
+def _calculate_adaptive_chunk_size(
+    *,
+    current_chunk_size: int,
+    completed_task_count: int,
+    completed_task_duration: float,
+    target_runtime_seconds: float,
+) -> Optional[int]:
+    """The adaptive-chunking size estimate, or ``None`` to defer adjusting.
+
+    Implements steps 3-7 of the adaptive chunking algorithm in the Open Job
+    Description CLI specification (``specs/cli/run.md`` in openjd-rs): if the
+    cumulative duration is zero or non-finite, keep the current chunk size and
+    wait for a measurable sample.
+
+    Deferring matters because a zero ``duration_per_task`` makes the ideal size
+    unrepresentable. The two implementations fail differently without this
+    guard: the Rust CLI produces ``inf``, which saturates to a huge chunk size,
+    while Python raises ``ZeroDivisionError`` out of the run. Neither is
+    reachable through a normal ``openjd run`` today -- ``run_task`` always
+    spawns and waits on a real subprocess, so a measured chunk duration of
+    exactly ``0.0`` would need that round trip to complete inside one
+    ``perf_counter`` tick (~42 ns here) -- so this is spec conformance and
+    hardening rather than a fix for an observed failure.
+
+    Extracted as a module-level function, mirroring openjd-rs's
+    ``calculate_adaptive_chunk_size``, so the deferral is unit-testable without
+    needing to provoke an unreachable timing condition end to end.
+    """
+    if (
+        completed_task_count <= 0
+        or completed_task_duration <= 0.0
+        or not isfinite(completed_task_duration)
+    ):
+        return None
+
+    duration_per_task = completed_task_duration / completed_task_count
+    adaptive_chunk_size = target_runtime_seconds / duration_per_task
+    if completed_task_count < 10 and adaptive_chunk_size > current_chunk_size:
+        # When we have data about only a few tasks, gradually blend in the new
+        # estimate instead of cutting over immediately.
+        adaptive_chunk_size = 0.75 * current_chunk_size + 0.25 * adaptive_chunk_size
+    return max(int(adaptive_chunk_size), 1)
+
+
 class LocalSession:
     """
     A class to manage a `Session` object from the `sessions` module,
@@ -102,6 +147,8 @@ class LocalSession:
         self._openjd_session = Session(
             session_id=self.session_id,
             job_parameter_values=job_parameter_values,
+            # RFC 0007 §7.3.1 (EXPR): seeds the Job.Name template variable.
+            job_name=str(job.name),
             path_mapping_rules=self._path_mapping_rules,
             callback=self._action_callback,
             retain_working_dir=retain_working_dir,
@@ -197,7 +244,14 @@ class LocalSession:
         LOG.info("Interruption signal recieved.")
         self.cancel()
 
-    def run_environment_enters(self, environments: Optional[list[Any]], type: EnvironmentType):
+    def run_environment_enters(
+        self,
+        environments: Optional[list[Any]],
+        type: EnvironmentType,
+        *,
+        extra_let_bindings: Optional[list[str]] = None,
+        step_name: Optional[str] = None,
+    ):
         """Enter one or more environments in the session."""
         if environments is None:
             return
@@ -211,10 +265,43 @@ class LocalSession:
             env_id = f"{type.name} - {env.name}"
             self._action_ended.clear()
             self._current_action = EnterEnvironmentAction(
-                session=self._openjd_session, environment=env, env_id=env_id
+                session=self._openjd_session,
+                environment=env,
+                env_id=env_id,
+                # RFC 0007: a step's environments see the step-level `let`
+                # bindings.
+                extra_let_bindings=extra_let_bindings,
+                # RFC 0007 §7.3.1 (EXPR): a step's environments see Step.Name.
+                # Only step-environment enters carry a step name.
+                step_name=step_name,
             )
             self._environments_entered.append((type, env_id))
-            self._current_action.run()
+            try:
+                self._current_action.run()
+            except (RuntimeError, ValueError) as exc:
+                # Session.enter_environment raises (rather than reporting
+                # through the action-status callback) when it rejects the
+                # environment up front — e.g. the RFC 0008 "at most one wrap
+                # environment" RuntimeError, or a ValueError from the extra
+                # `let` bindings — but it can also raise *after* registering
+                # the environment (e.g. an environment `variables` expression
+                # that fails to evaluate). Only when the session did NOT
+                # register the environment may we drop it from our entered
+                # list (cleanup must not try to exit it). If the session did
+                # register it, it must stay in our list so cleanup exits it —
+                # popping it here would skip its onExit and desynchronize us
+                # from the session's LIFO exit ordering check, masking the
+                # original error with "Must exit Environment X first".
+                if env_id not in self._openjd_session.environments_entered:
+                    self._environments_entered.pop()
+                LOG.info(
+                    msg=f"Open Job Description CLI: ERROR entering environment '{env.name}': {exc}",
+                    extra={"session_id": self.session_id},
+                )
+                self.failed = True
+                self._failed_action = self._current_action
+                self._current_action = None
+                raise LocalSessionFailed(self._failed_action) from exc
             self._action_ended.wait()
             if self.failed:
                 self._failed_action = self._current_action
@@ -300,27 +387,28 @@ class LocalSession:
             # Estimate a chunk size based on the statistics, and update the iterator. Note that this
             # logic is very simple, providing a good starting point that behaves reasonably for other implementations
             # to follow.
-            duration_per_task = completed_task_duration / completed_task_count
-            adaptive_chunk_size = target_runtime_seconds / duration_per_task
+            new_chunk_size = _calculate_adaptive_chunk_size(
+                current_chunk_size=task_parameters.chunks_default_task_count,  # type: ignore
+                completed_task_count=completed_task_count,
+                completed_task_duration=completed_task_duration,
+                target_runtime_seconds=target_runtime_seconds,
+            )
+            # `None` means there is no measurable sample yet: keep the current chunk
+            # size and wait for one. Deliberately not `continue` -- the maximum-task
+            # countdown below must still run for this completed chunk.
             if (
-                completed_task_count < 10
-                and adaptive_chunk_size > task_parameters.chunks_default_task_count  # type: ignore
+                new_chunk_size is not None
+                and new_chunk_size != task_parameters.chunks_default_task_count
             ):
-                # When we have data about only a few tasks, gradually blend in the new estimate instead of cutting over immediately
-                adaptive_chunk_size = (
-                    0.75 * task_parameters.chunks_default_task_count + 0.25 * adaptive_chunk_size  # type: ignore
-                )
-            adaptive_chunk_size = max(int(adaptive_chunk_size), 1)
-            if adaptive_chunk_size != task_parameters.chunks_default_task_count:
                 LOG.info(
                     msg=f"Open Job Description CLI: Ran {completed_task_count} tasks in {timedelta(seconds=completed_task_duration)}, average {timedelta(seconds=completed_task_duration / completed_task_count)}",
                     extra={"session_id": self.session_id},
                 )
                 LOG.info(
-                    msg=f"Open Job Description CLI: Adjusting chunk size from {task_parameters.chunks_default_task_count} to {adaptive_chunk_size}",
+                    msg=f"Open Job Description CLI: Adjusting chunk size from {task_parameters.chunks_default_task_count} to {new_chunk_size}",
                     extra={"session_id": self.session_id},
                 )
-                task_parameters.chunks_default_task_count = adaptive_chunk_size
+                task_parameters.chunks_default_task_count = new_chunk_size
 
             # If a maximum task count was specified, count them down
             if maximum_tasks and maximum_tasks > 0:
@@ -348,8 +436,22 @@ class LocalSession:
         if task_parameters is None:
             task_parameters = StepParameterSpaceIterator(space=step.parameterSpace)
 
-        # Enter all the step environments
-        self.run_environment_enters(step.stepEnvironments, EnvironmentType.STEP)
+        # Enter all the step environments. When the step defines step-level
+        # `let` bindings (RFC 0007), its environments are entered with them so
+        # their variables and actions can reference them.
+        # getattr guard: requires an openjd-model with Step.let on the
+        # instantiated Job (openjd-model PR #318+); collapse to plain
+        # `step.let` once the version pin floor guarantees it.
+        step_let_bindings = getattr(step, "let", None)
+        self.run_environment_enters(
+            step.stepEnvironments,
+            EnvironmentType.STEP,
+            extra_let_bindings=step_let_bindings or None,
+            # RFC 0007 §7.3.1 (EXPR): Step.Name is available to a step's
+            # environments (openjd-rs threads the step's resolved symbol
+            # table into enter_environment; this is the CLI counterpart).
+            step_name=step.name,
+        )
 
         try:
             # Run the tasks

{openjd_cli-0.7.4 → openjd_cli-0.7.6}/src/openjd/cli/_run/_run_command.py

@@ -338,6 +338,7 @@ def _run_local_session(
     Creates a Session object and listens for log messages to synchronously end the session.
     """
 
+    error_message = "Session ended with errors; see Task logs for details"
     try:
         start_seconds = time.perf_counter()
 
@@ -367,6 +368,14 @@ def _run_local_session(
     except LocalSessionFailed:
         duration = time.perf_counter() - start_seconds
         session = None
+    except (RuntimeError, ValueError) as exc:
+        # Exceptions raised by openjd.sessions from within session actions
+        # (e.g. the RFC 0008 "at most one wrap environment" RuntimeError)
+        # rather than reported through the action-status callback. Report
+        # them as a clean error result instead of a raw traceback.
+        duration = time.perf_counter() - start_seconds
+        session = None
+        error_message = f"Session ended with errors: {exc}"
 
     preserved_message: str = ""
     if retain_working_dir and session is not None:
@@ -377,7 +386,7 @@ def _run_local_session(
     if session is None or session.failed:
         return OpenJDRunResult(
             status="error",
-            message="Session ended with errors; see Task logs for details" + preserved_message,
+            message=error_message + preserved_message,
             job_name=job.name,
             step_name=step_name,
             duration=duration,
@@ -415,7 +424,11 @@ def do_run(args: Namespace) -> OpenJDCliResult:
             filename = Path(env).expanduser()
             try:
                 # Raises: RuntimeError, DecodeValidationError
-                env_template = read_environment_template(filename)
+                # Pass `extensions` so env templates can declare e.g.
+                # WRAP_ACTIONS (RFC 0008) — without this they're parsed
+                # against the default model surface and reject the
+                # extension declaration.
+                env_template = read_environment_template(filename, supported_extensions=extensions)
                 environments.append(env_template)
             except (RuntimeError, DecodeValidationError) as e:
                 return OpenJDCliResult(status="error", message=str(e))
@@ -543,9 +556,17 @@ def do_run(args: Namespace) -> OpenJDCliResult:
         return OpenJDCliResult(status="error", message=str(rte))
 
     # Create a RevisionExtensions object with the default specification version and enabled extensions
-    # We use the default v2023_09 since that's what we're currently supporting
+    # We use the default v2023_09 since that's what we're currently supporting.
+    # Extension behaviors activate only when declared by the templates being
+    # run (the job template and any external environment templates) — the
+    # CLI's --extensions list is what the CLI *accepts*, not what is enabled.
+    declared_extensions: list[str] = list(the_job.extensions or [])
+    for env_template in environments or []:
+        for ext_name in env_template.extensions or []:
+            if ext_name not in declared_extensions:
+                declared_extensions.append(ext_name)
     revision_extensions = RevisionExtensions(
-        spec_rev=the_job.revision, supported_extensions=extensions
+        spec_rev=the_job.revision, supported_extensions=declared_extensions
     )
 
     return _run_local_session(

openjd_cli-0.7.6/src/openjd/cli/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.7.6'
+__version_tuple__ = version_tuple = (0, 7, 6)
+
+__commit_id__ = commit_id = None

openjd_cli-0.7.4/_version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '0.7.4'
-__version_tuple__ = version_tuple = (0, 7, 4)
-
-__commit_id__ = commit_id = None

openjd_cli-0.7.4/src/openjd/cli/_version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '0.7.4'
-__version_tuple__ = version_tuple = (0, 7, 4)
-
-__commit_id__ = commit_id = None