pfc-client 0.1.0__tar.gz

pfc_client-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: pfc-client
+Version: 0.1.0
+Summary: Python SDK for Prime Form Calculus governance API
+Author: Dan Evans
+License: Proprietary
+Project-URL: Homepage, https://pfc-api.fly.dev
+Project-URL: Source, https://github.com/danlevans1/PFC
+Keywords: pfc,governance,ai,sdk,api
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+
+# PFC Python Client
+
+Example usage:
+
+```python
+from pfc_client import PFCClient, guarded_tool
+
+client = PFCClient(
+    api_url="https://pfc-api.fly.dev",
+    api_key="YOUR_API_KEY",
+)
+
+
+@guarded_tool(client)
+def deploy():
+    print("Deploying to production")
+
+
+deploy()
+```

pfc_client-0.1.0/README.md

@@ -0,0 +1,234 @@
+Core Positioning
+
+PFC determines whether an action should be permitted based on consequence, authority, irreversibility, and systemic stability. Execution-control systems enforce those permissions at runtime.
+
+Public architecture overview. Implementation and operational deployment require licensing.
+
+Public, non-commercial overview.
+
+Prime Form Calculus (PFC) defines 
+a governance layer for intelligent systems.
+
+This repository contains conceptual,
+architectural, and exploratory material
+intended for technical review and evaluation. 
+It is not a product, service, or solicitation.
+
+Any implementation or production use requires 
+a commercial license from the author.
+
+Read Full Spec: [PFC Specification v0.1](SPEC/PFC-v0.1.md)
+
+⸻
+
+Prime Form Calculus (PFC)
+
+A Governance Layer Between Intelligence and Action
+
+Artificial intelligence systems are rapidly moving 
+from generating information to taking real-world action.
+
+They diagnose conditions, recommend financial decisions,
+operate infrastructure, guide autonomous systems, and 
+influence regulatory and human outcomes.
+
+As systems transition from “answering questions” 
+to “exercising authority,” a new control boundary 
+becomes necessary.
+
+Not inside the model.
+Not after the output.
+But between intelligence and action.
+
+Most current approaches focus on alignment, 
+training, prompting, and moderation. These 
+improve surface behavior, but they do not 
+govern whether an intelligent system should 
+be allowed to act under real conditions.
+
+Over time, drift accumulates.
+Contradictions emerge.
+Operational authority expands beyond 
+verified boundaries.
+
+Systems can remain functional while 
+diverging from safe or intended operation.
+
+Prime Form Calculus (PFC) defines the 
+missing layer: a governance and stability 
+architecture that controls how intelligent 
+systems operate over time and whether 
+proposed actions are permitted.
+
+⸻
+
+What PFC Is
+
+PFC is a model-agnostic governance runtime
+designed to regulate operational authority, 
+state transitions, and system behavior.
+
+It does not improve model intelligence.
+It does not generate content.
+It does not replace existing AI systems.
+
+Instead, PFC governs whether an 
+intelligent system is allowed to act.
+
+Ordinary AI answers questions such as:
+
+What diagnosis to produce
+What trade to execute
+What route to choose
+
+PFC governs higher-order questions such as:
+
+Is the system authorized to perform this action
+Is the proposed state transition permitted 
+under current constraints
+Does the system remain inside its certified 
+operational envelope
+
+This establishes a control plane over 
+intelligence rather than inside it.
+
+⸻
+
+The Control Boundary
+
+PFC operates at the boundary between 
+model output and real-world authority.
+
+It governs:
+
+Whether outputs are permitted to influence 
+decisions Whether actions may be committed
+Whether operational transitions remain 
+within defined stability constraints
+
+Instead of filtering what a system says, 
+PFC governs what a system can do.
+
+This distinction becomes critical as 
+intelligent systems move into safety-critical 
+and regulated environments.
+
+⸻
+
+The Stability Kernel
+
+At the core of PFC is a continuously operating 
+closed-loop governance mechanism referred to 
+as the Stability Kernel.
+
+The Stability Kernel:
+
+Monitors system state continuously
+Evaluates proposed transitions against 
+stability and constraint criteria
+Controls which transitions may be committed
+Maintains operational integrity over time
+
+Because governance operates at runtime, 
+unsafe or unstable system regions become 
+dynamically unreachable rather than detected 
+after the fact.
+
+⸻
+
+Why This Layer Is Necessary
+
+Alignment, fine-tuning, and guardrails 
+address model behavior.
+
+They do not provide operational governance.
+
+As intelligent systems scale into real-world 
+environments, organizations require:
+
+Authority control
+Operational constraints
+Continuous assurance
+Audit-grade evidence
+Rollback and containment capability
+
+These needs define infrastructure, not features.
+
+PFC is designed to operate as 
+that infrastructure layer.
+
+⸻
+
+Evidence and Assurance
+
+PFC is designed to generate audit-grade, 
+machine-verifiable evidence of system 
+behavior by construction.
+
+This supports:
+
+Regulated deployment
+Post-incident analysis
+Continuous assurance requirements
+Operational accountability
+
+Rather than adding audit after deployment,
+governance is embedded into system operation.
+
+⸻
+
+Model-Agnostic Deployment
+
+PFC operates independently of 
+any specific model architecture.
+
+It can be deployed around:
+
+Cloud AI systems
+Enterprise decision platforms
+Autonomous systems
+Industrial and infrastructure environments
+Medical and financial systems
+
+PFC governs intelligent behavior 
+without retraining, modifying, or 
+accessing internal model parameters.
+
+⸻
+
+Position in the Stack
+
+PFC functions as governance infrastructure.
+
+Comparable roles in other domains include:
+
+Operating systems for computation
+Identity layers for access control
+API gateways for service interaction
+Control planes for distributed systems
+
+PFC provides a governance control plane 
+for intelligent systems.
+
+⸻
+
+Repository Scope
+
+This repository publishes conceptual 
+and architectural material related to the 
+Prime Form Calculus protocol for review
+and evaluation.
+
+It includes:
+
+Governance principles
+Control architecture concepts
+Runtime stability framing
+Evidence-generation approaches
+Compatibility with existing AI risk 
+and compliance frameworks
+
+Read Full Spec: [PFC Specification v0.1](SPEC/PFC-v0.1.md)
+
+Prime Flow Calculus Protocol, 
+Version 0.1 (Draft), 2026.

