Documentation

Actions and Events — Responding to the Edge

Attach callables to edge rules and handle Event objects safely: fail-open semantics, retries, and idempotent actions that survive crashes.

13 min read

Activation and Entitlement

What pyvorin-native 1.0.9 does when you activate: the Ed25519-signed lease, device binding, gate semantics, anti-rollback, and the offline grace table per tier.

7 min read

Alerting and Webhooks

pyvorin-native 1.0.9 has no webhook delivery. This page shows the verified alerting surfaces it does have and how to wire them into cron and CI.

Anomaly Detection with Pyvorin

Anomaly detection over streams works with Pyvorin when the detector is a compiled windowed aggregate behind the stream processor. Anchors, and the limits.

AOT vs JIT for Python: An Honest Comparison

Warm-up, peak performance, compatibility and running cost: the AOT vs JIT trade-offs for Python, the cases where each wins, and Pyvorin's position.

8 min read

Apache Airflow Integration

How to put Pyvorin-native compute inside an Airflow DAG: compile before the run, execute through the CLI, and keep a measured speedup on record in CI.

AST Analysis Phase

The first gate in the Pyvorin pipeline: what the AST walk looks for, what disqualifies a function, and how support tiers are assigned.

AWS and Azure Integration

Wire Pyvorin Edge into AWS IoT Greengrass and Azure IoT Hub, with MQTT bridging and a worked egress cost comparison.

16 min read

Benchmarking Correctly

Cold compiles, micro-workloads and single runs: the measurement mistakes that make benchmark numbers meaningless, and the verified commands that avoid them.

Benchmarking with the Pyvorin Edge SDK

Benchmark Pyvorin Edge pipelines honestly: cost-model assumptions, warm-up discipline, a CI regression example, and micro-benchmark limits.

13 min read

Benchmarks

Every measured CPython vs Pyvorin result across 71 workloads — the wins, the losses, and how to reproduce every number yourself.

3 min read

Caching Compiled Artifacts in CI

Skip the compile step on every repeated CI build: the verified pyvorin-native 1.0.9 cache locations, cache keys that actually hit, and the trap in cache clear.

Compiler Pipeline Overview

How Pyvorin turns a Python function into native machine code — every stage from parsing to the wrapper that makes the result callable.

Correctness Validation

pyvorin-native validates native output against CPython before trusting it: a ground-truth run in bench, a per-function oracle, drift and overflow fields.

Custom Benchmark Suites

Turn pyvorin bench --json into a repeatable suite: capture raw_times_ms, p95 and stddev per function, aggregate across a directory, and gate regressions in CI.

Custom Cloud Endpoints

Build a receiver for Pyvorin Edge batches: payload schema, bearer auth, retry semantics, and Flask and FastAPI handler examples.

15 min read

Dagster Integration

Dagster assets backed by Pyvorin-native code need no plugin: compile the asset's compute ahead of time and materialise it through the verified CLI runner.

Debugging Compiled Code

How to debug code compiled by Pyvorin Native 1.0.9: the support, explain and inspect commands, fallback reason chains, and cache forensics.

Disaster Recovery and Data Integrity

A recovery playbook: WAL checkpointing, queue repair, automated backups, factory reset and how to test your restores.

18 min read

Docker Deployment Guide

A production Docker setup for EdgeAgent: multi-stage builds, Compose, networking modes and secrets management.

24 min read

Edge and IoT Deployment

What pyvorin-native 1.0.9 can and cannot do at the edge: platform support, compile-then-deploy, offline licensing, and measured IoT benchmark numbers.

Edge CLI Tools Reference

Every pyv-edge command with flags and exit codes, plus patterns for wiring the tools into CI pipelines.

15 min read

Edge Configuration Reference

Every EdgeAgent configuration key explained: polling, storage, upload, dashboard, and licence settings, with reload caveats and examples.

22 min read

Error Handling and Diagnostics

How pyvorin-native 1.0.9 fails and reports: the four compile outcomes, verified exit codes, guard failure semantics, and where every diagnostic record lives.

Example Workload: ETL Pipeline

