ofplang 0.1.0__tar.gz

ofplang-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,45 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      - run: pip install -e ".[test]"
+      - run: pytest
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check ofplang tests
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: pip install -e ".[dev]"
+      - run: mypy

ofplang-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,94 @@
+name: Publish
+
+# Tag-driven release via PyPI Trusted Publishing (OIDC) — no API tokens.
+#
+# Version comes from the pushed git tag via setuptools-scm (`v0.1.0` -> 0.1.0).
+# Routing:
+#   - a pre-release tag containing `rc` (e.g. v0.1.0rc1) -> TestPyPI (rehearsal)
+#   - any other `v*` tag (e.g. v0.1.0)                    -> PyPI (production)
+#   - manual workflow_dispatch -> choose the target explicitly (run it from a
+#     tagged commit, else setuptools-scm yields a dev+local version PyPI rejects)
+#
+# PyPI-side setup (done once, by the project owner): register a Trusted Publisher
+# for owner=ofplang, repo=ofp, workflow=publish.yml, environment=pypi
+# (and environment=testpypi on TestPyPI). First release: register as "pending".
+# The published distribution name is `ofplang`.
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      target:
+        description: "Publish target"
+        type: choice
+        options: [testpypi, pypi]
+        default: testpypi
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # setuptools-scm derives the version from tags + history.
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade build twine
+      - run: python -m build
+      - run: twine check dist/*
+      # Guard against ambiguous tags: the built version (from setuptools-scm) must
+      # equal the pushed tag — e.g. tag v0.1.0 must build 0.1.0. Catches a commit
+      # carrying two tags (an rc and a release) where git describe can resolve to
+      # the wrong one and publish the wrong artifact.
+      - name: Verify built version matches tag
+        if: startsWith(github.ref, 'refs/tags/')
+        shell: bash
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          built="$(ls dist/*.tar.gz | sed -E 's#.*/[^/]*-([0-9][^-]*)\.tar\.gz#\1#')"
+          echo "tag=$tag built=$built"
+          if [ "$tag" != "$built" ]; then
+            echo "::error::built version $built != tag $tag (ambiguous or misplaced tag?)"
+            exit 1
+          fi
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-testpypi:
+    needs: build
+    if: >-
+      github.event_name == 'workflow_dispatch' && inputs.target == 'testpypi'
+      || (github.event_name == 'push' && contains(github.ref_name, 'rc'))
+    runs-on: ubuntu-latest
+    environment: testpypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  publish-pypi:
+    needs: build
+    if: >-
+      github.event_name == 'workflow_dispatch' && inputs.target == 'pypi'
+      || (github.event_name == 'push' && !contains(github.ref_name, 'rc'))
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

ofplang-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+
+# Local working notes, not part of the published project (until explicitly committed).
+CLAUDE.md
+dev-notes/

