protocol-governed-computing 2.0.0__tar.gz

protocol_governed_computing-2.0.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: protocol-governed-computing
+Version: 2.0.0
+Summary: Protocol-Governed Computing — installs the full toolchain and reports whether an environment is ready to compile, seal, and execute
+Author-email: Bhash Ganti <bachipeachy@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://omnibachi.org/
+Project-URL: Repository, https://github.com/protocol-governed-computing
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,governance,authorization,sdlc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pgc-compiler==2.0.0
+Requires-Dist: pgc-assembler==2.0.1
+Requires-Dist: pgc-runtime==2.0.1
+Requires-Dist: pgc-inspector==2.0.0
+Requires-Dist: pgc-transformation==2.0.0
+Requires-Dist: pgc-governance==2.0.0
+Requires-Dist: pgc-workloads==2.0.0
+Requires-Dist: pgc-domains==2.0.1
+Provides-Extra: blockchain
+Requires-Dist: pgc-domains[blockchain]==2.0.1; extra == "blockchain"
+
+# pgc_install
+
+**Protocol-Governed Computing — the whole toolchain in one install.**
+
+This repository publishes the `pgc` distribution. It is the composition as *installable
+software*, the counterpart to `pgc_release`, which is the same composition as *sealed
+evidence* — assembled, immutable, and cited by DOI. The parallel is in role, not in citation:
+a release is a thing a paper points at; an install is a thing that changes each version.
+
+```bash
+pip install pgc
+```
+
+That brings in the seven packages of the family, pinned to one composition.
+
+## Two steps, not one
+
+Installing the toolchain is half of a working environment. The compiler resolves the
+governance surface from `PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero
+inference — so the **declarations come from a repository you point at, not from a
+wheel**. A registry inside a package would be a second governance surface competing
+with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+## The family
+
+| Package | Role |
+|---|---|
+| `pgc-compiler` | declarations → compiled projections |
+| `pgc-assembler` | projections → sealed snapshot |
+| `pgc-runtime` | snapshot → governed execution |
+| `pgc-inspector` | snapshot → read-only inspection |
+| `pgc-transformation` | change request → protocol artifacts |
+| `pgc-governance` | the governance surface and its capability implementations |
+| `pgc-workloads` | the workloads that make conformance observable |
+| `pgc-domains` | the business domain implementations the composed snapshot binds |
+
+**Versioning.** Two schemes. Each repository's `VERSION` is a monotonic composition ordinal —
+internal build accounting, tagged `release-<N>`, never published. `PUBLIC_VERSION` is the platform's
+public identity, tagged on every component repository; the platform is at **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The family releases in lockstep, so `pgc`
+pins exact versions rather than ranges. The standard these packages implement is a separate artifact on
+its own track and is not this number.
+
+The standard these packages implement is published separately:
+https://doi.org/10.5281/zenodo.22150616

protocol_governed_computing-2.0.0/README.md

@@ -0,0 +1,52 @@
+# pgc_install
+
+**Protocol-Governed Computing — the whole toolchain in one install.**
+
+This repository publishes the `pgc` distribution. It is the composition as *installable
+software*, the counterpart to `pgc_release`, which is the same composition as *sealed
+evidence* — assembled, immutable, and cited by DOI. The parallel is in role, not in citation:
+a release is a thing a paper points at; an install is a thing that changes each version.
+
+```bash
+pip install pgc
+```
+
+That brings in the seven packages of the family, pinned to one composition.
+
+## Two steps, not one
+
+Installing the toolchain is half of a working environment. The compiler resolves the
+governance surface from `PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero
+inference — so the **declarations come from a repository you point at, not from a
+wheel**. A registry inside a package would be a second governance surface competing
+with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+## The family
+
+| Package | Role |
+|---|---|
+| `pgc-compiler` | declarations → compiled projections |
+| `pgc-assembler` | projections → sealed snapshot |
+| `pgc-runtime` | snapshot → governed execution |
+| `pgc-inspector` | snapshot → read-only inspection |
+| `pgc-transformation` | change request → protocol artifacts |
+| `pgc-governance` | the governance surface and its capability implementations |
+| `pgc-workloads` | the workloads that make conformance observable |
+| `pgc-domains` | the business domain implementations the composed snapshot binds |
+
+**Versioning.** Two schemes. Each repository's `VERSION` is a monotonic composition ordinal —
+internal build accounting, tagged `release-<N>`, never published. `PUBLIC_VERSION` is the platform's
+public identity, tagged on every component repository; the platform is at **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The family releases in lockstep, so `pgc`
+pins exact versions rather than ranges. The standard these packages implement is a separate artifact on
+its own track and is not this number.
+
+The standard these packages implement is published separately:
+https://doi.org/10.5281/zenodo.22150616

protocol_governed_computing-2.0.0/pgc/__init__.py

@@ -0,0 +1,2 @@
+"""Protocol-Governed Computing — the installed toolchain."""
+__all__ = ["cli"]

