ibm5250 0.1.0__tar.gz

ibm5250-0.1.0/.github/workflows/README.md

@@ -0,0 +1,48 @@
+# CI/CD: Build & Publish
+
+`publish.yml` builds the `ibm5250` package with [`uv`](https://docs.astral.sh/uv/)
+on every push and publishes it to PyPI using
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (OIDC) — no API
+tokens or secrets are stored in this repository.
+
+## Branch behavior
+
+| Branch                | Test | Build | Publish | Version format          |
+|------------------------|:----:|:-----:|:-------:|--------------------------|
+| `main`                 | ✅   | ✅    | ✅ (real PyPI, production) | `X.Y.Z` (patch auto-incremented from the latest published release for that `X.Y`) |
+| `develop`              | ✅   | ✅    | ✅ (real PyPI, development) | `X.Y.Z.devN` (`N` auto-incremented per base version) |
+| any other branch       | ✅   | ✅    | ❌      | n/a (build artifact only, not published) |
+
+The base version (`project.version` in `pyproject.toml`) is **never modified in
+the repository**. `scripts/compute_version.py` queries PyPI's public JSON API
+(`https://pypi.org/pypi/ibm5250/json`) at build time to determine the next
+version number, and `uv version` applies it only to the ephemeral CI checkout
+before `uv build` runs.
+
+## One-time setup required on PyPI
+
+Trusted Publishing must be configured on the `ibm5250` project at
+https://pypi.org (Project settings → Publishing) for **each** of the two
+publishing workflows below, since they use separate GitHub Environments:
+
+1. **Production publisher**
+   - Owner: `bengieeee` (or the appropriate GitHub org/user)
+   - Repository: `python5250`
+   - Workflow name: `publish.yml`
+   - Environment name: `pypi`
+
+2. **Development publisher**
+   - Owner / Repository / Workflow name: same as above
+   - Environment name: `pypi-dev`
+
+If the `ibm5250` project doesn't exist on PyPI yet, use PyPI's
+["pending publisher"](https://docs.pypi.org/trusted-publishers/creating-a-project-through-oidc/)
+flow to register the trusted publisher before the first release, which will
+create the project automatically on first successful publish.
+
+## GitHub Environments (recommended)
+
+Create the `pypi` and `pypi-dev` environments under repo Settings → Environments.
+Environments are optional for Trusted Publishing to function, but are
+recommended so you can add protection rules (e.g. required reviewers) around
+production PyPI publishes independently of development ones.

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

@@ -0,0 +1,112 @@
+name: Build and Publish
+
+on:
+  push:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Run tests
+        run: uv run pytest
+
+  build:
+    name: Build
+    needs: test
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Determine release channel
+        id: channel
+        run: |
+          if [ "${{ github.ref }}" = "refs/heads/main" ]; then
+            echo "channel=main" >> "$GITHUB_OUTPUT"
+          elif [ "${{ github.ref }}" = "refs/heads/develop" ]; then
+            echo "channel=develop" >> "$GITHUB_OUTPUT"
+          else
+            echo "channel=other" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Compute version
+        id: version
+        run: |
+          version=$(python3 scripts/compute_version.py "${{ steps.channel.outputs.channel }}")
+          echo "Computed version: $version"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Apply computed version
+        run: uv version --no-sync "${{ steps.version.outputs.version }}"
+
+      - name: Build package
+        run: uv build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          if-no-files-found: error
+
+  publish-main:
+    name: Publish (production / main)
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/
+
+  publish-develop:
+    name: Publish (development / develop)
+    needs: build
+    if: github.ref == 'refs/heads/develop'
+    runs-on: ubuntu-latest
+    environment: pypi-dev
+    permissions:
+      id-token: write
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

ibm5250-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+### macOS Finder metadata
+.DS_Store
+
+# Python Byte-compiled files
+__pycache__/
+
+# Python Distribution / packaging
+dist/
+*.egg-info/
+
+# Python dotenv environment variable files
+.env
+
+# Python Virtual environments
+.venv
+env/
+venv/
+
+# Python Caches
+.pytest_cache/

ibm5250-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: ibm5250
+Version: 0.1.0
+Summary: IBM 5250 terminal automation library
+Requires-Python: >=3.11

ibm5250-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "ibm5250"
+version = "0.1.0"
+description = "IBM 5250 terminal automation library"
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+# The repo's .gitignore excludes "*.py" (a pre-existing, unrelated quirk of this
+# repo) which would otherwise cause Hatchling to skip all Python source files
+# when it defaults to respecting VCS ignore rules. Disable that so real source
+# files are always included in built artifacts.
+ignore-vcs = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ibm5250"]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+  "src/ibm5250/tests",
+]

ibm5250-0.1.0/scripts/compute_version.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+"""Compute the version to publish for the current CI run.
+
+The version in pyproject.toml is never bumped in the repository itself.
+Instead, this script inspects the versions already published on PyPI and
+derives the *next* version to use for this build:
+
+- ``main``    -> bump the patch component of the highest published final
+                 release that shares the pyproject.toml major.minor version.
+                 If none exists yet, publish the pyproject.toml version as-is.
+- ``develop`` -> keep the pyproject.toml version as the base and append the
+                 next available PEP 440 ``devN`` suffix (e.g. ``0.1.0.dev3``).
+- anything else -> not published, so just echo the pyproject.toml version.
+
+Usage:
+    python scripts/compute_version.py <main|develop|other>
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+import tomllib
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+PACKAGE_NAME = "ibm5250"
+PYPI_JSON_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
+PYPROJECT_PATH = Path(__file__).resolve().parent.parent / "pyproject.toml"
+
+FINAL_VERSION_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)$")
+
+
+def read_base_version() -> str:
+    with PYPROJECT_PATH.open("rb") as f:
+        data = tomllib.load(f)
+    return data["project"]["version"]
+
+
+def fetch_published_versions() -> list[str]:
+    """Return the list of versions already published on PyPI (or [] if none)."""
+    try:
+        with urllib.request.urlopen(PYPI_JSON_URL, timeout=15) as resp:
+            payload = json.load(resp)
+        return list(payload.get("releases", {}).keys())
+    except urllib.error.HTTPError as exc:
+        if exc.code == 404:
+            return []
+        raise
+    except urllib.error.URLError:
+        # Network hiccups shouldn't hard-fail version computation; treat as
+        # "nothing published yet" so the build can still proceed.
+        return []
+
+
+def next_main_version(base_version: str, published: list[str]) -> str:
+    base_match = FINAL_VERSION_RE.match(base_version)
+    if not base_match:
+        raise ValueError(f"Unsupported base version format: {base_version!r}")
+    base_major, base_minor, base_patch = (int(x) for x in base_match.groups())
+
+    best_patch = None
+    for version in published:
+        m = FINAL_VERSION_RE.match(version)
+        if not m:
+            continue
+        major, minor, patch = (int(x) for x in m.groups())
+        if (major, minor) != (base_major, base_minor):
+            continue
+        if best_patch is None or patch > best_patch:
+            best_patch = patch
+
+    if best_patch is None:
+        # Nothing published yet for this major.minor: use the base version as-is.
+        return f"{base_major}.{base_minor}.{base_patch}"
+    return f"{base_major}.{base_minor}.{best_patch + 1}"
+
+
+def next_develop_version(base_version: str, published: list[str]) -> str:
+    dev_re = re.compile(rf"^{re.escape(base_version)}\.dev(\d+)$")
+    best_dev = None
+    for version in published:
+        m = dev_re.match(version)
+        if not m:
+            continue
+        n = int(m.group(1))
+        if best_dev is None or n > best_dev:
+            best_dev = n
+    next_n = 0 if best_dev is None else best_dev + 1
+    return f"{base_version}.dev{next_n}"
+
+
+def main() -> None:
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <main|develop|other>", file=sys.stderr)
+        sys.exit(1)
+
+    channel = sys.argv[1]
+    base_version = read_base_version()
+
+    if channel == "main":
+        published = fetch_published_versions()
+        version = next_main_version(base_version, published)
+    elif channel == "develop":
+        published = fetch_published_versions()
+        version = next_develop_version(base_version, published)
+    else:
+        version = base_version
+
+    print(version)
+
+
+if __name__ == "__main__":
+    main()

ibm5250-0.1.0/src/ibm5250/__init__.py

@@ -0,0 +1,96 @@
+"""ibm5250 — IBM 5250 terminal automation library.
+
+Typical usage::
+
+    from ibm5250 import Terminal, AID
+
+    with Terminal("as400.example.com") as t:
+        t.wait_for_text("Sign On")
+        t.fill_field("User", "MYUSER")
+        t.fill_field("Password", "SECRET")
+        t.send_key(AID.ENTER)
+        t.wait_for_text("Main Menu")
+        print(t.screen.get_screen_text())
+"""
+
+from .constants import (
+    AID,
+    Command,
+    Order,
+    TelnetCmd,
+    TelnetOpt,
+    FFW,
+    SCREEN_ROWS,
+    SCREEN_COLS,
+    encode_addr,
+    decode_addr,
+    pos_to_rowcol,
+    rowcol_to_pos,
+)
+from .connection import TN5250Connection
+from .datastream import (
+    DataStreamParser,
+    DSEvent,
+    DSEventType,
+    FieldResponse,
+    build_aid_response,
+    ebcdic_encode,
+    ebcdic_decode,
+    ebcdic_decode_stripped,
+)
+from .exceptions import (
+    IBM5250Error,
+    ConnectionError,
+    NegotiationError,
+    ProtocolError,
+    RecvTimeout,
+    ScreenWaitTimeout,
+    FieldNotFound,
+    KeyboardLocked,
+)
+from .screen import Field, Screen
+from .terminal import FieldProxy, Terminal
+
+__all__ = [
+    # High-level
+    "Terminal",
+    "FieldProxy",
+    # Screen / fields
+    "Screen",
+    "Field",
+    # Constants
+    "AID",
+    "Command",
+    "Order",
+    "TelnetCmd",
+    "TelnetOpt",
+    "FFW",
+    "SCREEN_ROWS",
+    "SCREEN_COLS",
+    # Address helpers
+    "encode_addr",
+    "decode_addr",
+    "pos_to_rowcol",
+    "rowcol_to_pos",
+    # Low-level
+    "TN5250Connection",
+    "DataStreamParser",
+    "DSEvent",
+    "DSEventType",
+    "FieldResponse",
+    "build_aid_response",
+    # EBCDIC helpers
+    "ebcdic_encode",
+    "ebcdic_decode",
+    "ebcdic_decode_stripped",
+    # Exceptions
+    "IBM5250Error",
+    "ConnectionError",
+    "NegotiationError",
+    "ProtocolError",
+    "ScreenWaitTimeout",
+    "FieldNotFound",
+    "KeyboardLocked",
+]
+
+__version__ = "0.1.0"