ofplang-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kazunari Kaizu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ofplang-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: ofplang
+Version: 0.1.0
+Summary: Umbrella `ofp` command-line interface for the Object-flow Programming Language toolchain.
+Author-email: Kazunari Kaizu <kwaizu@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ofplang/ofp
+Project-URL: Repository, https://github.com/ofplang/ofp
+Keywords: ofplang,dataflow,workflow,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ofplang-validate>=0.1.0
+Requires-Dist: ofplang-schedule>=0.1.0
+Requires-Dist: ofplang-run>=0.1.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.16; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Dynamic: license-file
+
+# ofplang
+
+[![CI](https://github.com/ofplang/ofp/actions/workflows/ci.yml/badge.svg)](https://github.com/ofplang/ofp/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/ofplang.svg)](https://pypi.org/project/ofplang/)
+
+The umbrella **`ofp`** command-line interface for the **Object-flow Programming
+Language** toolchain. Installing this one package pulls in the whole toolchain
+and exposes it under a single command:
+
+```sh
+ofp validate ...   # check a workflow is well-formed portable v0
+ofp schedule ...   # compute a schedule for a workflow
+ofp run ...        # execute a workflow (rolling-horizon runner / simulator)
+```
+
+The language is defined in the [ofplang/spec](https://github.com/ofplang/spec)
+repository.
+
+## Install
+
+```sh
+pip install ofplang
+```
+
+Requires Python 3.10+. This package is a thin dispatcher; it depends on the
+sibling packages that do the work:
+
+- [`ofplang-validate`](https://github.com/ofplang/validate) — the validator
+- [`ofplang-schedule`](https://github.com/ofplang/schedule) — the scheduler
+- [`ofplang-run`](https://github.com/ofplang/run) — the runner / simulator
+
+## Command line
+
+```sh
+ofp <command> [options]         # or: python -m ofplang.ofp <command> [options]
+ofp <command> --help            # command-specific options
+ofp --version
+```
+
+`ofp` forwards each subcommand to the corresponding sibling CLI **in-process**,
+so every command keeps its own options, output, and exit codes. `ofp` itself
+adds only routing and a top-level `--help`/`--version`.
+
+Each sibling also installs its own standalone command (`ofp-validate`,
+`ofp-schedule`, `ofp-run`); `ofp <command>` is the convenience aggregator.
+
+Exit codes: `2` for an unknown/missing command or usage error at the `ofp`
+level; otherwise the subcommand's own exit code is returned unchanged.
+
+## Scope
+
+This repository contains only the dispatcher. Behavior, options, and semantics
+live in the sibling repositories linked above. The package is published to PyPI
+as `ofplang`; the `ofplang` import namespace is a PEP 420 namespace shared
+across the organization's tools, and this distribution provides `ofplang.ofp`.

ofplang-0.1.0/README.md

@@ -0,0 +1,55 @@
+# ofplang
+
+[![CI](https://github.com/ofplang/ofp/actions/workflows/ci.yml/badge.svg)](https://github.com/ofplang/ofp/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/ofplang.svg)](https://pypi.org/project/ofplang/)
+
+The umbrella **`ofp`** command-line interface for the **Object-flow Programming
+Language** toolchain. Installing this one package pulls in the whole toolchain
+and exposes it under a single command:
+
+```sh
+ofp validate ...   # check a workflow is well-formed portable v0
+ofp schedule ...   # compute a schedule for a workflow
+ofp run ...        # execute a workflow (rolling-horizon runner / simulator)
+```
+
+The language is defined in the [ofplang/spec](https://github.com/ofplang/spec)
+repository.
+
+## Install
+
+```sh
+pip install ofplang
+```
+
+Requires Python 3.10+. This package is a thin dispatcher; it depends on the
+sibling packages that do the work:
+
+- [`ofplang-validate`](https://github.com/ofplang/validate) — the validator
+- [`ofplang-schedule`](https://github.com/ofplang/schedule) — the scheduler
+- [`ofplang-run`](https://github.com/ofplang/run) — the runner / simulator
+
+## Command line
+
+```sh
+ofp <command> [options]         # or: python -m ofplang.ofp <command> [options]
+ofp <command> --help            # command-specific options
+ofp --version
+```
+
+`ofp` forwards each subcommand to the corresponding sibling CLI **in-process**,
+so every command keeps its own options, output, and exit codes. `ofp` itself
+adds only routing and a top-level `--help`/`--version`.
+
+Each sibling also installs its own standalone command (`ofp-validate`,
+`ofp-schedule`, `ofp-run`); `ofp <command>` is the convenience aggregator.
+
+Exit codes: `2` for an unknown/missing command or usage error at the `ofp`
+level; otherwise the subcommand's own exit code is returned unchanged.
+
+## Scope
+
+This repository contains only the dispatcher. Behavior, options, and semantics
+live in the sibling repositories linked above. The package is published to PyPI
+as `ofplang`; the `ofplang` import namespace is a PEP 420 namespace shared
+across the organization's tools, and this distribution provides `ofplang.ofp`.

ofplang-0.1.0/ofplang/ofp/__init__.py

@@ -0,0 +1 @@
+"""ofplang.ofp -- the umbrella ``ofp`` CLI that dispatches to the toolchain."""

ofplang-0.1.0/ofplang/ofp/__main__.py

@@ -0,0 +1,9 @@
+"""Enable ``python -m ofplang.ofp <command> ...``.
+
+Intent: mirror the console-script entry point so the CLI is reachable without an
+installed script, which is convenient in dev checkouts and CI.
+"""
+
+from ofplang.ofp.cli import main
+
+raise SystemExit(main())

ofplang-0.1.0/ofplang/ofp/cli.py

@@ -0,0 +1,92 @@
+"""Umbrella ``ofp`` command-line interface.
+
+``ofp`` is a thin dispatcher over the Object-flow Programming Language toolchain.
+It forwards each subcommand to a sibling package's own CLI, in-process::
+
+    ofp validate ...  ->  ofplang.validate.cli.main
+    ofp schedule ...  ->  ofplang.schedule.cli.main
+    ofp run ...       ->  ofplang.run.cli.main
+
+Each subcommand keeps its own options, exit codes, and ``--help``; ``ofp`` adds
+no behavior of its own beyond routing plus a top-level ``--help``/``--version``.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from collections.abc import Sequence
+
+# Subcommand -> dotted path of the sibling CLI module exposing ``main(argv)``.
+# Kept as strings so each sibling is imported lazily, only when its subcommand is
+# invoked: ``ofp --help`` need not import a scheduler's ortools/numpy stack, and a
+# subcommand fails with a clear message if its package is somehow missing.
+_SUBCOMMANDS: dict[str, str] = {
+    "validate": "ofplang.validate.cli",
+    "schedule": "ofplang.schedule.cli",
+    "run": "ofplang.run.cli",
+}
+
+_USAGE = """\
+usage: ofp <command> [options]
+
+The umbrella CLI for the Object-flow Programming Language toolchain.
+
+commands:
+  validate    check a workflow document is well-formed portable v0
+  schedule    compute a schedule for a workflow
+  run         execute a workflow (rolling-horizon runner / simulator)
+
+Run `ofp <command> --help` for command-specific options.
+
+options:
+  -h, --help     show this help and exit
+  -V, --version  show version and exit
+"""
+
+
+def _version() -> str:
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        return version("ofplang")
+    except PackageNotFoundError:  # editable/source tree without installed metadata
+        return "0+unknown"
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+
+    if not args:
+        sys.stderr.write(_USAGE)
+        return 2
+
+    head = args[0]
+    if head in ("-h", "--help"):
+        sys.stdout.write(_USAGE)
+        return 0
+    if head in ("-V", "--version"):
+        sys.stdout.write(f"ofp {_version()}\n")
+        return 0
+    if head.startswith("-"):
+        sys.stderr.write(f"ofp: unrecognized option {head!r}\n\n")
+        sys.stderr.write(_USAGE)
+        return 2
+
+    module_path = _SUBCOMMANDS.get(head)
+    if module_path is None:
+        sys.stderr.write(f"ofp: unknown command {head!r}\n\n")
+        sys.stderr.write(_USAGE)
+        return 2
+
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as exc:
+        sys.stderr.write(
+            f"ofp: the '{head}' command requires a package that is not installed "
+            f"({exc}).\n"
+        )
+        return 2
+
+    exit_code: int = module.main(args[1:])
+    return exit_code

ofplang-0.1.0/ofplang.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: ofplang
+Version: 0.1.0
+Summary: Umbrella `ofp` command-line interface for the Object-flow Programming Language toolchain.
+Author-email: Kazunari Kaizu <kwaizu@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ofplang/ofp
+Project-URL: Repository, https://github.com/ofplang/ofp
+Keywords: ofplang,dataflow,workflow,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ofplang-validate>=0.1.0
+Requires-Dist: ofplang-schedule>=0.1.0
+Requires-Dist: ofplang-run>=0.1.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.16; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Dynamic: license-file
+
+# ofplang
+
+[![CI](https://github.com/ofplang/ofp/actions/workflows/ci.yml/badge.svg)](https://github.com/ofplang/ofp/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/ofplang.svg)](https://pypi.org/project/ofplang/)
+
+The umbrella **`ofp`** command-line interface for the **Object-flow Programming
+Language** toolchain. Installing this one package pulls in the whole toolchain
+and exposes it under a single command:
+
+```sh
+ofp validate ...   # check a workflow is well-formed portable v0
+ofp schedule ...   # compute a schedule for a workflow
+ofp run ...        # execute a workflow (rolling-horizon runner / simulator)
+```
+
+The language is defined in the [ofplang/spec](https://github.com/ofplang/spec)
+repository.
+
+## Install
+
+```sh
+pip install ofplang
+```
+
+Requires Python 3.10+. This package is a thin dispatcher; it depends on the
+sibling packages that do the work:
+
+- [`ofplang-validate`](https://github.com/ofplang/validate) — the validator
+- [`ofplang-schedule`](https://github.com/ofplang/schedule) — the scheduler
+- [`ofplang-run`](https://github.com/ofplang/run) — the runner / simulator
+
+## Command line
+
+```sh
+ofp <command> [options]         # or: python -m ofplang.ofp <command> [options]
+ofp <command> --help            # command-specific options
+ofp --version
+```
+
+`ofp` forwards each subcommand to the corresponding sibling CLI **in-process**,
+so every command keeps its own options, output, and exit codes. `ofp` itself
+adds only routing and a top-level `--help`/`--version`.
+
+Each sibling also installs its own standalone command (`ofp-validate`,
+`ofp-schedule`, `ofp-run`); `ofp <command>` is the convenience aggregator.
+
+Exit codes: `2` for an unknown/missing command or usage error at the `ofp`
+level; otherwise the subcommand's own exit code is returned unchanged.
+
+## Scope
+
+This repository contains only the dispatcher. Behavior, options, and semantics
+live in the sibling repositories linked above. The package is published to PyPI
+as `ofplang`; the `ofplang` import namespace is a PEP 420 namespace shared
+across the organization's tools, and this distribution provides `ofplang.ofp`.

ofplang-0.1.0/ofplang.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+.gitignore
+LICENSE
+README.md
+pyproject.toml
+.github/workflows/ci.yml
+.github/workflows/publish.yml
+ofplang.egg-info/PKG-INFO
+ofplang.egg-info/SOURCES.txt
+ofplang.egg-info/dependency_links.txt
+ofplang.egg-info/entry_points.txt
+ofplang.egg-info/requires.txt
+ofplang.egg-info/scm_file_list.json
+ofplang.egg-info/scm_version.json
+ofplang.egg-info/top_level.txt
+ofplang/ofp/__init__.py
+ofplang/ofp/__main__.py
+ofplang/ofp/cli.py
+ofplang/ofp/py.typed
+tests/test_cli.py

ofplang-0.1.0/ofplang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ofplang-0.1.0/ofplang.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ofp = ofplang.ofp.cli:main

ofplang-0.1.0/ofplang.egg-info/requires.txt

@@ -0,0 +1,11 @@
+ofplang-validate>=0.1.0
+ofplang-schedule>=0.1.0
+ofplang-run>=0.1.0
+
+[dev]
+pytest>=7.0
+ruff>=0.16
+mypy>=1.11
+
+[test]
+pytest>=7.0

ofplang-0.1.0/ofplang.egg-info/scm_file_list.json

@@ -0,0 +1,15 @@
+{
+  "files": [
+    "pyproject.toml",
+    "LICENSE",
+    "README.md",
+    ".gitignore",
+    ".github/workflows/ci.yml",
+    ".github/workflows/publish.yml",
+    "tests/test_cli.py",
+    "ofplang/ofp/py.typed",
+    "ofplang/ofp/__init__.py",
+    "ofplang/ofp/cli.py",
+    "ofplang/ofp/__main__.py"
+  ]
+}

ofplang-0.1.0/ofplang.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.0",
+  "distance": 0,
+  "node": "g5ef76f45941009748b95be652827fcf4b0b62e8c",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-26"
+}

ofplang-0.1.0/ofplang.egg-info/top_level.txt

@@ -0,0 +1 @@
+ofplang

ofplang-0.1.0/pyproject.toml

@@ -0,0 +1,87 @@
+[build-system]
+requires = ["setuptools>=77", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ofplang"
+description = "Umbrella `ofp` command-line interface for the Object-flow Programming Language toolchain."
+requires-python = ">=3.10"
+dynamic = ["version"]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Kazunari Kaizu", email = "kwaizu@gmail.com" }]
+keywords = ["ofplang", "dataflow", "workflow", "cli"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Compilers",
+    "Typing :: Typed",
+]
+# This distribution is a thin dispatcher: it bundles the toolchain by depending
+# on the sibling packages and forwards each subcommand to their CLIs in-process.
+# Siblings are resolved from PyPI; the lower bound matches the sibling-to-sibling
+# convention (`>=0.1.0`).
+dependencies = [
+    "ofplang-validate>=0.1.0",
+    "ofplang-schedule>=0.1.0",
+    "ofplang-run>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ofplang/ofp"
+Repository = "https://github.com/ofplang/ofp"
+
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+dev = ["pytest>=7.0", "ruff>=0.16", "mypy>=1.11"]
+
+[project.scripts]
+# The umbrella command. Subcommands (`ofp validate|schedule|run`) forward to the
+# sibling packages' own CLIs; those also ship standalone `ofp-*` commands.
+ofp = "ofplang.ofp.cli:main"
+
+# Version is derived from git tags (e.g. `v0.1.0`) by setuptools-scm; there is no
+# static version in this file.
+[tool.setuptools_scm]
+
+# `ofplang` is a PEP 420 namespace shared across the org's repos (validate,
+# schedule, run, …); this distribution provides only the `ofplang.ofp` package
+# (the dispatcher) under it.
+[tool.setuptools.packages.find]
+include = ["ofplang*"]
+namespaces = true
+
+# Ship the PEP 561 marker so downstreams see this package as typed.
+[tool.setuptools.package-data]
+"ofplang.ofp" = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+addopts = "-ra"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "C4", "W"]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["ofplang"]
+# `ofplang` is a PEP 420 namespace package (no __init__.py), so tell mypy how to
+# root it rather than letting it guess module names.
+namespace_packages = true
+explicit_package_bases = true
+mypy_path = "."
+ignore_missing_imports = true
+warn_unused_ignores = true
+warn_redundant_casts = true

ofplang-0.1.0/setup.cfg

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

ofplang-0.1.0/tests/test_cli.py

@@ -0,0 +1,47 @@
+"""Behavioral tests for the umbrella dispatcher.
+
+These exercise only `ofp`-level routing; each subcommand's behavior is covered in
+its own sibling repository. `validate` is used as the dispatch probe because it
+is the lightest sibling (PyYAML only, no ortools/numpy).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from ofplang.ofp.cli import main
+
+
+def test_no_args_is_usage_error(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main([]) == 2
+    assert "usage: ofp" in capsys.readouterr().err
+
+
+def test_help_goes_to_stdout_and_succeeds(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main(["--help"]) == 0
+    out = capsys.readouterr().out
+    assert "usage: ofp" in out
+    assert "validate" in out and "schedule" in out and "run" in out
+
+
+def test_version(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main(["--version"]) == 0
+    assert capsys.readouterr().out.startswith("ofp ")
+
+
+def test_unknown_command_is_usage_error(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main(["frobnicate"]) == 2
+    assert "unknown command" in capsys.readouterr().err
+
+
+def test_unrecognized_option_is_usage_error(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main(["--nope"]) == 2
+    assert "unrecognized option" in capsys.readouterr().err
+
+
+def test_dispatches_to_subcommand() -> None:
+    # A missing path is the validator's own usage error (exit 2), returned as a
+    # plain int; proves routing reaches the sibling and its exit code passes
+    # through unchanged. (`validate --help` would instead raise SystemExit from
+    # argparse, which is correct at runtime but awkward to assert on here.)
+    assert main(["validate", "no-such-file.yaml"]) == 2