protocol_governed_computing-2.0.0/pgc/cli.py

@@ -0,0 +1,99 @@
+"""`pgc` — report what is installed and whether this environment can build.
+
+Installing the toolchain is one of two steps. The compiler resolves the
+governance surface from PGC_PLATFORM_ROOT rather than from a bundled copy —
+fail-hard, cwd-independent, zero inference — so the declarations come from a
+repository the operator points at, not from a wheel. A registry inside a wheel
+would be a second governance surface competing with the repository's.
+
+This command reports both halves so the gap is visible before a build fails.
+"""
+from __future__ import annotations
+
+import importlib.metadata as md
+import os
+import sys
+from pathlib import Path
+
+FAMILY = [
+    ("pgc-compiler", "declarations → compiled projections"),
+    ("pgc-assembler", "projections → sealed snapshot"),
+    ("pgc-runtime", "snapshot → governed execution"),
+    ("pgc-inspector", "snapshot → read-only inspection"),
+    ("pgc-transformation", "change request → protocol artifacts"),
+    ("pgc-governance", "governance surface implementations"),
+    ("pgc-workloads", "conformance workload implementations"),
+    ("pgc-domains", "business domain implementations"),
+]
+
+STANDARD = "https://doi.org/10.5281/zenodo.22150616"
+
+
+def _installed() -> list[tuple[str, str, str]]:
+    rows = []
+    for dist, role in FAMILY:
+        try:
+            rows.append((dist, md.version(dist), role))
+        except md.PackageNotFoundError:
+            rows.append((dist, "-", role))
+    return rows
+
+
+def _environment() -> list[tuple[str, str, bool]]:
+    """The anchors the toolchain reads. Absent is not an error here — it is a fact."""
+    checks = []
+    root = os.environ.get("PGC_PLATFORM_ROOT")
+    if not root:
+        checks.append(("PGC_PLATFORM_ROOT", "not set", False))
+    else:
+        p = Path(root).expanduser()
+        ok = (p / "registry").is_dir()
+        checks.append(("PGC_PLATFORM_ROOT", f"{p}{'' if ok else '  (no registry/ here)'}", ok))
+    for name in ("PGC_BUILD_ROOT", "PGC_DOMAIN_ROOTS"):
+        v = os.environ.get(name)
+        checks.append((name, v or "not set (optional)", True))
+    return checks
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+    if argv and argv[0] not in ("status", "-h", "--help"):
+        print(f"pgc: unknown command {argv[0]!r}", file=sys.stderr)
+        return 2
+    if argv and argv[0] in ("-h", "--help"):
+        print(__doc__.strip())
+        return 0
+
+    print("Protocol-Governed Computing\n")
+    print("  toolchain")
+    missing = 0
+    for dist, ver, role in _installed():
+        if ver == "-":
+            missing += 1
+        print(f"    {dist:<20} {ver:<8} {role}")
+
+    print("\n  environment")
+    ready = True
+    for name, value, ok in _environment():
+        if not ok:
+            ready = False
+        print(f"    {name:<20} {value}")
+
+    print()
+    if missing:
+        print(f"  {missing} package(s) not installed — `pip install pgc` installs the family.")
+    if not ready:
+        print("  PGC_PLATFORM_ROOT must point at a governance repository (the directory")
+        print("  containing registry/). The declarations are not shipped in any wheel:")
+        print("  the compiler resolves them from this anchor, so one governance surface")
+        print("  governs a build rather than a wheel's stale copy competing with a repo.")
+        print("\n    git clone https://github.com/protocol-governed-computing/software_governance")
+        print("    export PGC_PLATFORM_ROOT=$PWD/software_governance")
+    if not missing and ready:
+        print("  Ready: toolchain installed and a governance surface is anchored.")
+    print(f"\n  standard: {STANDARD}")
+    return 0 if (ready and not missing) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