An illustrative ETL pipeline with acceleratable stages (transforms, windowed aggregates) and non-acceleratable ones (CSV parsing, joins) separated by evidence.

Example Workload: Financial Risk Calculations

An illustrative financial-risk batch dissected stage by stage: Monte Carlo, correlations and moving averages — what a compiler accelerates, what it cannot.

Example Workload: Log Analytics

An illustrative log-analytics pipeline dissected stage by stage: where native compilation wins, where parsing-bound stages do not, and the measured anchors.

Example Workload: ML Feature Engineering

An illustrative ML feature pipeline split into what a compiler accelerates — aggregations, transforms — and what it cannot: histograms, string features, I/O.

Field Redaction Patterns

Five field-level redaction actions for edge telemetry — drop, mask, hash, generalise, tokenise — with performance notes and ordering pitfalls.

16 min read

FileReplayAdapter — Time-Travel for Sensor Data

Replay recorded sensor data through a live pipeline with FileReplayAdapter: pacing modes, loop behaviour, and reproducible tests.

12 min read

GDPR and NIS2 Compliance

A practical route to GDPR and NIS2 compliance: records of processing, retention, erasure, breach timelines and audit evidence.

16 min read

Health Monitoring and Prometheus Export

Health endpoints, Prometheus metrics, a ready Grafana dashboard and Alertmanager rules for EdgeAgent fleets.

20 min read

High-Frequency Data Feeds

On high-frequency feeds, Pyvorin accelerates ingestion-side batch transforms, not the wire path. Measured anchors and where to draw the boundary.

How Local Compilation Works

The full path from import through compilation to native execution in pyvorin-native 1.0.9 — where the cache lives, what the fallback does, and exactly what does and does not leave the machine.

10 min read

How to Handle Compilation Failure

Compilation failure in pyvorin-native 1.0.9 almost never means a crash: the verified taxonomy, what each status means, and how to get per-function reasons.

How to Run a Speed Proof

The measurement a sceptical CFO could audit: captured baseline, warmed runs, median-of-N, correctness check, compile-time amortisation, and an honest write-up.

HTTPAdapter — REST, Webhooks, and Polling Ingest

HTTPAdapter for edge pipelines: inbound REST and webhook ingest, outbound polling, authentication headers, TLS, and key security notes.

14 min read

HTTPCloudUploader Configuration

Configure HTTPCloudUploader end to end: retry internals, backoff, TLS verification, batch sizing, and draining the local sync queue.

13 min read

Implementing Pyvorin at the Edge

Edge deployment with Pyvorin Native 1.0.9: compile on an x86_64 build host, ship the compiled cache, and activate per device within its offline grace window.

Implementing Pyvorin in Microservices

Compile CPU-bound services at build time, ship the artefacts in the image, and skip the compiler sidecar. Which service shapes benefit, which do not, and why.

LicenseValidator API Reference

Every LicenseValidator class, enum and environment variable, including local file format and the local-vs-remote validation cascade.

12 min read

Making Python ETL Pipelines Faster, Measured

Measured per-transform ETL results: windowed aggregates to 134.62x, merge joins to 0.64x — which transforms accelerate, which do not, and where the seam sits.

8 min read

Measuring Pyvorin Adoption

Metered credits do not exist in pyvorin-native, so they cannot measure adoption. Five verified metrics can: coverage, deltas, cache, fallback, correctness.

Migrating from Cython to Pyvorin

What Cython's static typing bought you, what changes when the annotations come off, which modules should stay, and the commands to prove each migration.

Migrating from Numba to Pyvorin

What @njit gave you, what Pyvorin compilation gives you instead, which kernels should stay on Numba, and how to verify each migrated function.

MQTTAdapter — Broker Subscriptions and Resilient Ingest

MQTTAdapter for resilient edge ingest: QoS semantics, TLS, reconnect and back-off behaviour, and durable local buffering during outages.

14 min read

Network Requirements for Pyvorin

Every endpoint pyvorin-native 1.0.9 contacts, when each fires, offline grace windows, air-gap implications, TLS, and the env overrides that redirect traffic.

7 min read

Prefect Integration