pfc_client-0.1.0/README_SDK.md

@@ -0,0 +1,20 @@
+# PFC Python Client
+
+Example usage:
+
+```python
+from pfc_client import PFCClient, guarded_tool
+
+client = PFCClient(
+    api_url="https://pfc-api.fly.dev",
+    api_key="YOUR_API_KEY",
+)
+
+
+@guarded_tool(client)
+def deploy():
+    print("Deploying to production")
+
+
+deploy()
+```

pfc_client-0.1.0/pfc_client/__init__.py

@@ -0,0 +1,4 @@
+from .client import PFCClient
+from .guard import guarded_tool
+
+__all__ = ["PFCClient", "guarded_tool"]

pfc_client-0.1.0/pfc_client/client.py

@@ -0,0 +1,50 @@
+import uuid
+
+import requests
+
+
+class PFCClient:
+    def __init__(self, api_url="https://pfc-api.fly.dev", api_key=None):
+        self.api_url = api_url.rstrip("/")
+        self.api_key = api_key
+
+    def evaluate(
+        self,
+        action,
+        subject=None,
+        resource=None,
+        policy=None,
+        context=None,
+        irreversible=True,
+    ):
+        payload = {
+            "request_id": str(uuid.uuid4()),
+            "action": action,
+            "subject": subject or {"type": "agent", "id": "default-agent"},
+            "resource": resource or {"type": "system", "id": "default"},
+            "proposed_execution": {"irreversible": irreversible},
+            "policy": policy or {"policy_id": "default-policy", "rules": {}},
+            "context": context or {"environment": "prod", "tenant_id": "default"},
+        }
+
+        r = requests.post(
+            f"{self.api_url}/v1/evaluate",
+            json=payload,
+            headers={
+                "Content-Type": "application/json",
+                "x-api-key": self.api_key,
+            },
+            timeout=10,
+        )
+
+        r.raise_for_status()
+        return r.json()
+
+    def verify(self, artifact, public_key_pem):
+        r = requests.post(
+            f"{self.api_url}/v1/verify",
+            json={"artifact": artifact, "public_key_pem": public_key_pem},
+            timeout=10,
+        )
+        r.raise_for_status()
+        return r.json()

pfc_client-0.1.0/pfc_client/guard.py

@@ -0,0 +1,22 @@
+from functools import wraps
+
+from .client import PFCClient
+
+
+def guarded_tool(client: PFCClient):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            decision = client.evaluate(
+                action=func.__name__,
+                resource={"type": "tool", "id": func.__name__},
+            )
+
+            if not decision.get("allow"):
+                raise RuntimeError(f"PFC blocked execution: {decision.get('reason')}")
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

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

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: pfc-client
+Version: 0.1.0
+Summary: Python SDK for Prime Form Calculus governance API
+Author: Dan Evans
+License: Proprietary
+Project-URL: Homepage, https://pfc-api.fly.dev
+Project-URL: Source, https://github.com/danlevans1/PFC
+Keywords: pfc,governance,ai,sdk,api
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+
+# PFC Python Client
+
+Example usage:
+
+```python
+from pfc_client import PFCClient, guarded_tool
+
+client = PFCClient(
+    api_url="https://pfc-api.fly.dev",
+    api_key="YOUR_API_KEY",
+)
+
+
+@guarded_tool(client)
+def deploy():
+    print("Deploying to production")
+
+
+deploy()
+```

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

@@ -0,0 +1,11 @@
+README.md
+README_SDK.md
+pyproject.toml
+pfc_client/__init__.py
+pfc_client/client.py
+pfc_client/guard.py
+pfc_client.egg-info/PKG-INFO
+pfc_client.egg-info/SOURCES.txt
+pfc_client.egg-info/dependency_links.txt
+pfc_client.egg-info/requires.txt
+pfc_client.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+requests>=2.28

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

@@ -0,0 +1 @@
+pfc_client

pfc_client-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel", "build"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pfc-client"
+version = "0.1.0"
+description = "Python SDK for Prime Form Calculus governance API"
+readme = "README_SDK.md"
+requires-python = ">=3.8"
+license = {text = "Proprietary"}
+authors = [
+  {name = "Dan Evans"}
+]
+dependencies = [
+  "requests>=2.28"
+]
+keywords = ["pfc", "governance", "ai", "sdk", "api"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries"
+]
+
+[project.urls]
+Homepage = "https://pfc-api.fly.dev"
+Source = "https://github.com/danlevans1/PFC"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["pfc_client*"]

pfc_client-0.1.0/setup.cfg

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