Metadata-Version: 2.4
Name: parmana
Version: 1.0.3
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

I agree. The PyPI page should have a \*\*purpose-built README\*\*, not the full project documentation.



Here's the structure I'd use for the \*\*official PyPI README\*\* (around 200 lines):



````markdown

\# 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)](https://github.com/pavancharak/parmana/blob/main/LICENSE)



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



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



\---



\## Why Parmana?



Modern AI systems can:



\- Plan

\- Reason

\- Call tools

\- Invoke APIs

\- Execute business workflows



However, they often cannot answer critical governance questions:



\- Who authorized this execution?

\- Which policy approved it?

\- Can this execution be independently verified?

\- Can it be replayed?

\- Is there cryptographic evidence of what occurred?



Parmana addresses these challenges by providing an execution trust layer for AI systems.



\---



\## 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 BusinessTransaction



client = ParmanaClient(

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

)



transaction = BusinessTransaction(

&#x20;   business\_transaction\_id="txn-001",

)



trust\_record = client.execute(transaction)



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

```



\---



\## Verify an Execution



```python

verification = client.verify(

&#x20;   "txn-001",

)



print(verification.status)

```



\---



\## Replay an Execution



```python

result = client.replay(

&#x20;   "txn-001",

)



print(result.success)

```



\---



\## Execution Lifecycle



```text

Business Transaction

&#x20;       |

&#x20;       v

Execution

&#x20;       |

&#x20;       v

Verification

&#x20;       |

&#x20;       v

Receipt

&#x20;       |

&#x20;       v

Execution Trust Record

```



\---



\## SDK APIs



| Method           | Description                        |

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

| `health()`       | Runtime health check               |

| `execute()`      | Execute a Business Transaction     |

| `verify()`       | Verify an execution                |

| `replay()`       | Replay a previous execution        |

| `receipt()`      | Retrieve an execution receipt      |

| `transaction()`  | Retrieve a Business Transaction    |

| `trust\_record()` | Retrieve an Execution Trust Record |



\---



\## Documentation



Documentation: \[https://docs.parmana.ai](https://docs.parmana.ai)



GitHub Repository: \[https://github.com/pavancharak/parmana](https://github.com/pavancharak/parmana)



Issue Tracker: \[https://github.com/pavancharak/parmana/issues](https://github.com/pavancharak/parmana/issues)



\---



\## License



Apache License 2.0



```



\### My recommendation for your documentation strategy



Keep the documentation layered:



\- \*\*PyPI README\*\* (this file): concise overview, installation, quick examples, and links.

\- \*\*GitHub README\*\*: richer developer guide with architecture and additional examples.

\- \*\*Mintlify documentation site\*\*: the complete reference for concepts, APIs, SDKs, architecture, tutorials, and contribution guides.



That approach gives PyPI users a clean first experience while keeping the comprehensive documentation where it belongs.

```