A Prefect flow running Pyvorin-native code needs no plugin: compile the step ahead of time, launch it from a task, and keep the measurement.

Privacy Filtering Overview

Privacy filtering for edge telemetry: regulatory context (GDPR, NIS2), filtering stages, measured overhead, and field-level options.

14 min read

Production Deployment Checklist

The pre-flight and post-deployment checks that keep EdgeAgent gateways secure, backed up and observable.

22 min read

Profiling Edge Pipelines and System Metrics

Profile edge pipelines in place: cProfile on hot rules, memory measurement, system metrics, and how to read results without fooling yourself.

12 min read

Programmatic API Usage

Using pyvorin-native 1.0.9 as a library: PyvorinCompiler, result objects, diagnostics, @kernel and the cache — all probed against the installed build.

Python Log Processing Performance

Parsing log lines is already fast under CPython — measured 0.86x compiled. The wins live in the aggregation layer behind the parser; here is the measured map.

8 min read

Pyvorin and HIPAA

Pyvorin is a build tool, not a system that touches PHI: under pyvorin-native, source stays on the machine and the network surface is two endpoints.

Pyvorin and SOC 2

No SOC 2 audit covers pyvorin-native as of 1.0.9. What exists is a set of controls you can execute and verify yourself, mapped to common criteria categories.

Pyvorin Edge Plugin Architecture

How the entry-point plugin system works, from discovery to a complete custom adapter with configuration.

20 min read

Pyvorin for Algorithmic Execution

Slicing schedules, market-impact research and pre-trade analytics are legitimate compiler targets; the hot order loop on a microsecond budget is not.

Pyvorin for Fraud Detection

Batch scoring grids, feature aggregation and anomaly loops are strong measured matches; inline authorisation-path scoring is not a compiler problem.

Pyvorin for Quantitative Trading

Backtests, signal generation and portfolio simulations accelerate well; market-data parsing and the live order path do not. A candid map of the boundary.

Pyvorin for Regulatory Reporting

Report pipelines split cleanly: enrichment, validation and aggregation loops have strong measured anchors; parsing, joins and formatting regress.

Pyvorin for Risk Management

Monte Carlo simulation, correlation matrices and stress-test grids are strong measured matches; intraday limit monitoring on a latency budget is not.

Pyvorin GDPR Considerations

Source never leaves the machine under pyvorin-native, telemetry carries event metadata only, and the device fingerprint is personal data.

Pyvorin in Air-Gapped Environments

Compilation needs no network at all. Licensing degrades slowly: offline-valid leases keep passing, and grace runs from 24 hours to 90 days by tier.

Pyvorin in Docker: Best Practices

Compile in the builder stage, ship the disk cache in the image, and activate at container start. The Docker practices that matter for Pyvorin Native 1.0.9.

Pyvorin on AWS

The practical AWS guide for Pyvorin Native 1.0.9: instance constraints, baking compiled artefacts into an AMI, Auto Scaling, and a labelled cost model.

Pyvorin Rollout Playbook

One CPU-bound pilot, a proof built on measured numbers, written success criteria, staged rollout and a clean rollback story — the Pyvorin adoption sequence.

Pyvorin vs Codon

Codon compiles Python-syntax code to standalone native binaries; Pyvorin compiles the Python you already run, in-process, beside CPython. Where each fits.

Pyvorin vs CPython

Pyvorin runs your existing Python as native machine code beside CPython. Where that helps, where it does not, and the measured results from 71 workloads.

Pyvorin vs CPython: A Total-Cost View

More than the compute line — a labelled three-year illustrative model comparing the same Python workload under CPython alone versus CPython with Pyvorin.

Pyvorin vs Cython

Cython asks you to maintain a second language for speed. Pyvorin compiles the Python you already have. The right choice depends on who owns the code.

Pyvorin vs Mojo

Mojo and Pyvorin both promise Python-like ergonomics with native performance, but they answer different questions. Goals, fit, and honest trade-offs.

Pyvorin vs Nuitka

Nuitka's deliverable is a binary you can hand to a customer. Pyvorin's deliverable is speed inside the Python environment you already run. Choose accordingly.

Pyvorin vs Numba

