Metadata-Version: 2.4
Name: parmana
Version: 1.0.2
Summary: Official Python SDK for the Parmana Execution Trust Infrastructure.
Author: Parmana
License: Apache-2.0
Project-URL: Homepage, https://github.com/pavancharak/parmana
Project-URL: Documentation, https://github.com/pavancharak/parmana/tree/main/python
Project-URL: Repository, https://github.com/pavancharak/parmana
Project-URL: Issues, https://github.com/pavancharak/parmana/issues
Project-URL: Releases, https://github.com/pavancharak/parmana/releases
Keywords: ai,artificial-intelligence,autonomous-ai,agents,governance,authorization,execution,trust,policy,sdk
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Information Technology
Classifier: Topic :: Software Development
Classifier: Topic :: Security
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: License :: OSI Approved :: Apache Software License
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: Programming Language :: Python :: 3.14
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: requests>=2.32.0
Dynamic: license-file

\# Parmana



> \*\*Proof of Human Authority in AI Systems\*\*



\[!\[PyPI](https://img.shields.io/pypi/v/parmana)](https://pypi.org/project/parmana/)

\[!\[Python](https://img.shields.io/pypi/pyversions/parmana)](https://pypi.org/project/parmana/)

\[!\[License](https://img.shields.io/pypi/l/parmana)](LICENSE)



The official Python SDK for the \*\*Parmana Execution Trust Infrastructure\*\*.



Parmana enables organizations to confidently deploy AI in high-impact workflows by ensuring that \*\*only authorized actions are executed\*\* and every execution is accompanied by cryptographically verifiable evidence.



\---



\# Why Parmana?



Modern AI systems can:



\- plan

\- reason

\- call tools

\- invoke APIs

\- execute business workflows



But most AI systems cannot answer fundamental governance questions:



\- Who authorized this execution?

\- Which policy approved it?

\- Was the execution verified?

\- Can it be replayed?

\- Can it be independently audited?

\- Can compliance teams prove what happened?



Parmana solves this problem.



\---



\# Core Principle



\*\*AI can propose actions.\*\*



\*\*Parmana authorizes execution.\*\*



Only Parmana-approved actions are executed.



\---



\# Features



\- Human Authority

\- Execution Authorization

\- Policy Validation

\- Business Transactions

\- Verification

\- Execution Trust Records

\- Cryptographic Receipts

\- Deterministic Replay

\- Audit Evidence

\- Python SDK

\- REST API

\- TypeScript SDK



\---



\# Installation



```bash

pip install parmana

```



\---



\# Requirements



\- Python 3.10+

\- Parmana Runtime



\---



\# Quick Start



```python

from parmana import ParmanaClient



client = ParmanaClient(

&#x20;   endpoint="http://localhost:3000",

)



print(client.version)

```



\---



\# Runtime Health



```python

status = client.health()



print(status)

```



\---



\# Execute a Business Transaction



```python

from parmana import ParmanaClient

from parmana.models import \*



client = ParmanaClient(

&#x20;   endpoint="http://localhost:3000",

)



transaction = BusinessTransaction(

&#x20;   ...

)



trust\_record = client.execute(transaction)



print(trust\_record.trust\_record\_id)

```



\---



\# Verify an Execution



```python

verification = client.verify(

&#x20;   business\_transaction\_id,

)



print(verification.status)

```



\---



\# Replay an Execution



```python

result = client.replay(

&#x20;   business\_transaction\_id,

)



print(result.success)

```



\---



\# Generate a Receipt



```python

receipt = client.receipt(

&#x20;   business\_transaction\_id,

)



print(receipt.receipt\_hash)

```



\---



\# Retrieve a Business Transaction



```python

transaction = client.transaction(

&#x20;   business\_transaction\_id,

)

```



\---



\# Retrieve an Execution Trust Record



```python

trust\_record = client.trust\_record(

&#x20;   business\_transaction\_id,

)

```



\---



\# Execution Lifecycle



```text

Business Transaction

&#x20;       │

&#x20;       ▼

Execution

&#x20;       │

&#x20;       ▼

Verification

&#x20;       │

&#x20;       ▼

Receipt

&#x20;       │

&#x20;       ▼

Execution Trust Record

```



\---



\# Core Concepts



\## Authority



Represents the human or system authority responsible for authorizing execution.



\---



\## Authorization



Represents permission granted by an Authority.



\---



\## Intent



Represents the requested business action.



\---



\## Policy



Represents the versioned policy evaluated by the Runtime.



\---



\## Business Transaction



The canonical execution request submitted to the Runtime.



\---



\## Decision



Policy evaluation result.



\---



\## Execution



Represents the performed execution.



\---



\## Verification



Independent verification produced by the Runtime.



\---



\## Receipt



Cryptographic proof of execution.



\---



\## Execution Trust Record



The canonical execution artifact containing:



\- Business Transaction

\- Executions

\- Verifications

\- Receipts

\- Trust Hash



\---



\# Architecture



```text

Application

&#x20;     │

&#x20;     ▼

&#x20;Python SDK

&#x20;     │

&#x20;REST API

&#x20;     │

&#x20;Parmana Runtime

&#x20;     │

&#x20;├── Policy Engine

&#x20;├── Verification

&#x20;├── Replay

&#x20;├── Receipt

&#x20;├── Storage

&#x20;└── Crypto

```



\---



\# Public APIs



The SDK provides:



| API | Purpose |

|------|----------|

| Health | Runtime health |

| Execute | Execute Business Transactions |

| Verify | Verify executions |

| Replay | Deterministic replay |

| Receipt | Generate receipts |

| Transaction | Retrieve Business Transactions |

| Trust Record | Retrieve Execution Trust Records |

| Policy | Validate policies |



\---



\# Error Handling



Example:



```python

from parmana.errors import NetworkError



try:

&#x20;   client.health()



except NetworkError:

&#x20;   print("Runtime unavailable")

```



\---



\# Deterministic Replay



Replay enables independent verification that an execution can be reproduced using the recorded execution evidence.



Replay never changes execution history.



\---



\# Security



Parmana provides:



\- Human authorization

\- Versioned policies

\- Cryptographic receipts

\- Replayable execution

\- Tamper-evident trust records

\- Audit evidence



\---



\# Documentation



Documentation:



https://docs.parmana.ai



\---



\# Repository



GitHub:



https://github.com/pavancharak/parmana



\---



\# Issues



https://github.com/pavancharak/parmana/issues



\---



\# Contributing



Issues and pull requests are welcome.



Please ensure:



\- Tests pass

\- Documentation is updated

\- Public APIs remain backward compatible



\---



\# License



Apache License 2.0



\---



\# Learn More



\- Documentation

\- Runtime

\- REST API

\- Python SDK

\- TypeScript SDK

\- Examples

\- Architecture

\- Verification

\- Replay

\- Execution Trust Records



\---



\*\*Parmana\*\*



\*\*Proof of Human Authority in AI Systems\*\*

