libpetri 2.6.0__tar.gz

libpetri-2.6.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: libpetri
+Version: 2.6.0
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Typing :: Typed
+Requires-Dist: maturin>=1.8,<2 ; extra == 'dev'
+Requires-Dist: pytest>=8.3 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24 ; extra == 'dev'
+Requires-Dist: pytest-benchmark>=5.0 ; extra == 'dev'
+Provides-Extra: dev
+Summary: Python bindings for libpetri
+Keywords: petri-net,workflow,verification,graphviz,python
+Home-Page: https://libpetri.org
+Author: Dennis Berger
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# libpetri
+
+[![PyPI](https://img.shields.io/pypi/v/libpetri)](https://pypi.org/project/libpetri/)
+[![Python](https://img.shields.io/pypi/pyversions/libpetri)](https://pypi.org/project/libpetri/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](https://github.com/libpetri/libpetri/blob/main/LICENSE)
+
+**Python bindings for the libpetri Coloured Time Petri Net engine.**
+
+Compose typed Petri nets in Python, run them on the Rust executor through PyO3.
+Full surface parity with the Java, TypeScript, and Rust implementations — same
+arc types, timing modes, composition primitives, formal-verification API,
+debug protocol, and DOT export.
+
+## Install
+
+```bash
+pip install libpetri
+```
+
+Wheels are published for CPython 3.11, 3.12, 3.13 on Linux / macOS / Windows
+(x86-64 and arm64).
+
+## Quick example
+
+```python
+import libpetri as lp
+
+request  = lp.Place("Request")
+response = lp.Place("Response")
+
+def process(ctx: lp.TransitionContext) -> None:
+    req = ctx.input("Request")
+    ctx.output("Response", f"Processed: {req}")
+
+net = (
+    lp.Net("Example")
+    .transition(
+        lp.Transition("Process")
+        .input(lp.one(request))
+        .output(lp.out(response))
+        .timing(lp.deadline(5000))
+        .action(process)
+        .build()
+    )
+    .build()
+)
+
+result = lp.run_sync(net, initial={request: ["hello"]})
+print(result.first(response))  # → "Processed: hello"
+```
+
+Async callbacks work the same way; `lp.run_async` drives `async def` actions
+on tokio, releasing the GIL between awaits:
+
+```python
+import asyncio, libpetri as lp
+
+async def main() -> None:
+    incoming = lp.Place("incoming")
+    approved = lp.Place("approved")
+
+    async def approve(ctx: lp.TransitionContext) -> None:
+        order = ctx.input("incoming")
+        await asyncio.sleep(0)  # any awaitable works
+        ctx.output("approved", {**order, "approved": True})
+
+    net = (
+        lp.Net("orders")
+        .transition(
+            lp.Transition("approve")
+            .input(lp.one(incoming))
+            .output(lp.out(approved))
+            .action(approve)
+            .build()
+        )
+        .build()
+    )
+
+    result = await lp.run_async(net, initial={incoming: [{"id": 1}]})
+    print(result.first(approved))  # → {'id': 1, 'approved': True}
+
+asyncio.run(main())
+```
+
+## What you get
+
+- **Full runtime** — sync + async execution, environment-place injection, all
+  five arc kinds (input / output / inhibitor / read / reset), all five timing
+  modes, priority + FIFO scheduling.
+- **Composition** — `SubnetDef` with typed ports + channels, `compose(...)`
+  via structural rewrite, port bindings, instance prefixes.
+- **Formal verification** — SMT/IC3 properties (deadlock-free, mutual
+  exclusion, place bound, unreachable) through Z3 when the wheel ships with
+  the `z3` system library available.
+- **Debug protocol** — same JSON wire format as the Java / TypeScript
+  implementations; pair with the libpetri debug-ui for live inspection.
+- **DOT / Graphviz export** — `lp.dot_export(net)`.
+- **Typed and IDE-friendly** — ships with `.pyi` stubs and `py.typed`; IDE
+  autocomplete and `mypy --strict` work out of the box.
+
+## A note on token typing
+
+The Java, TypeScript, and Rust implementations enforce `Place[T]` at compile
+time. The Python binding stores tokens as `Py<PyAny>` across the FFI boundary
+— net *structure* (arcs, transitions, composition) is still validated, but
+token *runtime types* are not. A place named `"order"` will accept dicts,
+integers, or strings interchangeably. This is intentional: Python has no
+static generics across the FFI. Validate at your boundary (Pydantic,
+dataclasses, `isinstance`) and only put validated values into markings.
+
+## Links
+
+- [Source / specification / sibling implementations](https://github.com/libpetri/libpetri)
+- [Spec (183 requirements, 11 files)](https://github.com/libpetri/libpetri/tree/main/spec)
+- [CHANGELOG](https://github.com/libpetri/libpetri/blob/main/CHANGELOG.md)
+- [Benchmarks](https://github.com/libpetri/libpetri/tree/main/python/benches)
+
+[Apache License 2.0](https://github.com/libpetri/libpetri/blob/main/LICENSE)
+

libpetri-2.6.0/README.md

@@ -0,0 +1,118 @@
+# libpetri
+
+[![PyPI](https://img.shields.io/pypi/v/libpetri)](https://pypi.org/project/libpetri/)
+[![Python](https://img.shields.io/pypi/pyversions/libpetri)](https://pypi.org/project/libpetri/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](https://github.com/libpetri/libpetri/blob/main/LICENSE)
+
+**Python bindings for the libpetri Coloured Time Petri Net engine.**
+
+Compose typed Petri nets in Python, run them on the Rust executor through PyO3.
+Full surface parity with the Java, TypeScript, and Rust implementations — same
+arc types, timing modes, composition primitives, formal-verification API,
+debug protocol, and DOT export.
+
+## Install
+
+```bash
+pip install libpetri
+```
+
+Wheels are published for CPython 3.11, 3.12, 3.13 on Linux / macOS / Windows
+(x86-64 and arm64).
+
+## Quick example
+
+```python
+import libpetri as lp
+
+request  = lp.Place("Request")
+response = lp.Place("Response")
+
+def process(ctx: lp.TransitionContext) -> None:
+    req = ctx.input("Request")
+    ctx.output("Response", f"Processed: {req}")
+
+net = (
+    lp.Net("Example")
+    .transition(
+        lp.Transition("Process")
+        .input(lp.one(request))
+        .output(lp.out(response))
+        .timing(lp.deadline(5000))
+        .action(process)
+        .build()
+    )
+    .build()
+)
+
+result = lp.run_sync(net, initial={request: ["hello"]})
+print(result.first(response))  # → "Processed: hello"
+```
+
+Async callbacks work the same way; `lp.run_async` drives `async def` actions
+on tokio, releasing the GIL between awaits:
+
+```python
+import asyncio, libpetri as lp
+
+async def main() -> None:
+    incoming = lp.Place("incoming")
+    approved = lp.Place("approved")
+
+    async def approve(ctx: lp.TransitionContext) -> None:
+        order = ctx.input("incoming")
+        await asyncio.sleep(0)  # any awaitable works
+        ctx.output("approved", {**order, "approved": True})
+
+    net = (
+        lp.Net("orders")
+        .transition(
+            lp.Transition("approve")
+            .input(lp.one(incoming))
+            .output(lp.out(approved))
+            .action(approve)
+            .build()
+        )
+        .build()
+    )
+
+    result = await lp.run_async(net, initial={incoming: [{"id": 1}]})
+    print(result.first(approved))  # → {'id': 1, 'approved': True}
+
+asyncio.run(main())
+```
+
+## What you get
+
+- **Full runtime** — sync + async execution, environment-place injection, all
+  five arc kinds (input / output / inhibitor / read / reset), all five timing
+  modes, priority + FIFO scheduling.
+- **Composition** — `SubnetDef` with typed ports + channels, `compose(...)`
+  via structural rewrite, port bindings, instance prefixes.
+- **Formal verification** — SMT/IC3 properties (deadlock-free, mutual
+  exclusion, place bound, unreachable) through Z3 when the wheel ships with
+  the `z3` system library available.
+- **Debug protocol** — same JSON wire format as the Java / TypeScript
+  implementations; pair with the libpetri debug-ui for live inspection.
+- **DOT / Graphviz export** — `lp.dot_export(net)`.
+- **Typed and IDE-friendly** — ships with `.pyi` stubs and `py.typed`; IDE
+  autocomplete and `mypy --strict` work out of the box.
+
+## A note on token typing
+
+The Java, TypeScript, and Rust implementations enforce `Place[T]` at compile
+time. The Python binding stores tokens as `Py<PyAny>` across the FFI boundary
+— net *structure* (arcs, transitions, composition) is still validated, but
+token *runtime types* are not. A place named `"order"` will accept dicts,
+integers, or strings interchangeably. This is intentional: Python has no
+static generics across the FFI. Validate at your boundary (Pydantic,
+dataclasses, `isinstance`) and only put validated values into markings.
+
+## Links
+
+- [Source / specification / sibling implementations](https://github.com/libpetri/libpetri)
+- [Spec (183 requirements, 11 files)](https://github.com/libpetri/libpetri/tree/main/spec)
+- [CHANGELOG](https://github.com/libpetri/libpetri/blob/main/CHANGELOG.md)
+- [Benchmarks](https://github.com/libpetri/libpetri/tree/main/python/benches)
+
+[Apache License 2.0](https://github.com/libpetri/libpetri/blob/main/LICENSE)

libpetri-2.6.0/libpetri/__init__.py

@@ -0,0 +1,180 @@
+"""libpetri — Python bindings for the Rust Coloured Time Petri Net engine.
+
+Note on token typing: the Java, TypeScript, and Rust implementations enforce
+``Place[T]`` token types at compile time. The Python binding stores tokens as
+``Py<PyAny>`` across the FFI boundary — net *structure* (arcs, transitions,
+composition) is still validated, but token *runtime types* are not. A place
+named ``"order"`` will accept dicts, integers, or strings interchangeably.
+This is intentional: Python has no static generics across the FFI. If you need
+type discipline, validate at your boundary (Pydantic, dataclasses, ``isinstance``)
+and only put validated values into markings.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from . import _libpetri
+from .debug import DebugProtocolHandler, SessionSummary, require_debug
+from .export import DotConfig, RankDir, dot_export
+from .model import (
+    BuiltNet,
+    BuiltSubnetDef,
+    BuiltTransition,
+    BuiltinAction,
+    Channel,
+    fork,
+    passthrough,
+    InputSpec,
+    Instance,
+    InhibitorArc,
+    Net,
+    NetBuilder,
+    OutputSpec,
+    Place,
+    Port,
+    ReadArc,
+    ResetArc,
+    SubnetDef,
+    SubnetDefBuilder,
+    SubnetInstance,
+    Timing,
+    Transition,
+    TransitionBuilder,
+    TransitionContext,
+    all_tokens,
+    and_,
+    and_outputs,
+    at_least,
+    deadline,
+    delayed,
+    exact,
+    exactly,
+    forward_input,
+    immediate,
+    inhibitor,
+    one,
+    out,
+    out_place,
+    read,
+    reset,
+    timeout,
+    window,
+    xor,
+    xor_outputs,
+)
+from .runtime import (
+    CompiledNet,
+    ExecutorHandle,
+    ExecutorOptions,
+    MarkingView,
+    compile,
+    run_async,
+    run_sync,
+    start_async,
+)
+from .verification import (
+    PropertyResult,
+    SmtProperty,
+    SubnetVerificationResult,
+    VerificationHarness,
+    VerificationResult,
+    deadlock_free,
+    mutual_exclusion,
+    place_bound,
+    unreachable,
+    verify,
+    verify_subnet,
+)
+
+CallbackError = _libpetri.CallbackError
+LibpetriError = _libpetri.LibpetriError
+StructureError = _libpetri.StructureError
+
+HAS_TOKIO = bool(_libpetri.HAS_TOKIO)
+HAS_Z3 = bool(_libpetri.HAS_Z3)
+HAS_DEBUG = bool(_libpetri.HAS_DEBUG)
+
+try:
+    __version__ = version("libpetri")
+except PackageNotFoundError:
+    __version__ = "0+local"
+
+__all__ = [
+    "__version__",
+    "BuiltinAction",
+    "CallbackError",
+    "Channel",
+    "fork",
+    "passthrough",
+    "CompiledNet",
+    "DebugProtocolHandler",
+    "DotConfig",
+    "ExecutorHandle",
+    "ExecutorOptions",
+    "HAS_DEBUG",
+    "HAS_TOKIO",
+    "HAS_Z3",
+    "InputSpec",
+    "InhibitorArc",
+    "Instance",
+    "LibpetriError",
+    "MarkingView",
+    "Net",
+    "NetBuilder",
+    "OutputSpec",
+    "Place",
+    "Port",
+    "PropertyResult",
+    "RankDir",
+    "ReadArc",
+    "ResetArc",
+    "SessionSummary",
+    "SmtProperty",
+    "StructureError",
+    "SubnetDef",
+    "SubnetDefBuilder",
+    "SubnetInstance",
+    "SubnetVerificationResult",
+    "Timing",
+    "Transition",
+    "TransitionBuilder",
+    "TransitionContext",
+    "VerificationHarness",
+    "VerificationResult",
+    "all_tokens",
+    "and_",
+    "and_outputs",
+    "at_least",
+    "compile",
+    "deadlock_free",
+    "deadline",
+    "delayed",
+    "dot_export",
+    "exact",
+    "exactly",
+    "forward_input",
+    "immediate",
+    "inhibitor",
+    "mutual_exclusion",
+    "one",
+    "out",
+    "out_place",
+    "place_bound",
+    "read",
+    "require_debug",
+    "reset",
+    "run_async",
+    "run_sync",
+    "start_async",
+    "timeout",
+    "unreachable",
+    "verify",
+    "verify_subnet",
+    "window",
+    "xor",
+    "xor_outputs",
+    "BuiltNet",
+    "BuiltSubnetDef",
+    "BuiltTransition",
+]

libpetri-2.6.0/libpetri/__init__.pyi

@@ -0,0 +1,94 @@
+"""Type stubs for the libpetri public surface."""
+
+from __future__ import annotations
+
+from . import _libpetri
+from .debug import (
+    DebugProtocolHandler as DebugProtocolHandler,
+    SessionSummary as SessionSummary,
+    require_debug as require_debug,
+)
+from .export import (
+    DotConfig as DotConfig,
+    RankDir as RankDir,
+    dot_export as dot_export,
+)
+from .model import (
+    BuiltNet as BuiltNet,
+    BuiltSubnetDef as BuiltSubnetDef,
+    BuiltTransition as BuiltTransition,
+    BuiltinAction as BuiltinAction,
+    Channel as Channel,
+    InhibitorArc as InhibitorArc,
+    InputSpec as InputSpec,
+    Instance as Instance,
+    Net as Net,
+    NetBuilder as NetBuilder,
+    OutputSpec as OutputSpec,
+    Place as Place,
+    PlaceLike as PlaceLike,
+    Port as Port,
+    ReadArc as ReadArc,
+    ResetArc as ResetArc,
+    SubnetDef as SubnetDef,
+    SubnetDefBuilder as SubnetDefBuilder,
+    SubnetInstance as SubnetInstance,
+    Timing as Timing,
+    Transition as Transition,
+    TransitionBuilder as TransitionBuilder,
+    TransitionContext as TransitionContext,
+    all_tokens as all_tokens,
+    and_ as and_,
+    and_outputs as and_outputs,
+    at_least as at_least,
+    deadline as deadline,
+    delayed as delayed,
+    exact as exact,
+    exactly as exactly,
+    fork as fork,
+    forward_input as forward_input,
+    immediate as immediate,
+    inhibitor as inhibitor,
+    one as one,
+    out as out,
+    out_place as out_place,
+    passthrough as passthrough,
+    read as read,
+    reset as reset,
+    timeout as timeout,
+    window as window,
+    xor as xor,
+    xor_outputs as xor_outputs,
+)
+from .runtime import (
+    CompiledNet as CompiledNet,
+    ExecutorHandle as ExecutorHandle,
+    ExecutorOptions as ExecutorOptions,
+    MarkingView as MarkingView,
+    compile as compile,
+    run_async as run_async,
+    run_sync as run_sync,
+    start_async as start_async,
+)
+from .verification import (
+    PropertyResult as PropertyResult,
+    SmtProperty as SmtProperty,
+    SubnetVerificationResult as SubnetVerificationResult,
+    VerificationHarness as VerificationHarness,
+    VerificationResult as VerificationResult,
+    deadlock_free as deadlock_free,
+    mutual_exclusion as mutual_exclusion,
+    place_bound as place_bound,
+    unreachable as unreachable,
+    verify as verify,
+    verify_subnet as verify_subnet,
+)
+
+CallbackError = _libpetri.CallbackError
+LibpetriError = _libpetri.LibpetriError
+StructureError = _libpetri.StructureError
+
+HAS_TOKIO: bool
+HAS_Z3: bool
+HAS_DEBUG: bool
+__version__: str