labcode 0.0.1__tar.gz

labcode-0.0.1/.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 labcode 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

labcode-0.0.1/.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.0.1` -> 0.0.1).
+# Routing:
+#   - a pre-release tag containing `rc` (e.g. v0.0.1rc1) -> TestPyPI (rehearsal)
+#   - any other `v*` tag (e.g. v0.0.1)                    -> 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=labcode, workflow=publish.yml, environment=pypi
+# (and environment=testpypi on TestPyPI). First release: register as "pending".
+# The published distribution name is `labcode`.
+
+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.0.1 must build 0.0.1. 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

labcode-0.0.1/.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/

labcode-0.0.1/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.

labcode-0.0.1/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: labcode
+Version: 0.0.1
+Summary: labcode -- a dialect wrapper over the Object-Flow Programming Language toolchain
+Author-email: Kazunari Kaizu <kwaizu@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ofplang/labcode
+Project-URL: Repository, https://github.com/ofplang/labcode
+Keywords: ofplang,labcode,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
+
+# labcode
+
+[![CI](https://github.com/ofplang/labcode/actions/workflows/ci.yml/badge.svg)](https://github.com/ofplang/labcode/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/labcode.svg)](https://pypi.org/project/labcode/)
+
+The **`lc`** command-line interface for the **labcode** dialect of the
+**Object-flow Programming Language**. Installing this one package pulls in the
+ofplang toolchain and exposes it under a single command:
+
+```sh
+lc validate ...   # check a workflow is well-formed portable v0
+lc schedule ...   # compute a schedule for a workflow
+lc run ...        # execute a workflow (rolling-horizon runner / simulator)
+```
+
+labcode is where a site-specific dialect and a custom runner (real lab hardware)
+are developed on top of the ofplang toolchain. At this version `lc` is a thin
+dispatcher that forwards each subcommand to the ofplang siblings **unchanged**;
+the dialect and custom-runner behavior will land in later versions, replacing
+individual subcommands behind the same interface.
+
+## Install
+
+```sh
+pip install labcode
+```
+
+Requires Python 3.10+. This package is a thin dispatcher; it depends on the
+ofplang 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
+
+The language is defined in the [ofplang/spec](https://github.com/ofplang/spec)
+repository.
+
+## Usage
+
+Each subcommand keeps its own options, exit codes, and `--help`:
+
+```sh
+lc --help            # top-level help
+lc <command> --help  # command-specific options
+lc --version
+```
+
+`lc` can also be run as a module: `python -m labcode <command> ...`.
+
+## License
+
+MIT

labcode-0.0.1/README.md

@@ -0,0 +1,52 @@
+# labcode
+
+[![CI](https://github.com/ofplang/labcode/actions/workflows/ci.yml/badge.svg)](https://github.com/ofplang/labcode/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/labcode.svg)](https://pypi.org/project/labcode/)
+
+The **`lc`** command-line interface for the **labcode** dialect of the
+**Object-flow Programming Language**. Installing this one package pulls in the
+ofplang toolchain and exposes it under a single command:
+
+```sh
+lc validate ...   # check a workflow is well-formed portable v0
+lc schedule ...   # compute a schedule for a workflow
+lc run ...        # execute a workflow (rolling-horizon runner / simulator)
+```
+
+labcode is where a site-specific dialect and a custom runner (real lab hardware)
+are developed on top of the ofplang toolchain. At this version `lc` is a thin
+dispatcher that forwards each subcommand to the ofplang siblings **unchanged**;
+the dialect and custom-runner behavior will land in later versions, replacing
+individual subcommands behind the same interface.
+
+## Install
+
+```sh
+pip install labcode
+```
+
+Requires Python 3.10+. This package is a thin dispatcher; it depends on the
+ofplang 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
+
+The language is defined in the [ofplang/spec](https://github.com/ofplang/spec)
+repository.
+
+## Usage
+
+Each subcommand keeps its own options, exit codes, and `--help`:
+
+```sh
+lc --help            # top-level help
+lc <command> --help  # command-specific options
+lc --version
+```
+
+`lc` can also be run as a module: `python -m labcode <command> ...`.
+
+## License
+
+MIT

labcode-0.0.1/labcode/__init__.py

@@ -0,0 +1 @@
+"""labcode -- the ``lc`` CLI, a dialect wrapper over the ofplang toolchain."""

labcode-0.0.1/labcode/__main__.py

@@ -0,0 +1,9 @@
+"""Enable ``python -m labcode <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 labcode.cli import main
+
+raise SystemExit(main())

labcode-0.0.1/labcode/cli.py

@@ -0,0 +1,99 @@
+"""labcode ``lc`` command-line interface.
+
+``lc`` is the entry point for the labcode dialect of the Object-flow Programming
+Language. It is a thin dispatcher over the ofplang toolchain: each subcommand is
+forwarded to a sibling package's own CLI, in-process::
+
+    lc validate ...  ->  ofplang.validate.cli.main
+    lc schedule ...  ->  ofplang.schedule.cli.main
+    lc run ...       ->  ofplang.run.cli.main
+
+At this version ``lc`` forwards to the ofplang siblings unchanged (no dialect
+behavior yet). The seam -- routing each subcommand independently -- is where the
+labcode dialect and its custom runner will later diverge. Each subcommand keeps
+its own options, exit codes, and ``--help``; ``lc`` 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: ``lc --help`` need not import a scheduler's ortools/numpy stack, and a
+# subcommand fails with a clear message if its package is somehow missing. This
+# dict is also the divergence seam: a later labcode version replaces an entry
+# (e.g. ``run``) with its own module to add dialect / custom-runner behavior.
+_SUBCOMMANDS: dict[str, str] = {
+    "validate": "ofplang.validate.cli",
+    "schedule": "ofplang.schedule.cli",
+    "run": "ofplang.run.cli",
+}
+
+_USAGE = """\
+usage: lc <command> [options]
+
+The labcode CLI: a dialect wrapper over the Object-flow Programming Language
+toolchain. Subcommands forward to the ofplang 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 `lc <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("labcode")
+    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"lc {_version()}\n")
+        return 0
+    if head.startswith("-"):
+        sys.stderr.write(f"lc: 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"lc: 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"lc: 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

labcode-0.0.1/labcode.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: labcode
+Version: 0.0.1
+Summary: labcode -- a dialect wrapper over the Object-Flow Programming Language toolchain
+Author-email: Kazunari Kaizu <kwaizu@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ofplang/labcode
+Project-URL: Repository, https://github.com/ofplang/labcode
+Keywords: ofplang,labcode,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
+
+# labcode
+
+[![CI](https://github.com/ofplang/labcode/actions/workflows/ci.yml/badge.svg)](https://github.com/ofplang/labcode/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/labcode.svg)](https://pypi.org/project/labcode/)
+
+The **`lc`** command-line interface for the **labcode** dialect of the
+**Object-flow Programming Language**. Installing this one package pulls in the
+ofplang toolchain and exposes it under a single command:
+
+```sh
+lc validate ...   # check a workflow is well-formed portable v0
+lc schedule ...   # compute a schedule for a workflow
+lc run ...        # execute a workflow (rolling-horizon runner / simulator)
+```
+
+labcode is where a site-specific dialect and a custom runner (real lab hardware)
+are developed on top of the ofplang toolchain. At this version `lc` is a thin
+dispatcher that forwards each subcommand to the ofplang siblings **unchanged**;
+the dialect and custom-runner behavior will land in later versions, replacing
+individual subcommands behind the same interface.
+
+## Install
+
+```sh
+pip install labcode
+```
+
+Requires Python 3.10+. This package is a thin dispatcher; it depends on the
+ofplang 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
+
+The language is defined in the [ofplang/spec](https://github.com/ofplang/spec)
+repository.
+
+## Usage
+
+Each subcommand keeps its own options, exit codes, and `--help`:
+
+```sh
+lc --help            # top-level help
+lc <command> --help  # command-specific options
+lc --version
+```
+
+`lc` can also be run as a module: `python -m labcode <command> ...`.
+
+## License
+
+MIT

labcode-0.0.1/labcode.egg-info/SOURCES.txt

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

labcode-0.0.1/labcode.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

labcode-0.0.1/labcode.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lc = labcode.cli:main

labcode-0.0.1/labcode.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

labcode-0.0.1/labcode.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",
+    "labcode/py.typed",
+    "labcode/__init__.py",
+    "labcode/cli.py",
+    "labcode/__main__.py",
+    "tests/test_cli.py"
+  ]
+}

labcode-0.0.1/labcode.egg-info/scm_version.json

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

labcode-0.0.1/labcode.egg-info/top_level.txt

@@ -0,0 +1 @@
+labcode

labcode-0.0.1/pyproject.toml

@@ -0,0 +1,82 @@
+[build-system]
+requires = ["setuptools>=77", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "labcode"
+description = "labcode -- a dialect wrapper over 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", "labcode", "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",
+]
+# labcode is a thin dispatcher: it bundles the toolchain by depending on the
+# ofplang 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`). At this version labcode adds no behavior beyond routing.
+dependencies = [
+    "ofplang-validate>=0.1.0",
+    "ofplang-schedule>=0.1.0",
+    "ofplang-run>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ofplang/labcode"
+Repository = "https://github.com/ofplang/labcode"
+
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+dev = ["pytest>=7.0", "ruff>=0.16", "mypy>=1.11"]
+
+[project.scripts]
+# The labcode command. Subcommands (`lc validate|schedule|run`) forward to the
+# ofplang sibling packages' own CLIs.
+lc = "labcode.cli:main"
+
+# Version is derived from git tags (e.g. `v0.0.1`) by setuptools-scm. Until the
+# first tag exists, fall back to a static placeholder so a source/editable tree
+# still builds and reports a version.
+[tool.setuptools_scm]
+fallback_version = "0.0.0"
+
+# labcode is an ordinary top-level package (it has an __init__.py); this
+# distribution provides only the `labcode` package.
+[tool.setuptools.packages.find]
+include = ["labcode*"]
+
+# Ship the PEP 561 marker so downstreams see this package as typed.
+[tool.setuptools.package-data]
+"labcode" = ["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 = ["labcode"]
+ignore_missing_imports = true
+warn_unused_ignores = true
+warn_redundant_casts = true

labcode-0.0.1/setup.cfg

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

labcode-0.0.1/tests/test_cli.py

@@ -0,0 +1,47 @@
+"""Behavioral tests for the labcode dispatcher.
+
+These exercise only `lc`-level routing; each subcommand's behavior is covered in
+its own ofplang 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 labcode.cli import main
+
+
+def test_no_args_is_usage_error(capsys: pytest.CaptureFixture[str]) -> None:
+    assert main([]) == 2
+    assert "usage: lc" 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: lc" 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("lc ")
+
+
+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