Both tools turn Python into machine code through LLVM. The deciding factor is what your slow code looks like — and this page shows how to find out.

Pyvorin vs PyPy

PyPy replaces CPython with a faster interpreter and asks for nothing. Pyvorin keeps your runtime and compiles the hot paths. Compatibility decides most battles.

Reducing Cloud Compute Bills

Where a measured speedup becomes a smaller bill, where it does not, and a labelled illustrative model covering spot capacity, autoscaling and reservations.

Reducing Python CPU Usage Without Rewriting

Profile first, compile what the profile points at: a measured workflow for lower Python CPU usage, the workloads where it works, and a labelled capacity model.

8 min read

Rules and Conditions — Logic at the Edge

Ten concrete rule and condition examples for edge pipelines: thresholds, hysteresis, isolation tests, and the patterns that avoid false alarms.

16 min read

Running EdgeAgent Under Systemd

A hardened unit file for EdgeAgent, with graceful shutdown, resource limits, journald logging and socket activation caveats.

18 min read

Running Pyvorin Natively on Your Own Hardware

pyvorin-native has no remote compile mode to opt into — local compilation is the architecture. What runs on your hardware, and what the only network calls do.

Security and Source Privacy

What pyvorin-native 1.0.9 sends off your machine, what never leaves it, the pyvorin-thin warning, and the set_privacy opt-out — verified on the installed build.

Security Best Practices

The verified security posture of pyvorin-native 1.0.9: what the product guarantees, what it does not, and the practices that keep it sound.

SensorReading API Reference

SensorReading API reference: constructor fields, unit handling, the dual-definition caveat, and validation behaviour at the edge.

10 min read

Server Consolidation with Pyvorin

Fewer servers is the goal; safe consolidation is the method. Measure first, keep the redundancy floor, treat freed capacity as headroom before saving.

Structured Log Management and Shipping

Practical log management for gateways: structlog, rotation, shipping to Loki, Splunk or CloudWatch, and correlation IDs.

18 min read

Telemetry and Privacy

Event types, sampling, the bulk endpoint, envelope fields, privacy levels, and client-side inspection — the pyvorin-native 1.0.9 telemetry system, precisely.

Testing Pyvorin Edge Pipelines

The testing pyramid for edge pipelines: unit tests, property tests, integration runs, coverage gates and mutation testing.

18 min read

The Pipeline Class — Ingest, Window, Evaluate, Act

How the Pipeline class works conceptually: dataflow from ingest through windowing and rules to actions, and where the API reference takes over.

15 min read

Tutorial: Cold Chain Monitoring for Pharmaceuticals

A complete GDP cold-chain pipeline: excursion rules, patient-field redaction, signed audit records and offline buffering.

25 min read

Tutorial: Precision Agriculture and Smart Irrigation

Soil-moisture rules, weather-driven irrigation, a solar power budget and fleet rollout for remote fields.

25 min read

Tutorial: Predictive Maintenance with Vibration Analysis

Vibration baselines, a NEON-compiled hot-path, threshold tuning and the business case for early fault detection.

25 min read

Tutorial: Smart Building Energy Monitor

From Modbus meters to a live dashboard: pipeline configuration, cloud sync and the readings behind each panel.

30 min read

Tutorial: Telecom Tower Monitoring and Safety

SNMP telemetry, multi-sensor pipelines, tower-climb safety rules and MQTT integration with the NOC.

35 min read

Unsupported Code and the Fallback Path

When Pyvorin cannot take a function native, your code still runs — via a recorded, per-call fallback to lazily compiled CPython. Here is exactly how that works.

Warm-Up and Caching Strategies

Where pyvorin-native 1.0.9 caches compiled code, what a cache hit is worth in measured milliseconds, and how to key the cache in CI.

Window Aggregation — Rolling, Tumbling, and Custom Functions

How rolling, tumbling and session windows aggregate sensor streams, which built-in functions exist, and the performance caveats.

14 min read

Writing Compiler-Friendly Python for Pyvorin Edge

Patterns that compile well on the edge device: stable types, simple control flow, and the habits that force the compiler to bail out.

12 min read