protocol_governed_computing-2.0.0/protocol_governed_computing.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: protocol-governed-computing
+Version: 2.0.0
+Summary: Protocol-Governed Computing — installs the full toolchain and reports whether an environment is ready to compile, seal, and execute
+Author-email: Bhash Ganti <bachipeachy@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://omnibachi.org/
+Project-URL: Repository, https://github.com/protocol-governed-computing
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,governance,authorization,sdlc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pgc-compiler==2.0.0
+Requires-Dist: pgc-assembler==2.0.1
+Requires-Dist: pgc-runtime==2.0.1
+Requires-Dist: pgc-inspector==2.0.0
+Requires-Dist: pgc-transformation==2.0.0
+Requires-Dist: pgc-governance==2.0.0
+Requires-Dist: pgc-workloads==2.0.0
+Requires-Dist: pgc-domains==2.0.1
+Provides-Extra: blockchain
+Requires-Dist: pgc-domains[blockchain]==2.0.1; extra == "blockchain"
+
+# pgc_install
+
+**Protocol-Governed Computing — the whole toolchain in one install.**
+
+This repository publishes the `pgc` distribution. It is the composition as *installable
+software*, the counterpart to `pgc_release`, which is the same composition as *sealed
+evidence* — assembled, immutable, and cited by DOI. The parallel is in role, not in citation:
+a release is a thing a paper points at; an install is a thing that changes each version.
+
+```bash
+pip install pgc
+```
+
+That brings in the seven packages of the family, pinned to one composition.
+
+## Two steps, not one
+
+Installing the toolchain is half of a working environment. The compiler resolves the
+governance surface from `PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero
+inference — so the **declarations come from a repository you point at, not from a
+wheel**. A registry inside a package would be a second governance surface competing
+with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+## The family
+
+| Package | Role |
+|---|---|
+| `pgc-compiler` | declarations → compiled projections |
+| `pgc-assembler` | projections → sealed snapshot |
+| `pgc-runtime` | snapshot → governed execution |
+| `pgc-inspector` | snapshot → read-only inspection |
+| `pgc-transformation` | change request → protocol artifacts |
+| `pgc-governance` | the governance surface and its capability implementations |
+| `pgc-workloads` | the workloads that make conformance observable |
+| `pgc-domains` | the business domain implementations the composed snapshot binds |
+
+**Versioning.** Two schemes. Each repository's `VERSION` is a monotonic composition ordinal —
+internal build accounting, tagged `release-<N>`, never published. `PUBLIC_VERSION` is the platform's
+public identity, tagged on every component repository; the platform is at **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The family releases in lockstep, so `pgc`
+pins exact versions rather than ranges. The standard these packages implement is a separate artifact on
+its own track and is not this number.
+
+The standard these packages implement is published separately:
+https://doi.org/10.5281/zenodo.22150616

protocol_governed_computing-2.0.0/protocol_governed_computing.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+pgc/__init__.py
+pgc/cli.py
+protocol_governed_computing.egg-info/PKG-INFO
+protocol_governed_computing.egg-info/SOURCES.txt
+protocol_governed_computing.egg-info/dependency_links.txt
+protocol_governed_computing.egg-info/entry_points.txt
+protocol_governed_computing.egg-info/requires.txt
+protocol_governed_computing.egg-info/top_level.txt

protocol_governed_computing-2.0.0/protocol_governed_computing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

protocol_governed_computing-2.0.0/protocol_governed_computing.egg-info/entry_points.txt

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

protocol_governed_computing-2.0.0/protocol_governed_computing.egg-info/requires.txt

@@ -0,0 +1,11 @@
+pgc-compiler==2.0.0
+pgc-assembler==2.0.1
+pgc-runtime==2.0.1
+pgc-inspector==2.0.0
+pgc-transformation==2.0.0
+pgc-governance==2.0.0
+pgc-workloads==2.0.0
+pgc-domains==2.0.1
+
+[blockchain]
+pgc-domains[blockchain]==2.0.1

protocol_governed_computing-2.0.0/protocol_governed_computing.egg-info/top_level.txt

@@ -0,0 +1 @@
+pgc

protocol_governed_computing-2.0.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# PyPI prohibits the distribution name `pgc` outright ("The name 'pgc' isn't allowed"), so the
+# composition takes the full project name. The import package and the console script are unaffected:
+# a user still runs `pgc`.
+name = "protocol-governed-computing"
+version = "2.0.0"
+description = "Protocol-Governed Computing — installs the full toolchain and reports whether an environment is ready to compile, seal, and execute"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+authors = [{ name = "Bhash Ganti", email = "bachipeachy@gmail.com" }]
+
+keywords = ["protocol-governed-computing", "pgc", "governance", "authorization", "sdlc"]
+
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Compilers",
+]
+
+# The whole family, pinned to one composition. PGC versions the composition:
+# the repos release together and the governance closure forces lockstep, so a
+# mixed-version install is not a supported configuration.
+dependencies = [
+  "pgc-compiler==2.0.0",
+  "pgc-assembler==2.0.1",
+  "pgc-runtime==2.0.1",
+  "pgc-inspector==2.0.0",
+  "pgc-transformation==2.0.0",
+  "pgc-governance==2.0.0",
+  "pgc-workloads==2.0.0",
+  "pgc-domains==2.0.1",
+]
+
+# The blockchain domain's capability transforms need Keccak-256, which is optional in pgc-domains
+# for the same reason it is optional there: the core compile path imports none of it.
+[project.optional-dependencies]
+blockchain = ["pgc-domains[blockchain]==2.0.1"]
+
+[project.scripts]
+pgc = "pgc.cli:main"
+
+[project.urls]
+Homepage = "https://omnibachi.org/"
+Repository = "https://github.com/protocol-governed-computing"
+Standard = "https://doi.org/10.5281/zenodo.22150616"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pgc*"]

protocol_governed_computing-2.0.0/setup.cfg

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