flowsense-engine 0.5.0__tar.gz → 0.5.1__tar.gz

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/CHANGELOG.md

@@ -11,6 +11,26 @@ All notable changes to FlowSense are documented in this file. The project uses
 
 ### Fixed
 
+## [0.5.1] - 2026-09-25
+
+### Added
+
+- Six controlled Airflow demo DAGs, each with 20 seeded runs, bounded live
+  execution waves, and a read-only execution-evidence verifier.
+- Dedicated multi-DAG showcase dashboard with per-pipeline results and separate
+  queued/running activity metrics.
+- FlowSense Engine wordmark in the README and PyPI package description.
+
+### Changed
+
+- Overview dashboard now uses instant summary queries, clearer multi-DAG labels,
+  and a shorter default history window.
+
+### Fixed
+
+- Corrected Airflow 3 GET state filters from `states` to `state`, preventing
+  running runs from shrinking the bounded successful-run analysis window.
+
 ## [0.5.0] - 2026-09-23
 
 ### Added

{flowsense_engine-0.5.0/src/flowsense_engine.egg-info → flowsense_engine-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowsense-engine
-Version: 0.5.0
+Version: 0.5.1
 Summary: Temporal drift and anomaly detection for Apache Airflow
 Author: Omer Cengiz
 License-Expression: Apache-2.0
@@ -36,9 +36,13 @@ Dynamic: license-file
 
 # FlowSense Engine
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/omercengiz/flowsense-engine/27f7db5e55bfefbba6e355c53c7c84ff34e6f37b/assets/branding/flowsense-engine-logo-v2.png" alt="FlowSense Engine logo" width="640">
+</p>
+
 Temporal drift, anomaly detection, and dependency-aware propagation analysis for Apache Airflow.
 
-Current package release: `0.5.0`. See [CHANGELOG.md](CHANGELOG.md) for release
+Current package release: `0.5.1`. See [CHANGELOG.md](CHANGELOG.md) for release
 notes, [docs/architecture.md](docs/architecture.md) for the system architecture,
 [docs/benchmarks.md](docs/benchmarks.md) for performance measurement, and
 [docs/production-quickstart.md](docs/production-quickstart.md) for a production

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/README.md

@@ -1,8 +1,12 @@
 # FlowSense Engine
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/omercengiz/flowsense-engine/27f7db5e55bfefbba6e355c53c7c84ff34e6f37b/assets/branding/flowsense-engine-logo-v2.png" alt="FlowSense Engine logo" width="640">
+</p>
+
 Temporal drift, anomaly detection, and dependency-aware propagation analysis for Apache Airflow.
 
-Current package release: `0.5.0`. See [CHANGELOG.md](CHANGELOG.md) for release
+Current package release: `0.5.1`. See [CHANGELOG.md](CHANGELOG.md) for release
 notes, [docs/architecture.md](docs/architecture.md) for the system architecture,
 [docs/benchmarks.md](docs/benchmarks.md) for performance measurement, and
 [docs/production-quickstart.md](docs/production-quickstart.md) for a production

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/docs/grafana.md

@@ -56,7 +56,21 @@ The dashboard provides:
 - currently firing FlowSense alerts.
 
 Use the DAG and task variables at the top of the dashboard to narrow the view.
-The default time range is six hours and the dashboard refreshes every 30 seconds.
+The default time range is 15 minutes and the dashboard refreshes every 30 seconds.
+Summary cards use instant queries, so they remain populated independently of
+the selected history window. Current task comparisons include both DAG and
+task names to distinguish tasks across multiple DAGs.
+
+The top row summarizes the selected DAGs: monitored count, highest severity,
+analysis health (healthy only when every selected DAG succeeded), mean coverage,
+and total anomalous and affected tasks. Task comparisons and history appear
+below; collection diagnostics and active alerts follow.
+
+Prometheus history starts when the metrics service is scraped; historical
+Airflow runs are analyzed but are not backfilled into these charts. After
+starting the exporter, use a recent time range and allow a few scrapes. An
+existing browser URL can retain an older time range; select Last 15 minutes
+manually in that case.
 See [alerting.md](alerting.md) for rule behavior, validation, and production
 notification configuration.
 
@@ -68,3 +82,8 @@ docker compose -f deploy/observability/docker-compose.yml down
 
 Prometheus and Grafana data remain in named volumes. To explicitly remove those
 local volumes, add `--volumes` to the command.
+
+## Multi-DAG demo with execution evidence
+
+For six real Airflow workloads, 20 seeded runs per DAG, continued live activity,
+and a dedicated presentation dashboard, see [showcase.md](showcase.md).

flowsense_engine-0.5.1/docs/release-0.5.1.md

@@ -0,0 +1,21 @@
+# FlowSense 0.5.1
+
+This patch fixes Airflow 3 state filtering and adds a reproducible multi-DAG
+showcase and updated project branding.
+
+## Highlights
+
+- Correct `state` filters for Airflow 3 DAG runs and task instances. A running
+  run no longer consumes a slot in the bounded successful-run history window.
+- Six controlled demo DAGs, four tasks each, with 20 seeded runs per DAG and
+  optional bounded live execution waves.
+- Read-only verification of 120 successful seed runs and 480 task executions.
+- Dedicated Grafana showcase with per-DAG analyses, severity history, task
+  deviations, and separately collected running/queued activity.
+- Improved overview dashboard and a wordmark in the README/PyPI description.
+
+Demo workloads use controlled delays. Drift analysis evaluates completed
+successful runs; live activity monitoring is separate. Output schemas and
+public API contracts are unchanged.
+
+See [the showcase guide](showcase.md) for setup and verification.

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/docs/releasing.md

@@ -33,8 +33,8 @@ After the release pull request is merged into `master` and CI passes:
 ```bash
 git switch master
 git pull --ff-only origin master
-git tag -a v0.5.0 -m "FlowSense 0.5.0"
-git push origin v0.5.0
+git tag -a v0.5.1 -m "FlowSense 0.5.1"
+git push origin v0.5.1
 ```
 
 Create and publish the corresponding GitHub Release after pushing the tag. The
@@ -42,7 +42,7 @@ release workflow builds that exact tag and publishes it through the protected
 `pypi` environment. Package publication should run only after the built artifacts
 have been verified.
 
-Use `FlowSense 0.5.0` as the release title, select `Latest`, and do not mark a
-stable release as a pre-release. Use [release-0.5.0.md](release-0.5.0.md) as the
+Use `FlowSense 0.5.1` as the release title, select `Latest`, and do not mark a
+stable release as a pre-release. Use [release-0.5.1.md](release-0.5.1.md) as the
 GitHub release notes; the matching `CHANGELOG.md` section remains the canonical
 change inventory.

flowsense_engine-0.5.1/docs/showcase.md

@@ -0,0 +1,79 @@
+# Live multi-DAG showcase
+
+This is a controlled demo, executed by real Airflow workers. It is not production
+traffic or a scalability benchmark. No run states, task durations, or Prometheus
+history are fabricated or backdated.
+
+The six DAGs in `examples/dags/flowsense_showcase.py` each contain four tasks:
+orders, payments, inventory, analytics, ML features, and customer 360. The first
+14 runs establish a baseline; the next six introduce different controlled sleep
+patterns. Worker and scheduler overhead are included in the measured durations,
+so actual severities can vary. The orders workload has no injected slowdown.
+
+## Run locally
+
+The repository's Airflow Compose configuration mounts `examples/dags`. If an
+existing installation uses a different DAG mount, copy the file to its actual
+DAG folder. Wait for all six `flowsense_showcase_*` DAGs to be parsed.
+
+With Airflow credentials in environment variables or the local `.env`:
+
+```bash
+PYTHONPATH=src .venv/bin/python examples/python/showcase.py \
+  --seed --live-cycles 30 --host 0.0.0.0
+```
+
+Only one exporter can use port 9108 at a time; stop an existing `serve-metrics`
+process before starting this one. The showcase seeds 20 real executions per DAG
+(120 runs, 480 task executions), skipping seed run IDs that already exist. It
+unpauses only the six showcase DAGs. Failed seed runs are reported, not silently
+marked successful or retried. Once each DAG has at least 20 successes, up to 30
+additional waves are submitted, one wave per minute. Live waves triple injected
+slow task delays so running activity is visible across scrape intervals; the
+unchanged orders workload remains a control. Run counts can therefore
+exceed 20; each analysis still uses the latest 20 successful runs. After the last
+wave, collection continues without submitting additional work. Ctrl-C stops the
+collector; already submitted Airflow runs continue to completion.
+
+Start the observability stack as described in [grafana.md](grafana.md), then open
+[FlowSense · Live Multi-DAG Showcase](http://localhost:3000/d/flowsense-showcase?from=now-5m&to=now&kiosk).
+The dashboard is automatically provisioned alongside FlowSense Overview.
+
+## What the dashboard proves
+
+- `flowsense_dag_runs_analyzed`: actual successful runs consumed by the engine,
+  per DAG; the sum is the current analysis-window total, not lifetime throughput.
+- `flowsense_task_*`: measured duration deviations, robust z-scores, and severity.
+- DAG-level affected tasks, change points, trends, and handoff anomalies are
+  computed by the existing FlowSense engine.
+- `airflow_showcase_runs`: queued, running, successful, and failed run counts read
+  separately from the Airflow REST API by the demo collector.
+
+**Running-run counts are activity monitoring, not in-flight drift analysis.**
+The engine analyzes completed successful runs. Both activity and analysis update
+on each collection loop, followed by the normal Prometheus scrape interval.
+Brief runs can finish between scrapes. Time-series charts show actual observations
+since collection began, not all historical Airflow run timestamps.
+
+`logs/showcase-evidence/runs.json` records Airflow run IDs, states, timestamps,
+and demo configuration. The sibling per-DAG JSON documents contain full FlowSense
+analyses, including the current run ID, baseline, deviations, and root cause.
+These are continuously updated local evidence files, not committed credentials.
+For a durable report, copy a snapshot into `artifacts/showcase-evidence` alongside
+the screenshot, recording the observation time.
+
+A defensible description for sharing is: “FlowSense analyzed a rolling window
+of 20 successful executions across each of six controlled Airflow pipelines
+(120 runs, 24 task definitions), while separately monitoring live run activity.”
+Use the captured evidence for anomaly counts, which change between observations.
+
+Re-run the read-only execution proof against Airflow:
+
+```bash
+PYTHONPATH=src .venv/bin/python examples/python/showcase.py \
+  --verify-seed --evidence-dir artifacts/showcase-evidence
+```
+
+This fails if a seed run is missing/unsuccessful or a run lacks four successful
+task instances with start/end timestamps. It writes `seed-execution-proof.json`
+only after validating all six DAGs.

flowsense_engine-0.5.1/examples/dags/flowsense_showcase.py

@@ -0,0 +1,91 @@
+"""Six controlled workloads; real task executions, deliberately varied latency."""
+
+from __future__ import annotations
+
+import time
+from datetime import UTC, datetime
+
+from airflow.sdk import DAG, get_current_context, task
+
+SCENARIOS = {
+    "orders": (
+        "extract_orders",
+        "validate_orders",
+        "aggregate_orders",
+        "publish_orders",
+    ),
+    "payments": ("fetch_payments", "validate_payments", "reconcile", "settle"),
+    "inventory": ("read_stock", "normalize_stock", "forecast_stock", "sync_stock"),
+    "analytics": (
+        "collect_events",
+        "enrich_events",
+        "build_sessions",
+        "publish_metrics",
+    ),
+    "ml_features": (
+        "read_events",
+        "clean_features",
+        "compute_features",
+        "write_features",
+    ),
+    "customer360": (
+        "fetch_profiles",
+        "deduplicate",
+        "join_profiles",
+        "publish_profiles",
+    ),
+}
+
+
+def build_dag(name: str, task_names: tuple[str, ...]) -> DAG:
+    with DAG(
+        dag_id=f"flowsense_showcase_{name}",
+        start_date=datetime(2026, 1, 1, tzinfo=UTC),
+        schedule=None,
+        catchup=False,
+        max_active_runs=3,
+        max_active_tasks=6,
+        tags=["flowsense", "controlled-demo", name],
+        doc_md="Controlled latency demo. Real Airflow executions; no production data.",
+    ) as dag:
+
+        @task
+        def work(stage: int, scenario: str) -> dict:
+            run = get_current_context()["dag_run"]
+            conf = run.conf or {}
+            index = int(conf.get("sample", 0))
+            # Small deterministic baseline variation, then different incident patterns.
+            delay = 0.35 + ((index * 5 + stage * 3) % 7) * 0.04
+            if index >= 14:
+                if scenario == "payments" and stage == 2:
+                    delay += 3.0
+                elif scenario == "inventory" and stage == 2:
+                    delay += (index - 13) * 0.45
+                elif scenario == "analytics" and stage in (1, 2):
+                    delay += 1.8 if index % 3 else 0.2
+                elif scenario == "ml_features" and stage == 2:
+                    delay += 4.0
+                elif scenario == "customer360" and stage == 1:
+                    delay += 1.2
+            # Live waves intensify the incident so activity spans multiple scrapes.
+            if "_live_" in run.run_id and delay > 1.0:
+                delay *= 3
+            time.sleep(delay)
+            return {
+                "scenario": scenario,
+                "sample": index,
+                "stage": stage,
+                "sleep_seconds": delay,
+            }
+
+        previous = None
+        for stage, task_name in enumerate(task_names):
+            current = work.override(task_id=task_name)(stage, name)
+            if previous is not None:
+                previous >> current
+            previous = current
+    return dag
+
+
+for scenario, names in SCENARIOS.items():
+    globals()[f"flowsense_showcase_{scenario}"] = build_dag(scenario, names)

flowsense_engine-0.5.1/examples/python/showcase.py

@@ -0,0 +1,290 @@
+"""Run and observe six real Airflow demo workloads (local Airflow 3 only).
+
+The analysis engine evaluates completed runs. A separate, explicitly named
+activity metric reports queued/running runs; it is not in-flight drift detection.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import threading
+import time
+from collections import Counter
+from datetime import UTC, datetime
+from pathlib import Path
+
+from flowsense.application import AnalysisRequest, AnalyzeDAG
+from flowsense.application.serialization import serialize_analysis
+from flowsense.infrastructure.airflow.client import AirflowClient
+from flowsense.infrastructure.airflow.config import load_airflow_config
+from flowsense.infrastructure.airflow.factory import create_airflow_data_source_factory
+from flowsense.observability.prometheus import PrometheusExporter, create_metrics_server
+
+DAGS = [
+    f"flowsense_showcase_{name}"
+    for name in (
+        "orders",
+        "payments",
+        "inventory",
+        "analytics",
+        "ml_features",
+        "customer360",
+    )
+]
+
+
+class ShowcaseExporter(PrometheusExporter):
+    """FlowSense analysis plus separately labelled Airflow demo activity."""
+
+    def __init__(self):
+        super().__init__()
+        self.activity = ""
+
+    def render(self):
+        return super().render() + self.activity
+
+
+def verify_seed_runs(client: AirflowClient, evidence_dir: Path) -> dict:
+    """Verify real successful seed runs and task timestamps, without mutations."""
+    proof = {
+        "observed_at": datetime.now(UTC).isoformat(),
+        "controlled_demo": True,
+        "source": "Airflow REST API",
+        "dags": {},
+    }
+    expected = {f"flowsense_showcase_seed_{index:02d}" for index in range(20)}
+    for dag in DAGS:
+        seeds = [
+            run
+            for run in client.get_dag_runs(dag)["dag_runs"]
+            if run["dag_run_id"] in expected
+        ]
+        if {r["dag_run_id"] for r in seeds} != expected or any(
+            r["state"] != "success" for r in seeds
+        ):
+            raise ValueError(f"{dag}: expected 20 successful seed runs")
+        tasks = []
+        for run in seeds:
+            instances = client.get_task_instances(dag, run["dag_run_id"])[
+                "task_instances"
+            ]
+            if len(instances) != 4 or any(
+                t["state"] != "success"
+                or not t.get("start_date")
+                or not t.get("end_date")
+                for t in instances
+            ):
+                raise ValueError(
+                    f"{dag}/{run['dag_run_id']}: expected four successful timed tasks"
+                )
+            tasks.extend(
+                {
+                    key: task.get(key)
+                    for key in (
+                        "dag_id",
+                        "dag_run_id",
+                        "task_id",
+                        "state",
+                        "start_date",
+                        "end_date",
+                        "duration",
+                        "try_number",
+                    )
+                }
+                for task in instances
+            )
+        proof["dags"][dag] = {
+            "successful_seed_runs": len(seeds),
+            "successful_task_executions": len(tasks),
+            "task_instances": tasks,
+        }
+    evidence_dir.mkdir(parents=True, exist_ok=True)
+    (evidence_dir / "seed-execution-proof.json").write_text(
+        json.dumps(proof, indent=2) + "\n"
+    )
+    return proof
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--seed",
+        action="store_true",
+        help="Create 20 real runs per demo DAG, idempotently.",
+    )
+    parser.add_argument(
+        "--live-cycles",
+        type=int,
+        default=0,
+        help="Additional waves after seeding; one wave per minute.",
+    )
+    parser.add_argument(
+        "--verify-seed",
+        action="store_true",
+        help="Verify 120 seed runs and 480 task executions without triggering work.",
+    )
+    parser.add_argument("--port", type=int, default=9108)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument(
+        "--evidence-dir", type=Path, default=Path("logs/showcase-evidence")
+    )
+    args = parser.parse_args()
+    if args.live_cycles < 0 or (args.verify_seed and (args.seed or args.live_cycles)):
+        parser.error(
+            "Use nonnegative live cycles; verification cannot be combined with execution."
+        )
+    # Parse values as data, never execute the .env file as shell code.
+    if Path(".env").exists():
+        for line in Path(".env").read_text().splitlines():
+            key, sep, value = line.strip().removeprefix("export ").partition("=")
+            if sep and key.startswith("AIRFLOW_"):
+                os.environ.setdefault(key, " ".join(shlex.split(value, comments=True)))
+    config = load_airflow_config()
+    client = AirflowClient(config)
+    if args.verify_seed:
+        try:
+            verify_seed_runs(client, args.evidence_dir)
+            print(
+                "Verified 120 successful seed runs and 480 successful task executions."
+            )
+        finally:
+            client.close()
+        return
+
+    def api(method, path, **kwargs):
+        response = client._authenticated_request(
+            method, client._api_url(path), **kwargs
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def trigger(dag, run_id, sample):
+        api(
+            "POST",
+            f"/dags/{dag}/dagRuns",
+            json={
+                "dag_run_id": run_id,
+                "logical_date": None,
+                "conf": {"sample": sample, "controlled_demo": True},
+                "note": "FlowSense showcase: real execution, controlled latency workload.",
+            },
+        )
+
+    args.evidence_dir.mkdir(parents=True, exist_ok=True)
+    exporter = ShowcaseExporter()
+    server = create_metrics_server(exporter, host=args.host, port=args.port)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    analyze = AnalyzeDAG(create_airflow_data_source_factory(config)).execute
+    if args.seed:
+        for dag in DAGS:
+            api("PATCH", f"/dags/{dag}", json={"is_paused": False})
+            existing = {r["dag_run_id"] for r in client.get_dag_runs(dag)["dag_runs"]}
+            for index in range(20):
+                run_id = f"flowsense_showcase_seed_{index:02d}"
+                if run_id not in existing:
+                    trigger(dag, run_id, index)
+            print(f"{dag}: 20 seed runs submitted", flush=True)
+
+    cycles = 0
+    last_wave = 0.0
+    session = datetime.now(UTC).strftime("%Y%m%dT%H%M%S")
+    try:
+        while True:
+            snapshot = {
+                "observed_at": datetime.now(UTC).isoformat(),
+                "controlled_demo": True,
+                "dags": {},
+            }
+            activity = [
+                "# HELP airflow_showcase_runs Real Airflow run counts for controlled demo DAGs.",
+                "# TYPE airflow_showcase_runs gauge",
+            ]
+            ready = True
+            for dag in DAGS:
+                started = time.monotonic()
+                try:
+                    runs = client.get_dag_runs(dag)["dag_runs"]
+                    counts = Counter(r["state"] for r in runs)
+                    ready = ready and counts["success"] >= 20
+                    for state in ("queued", "running", "success", "failed"):
+                        activity.append(
+                            f'airflow_showcase_runs{{dag_id="{dag}",state="{state}"}} {counts[state]}'
+                        )
+                    snapshot["dags"][dag] = {
+                        "states": dict(counts),
+                        "runs": [
+                            {
+                                k: r.get(k)
+                                for k in (
+                                    "dag_run_id",
+                                    "state",
+                                    "start_date",
+                                    "end_date",
+                                    "conf",
+                                )
+                            }
+                            for r in runs
+                        ],
+                    }
+                    if counts["success"] >= 6:
+                        analysis = analyze(
+                            AnalysisRequest(dag_id=dag, history_run_limit=20)
+                        )
+                        exporter.record_success(
+                            analysis, duration_seconds=time.monotonic() - started
+                        )
+                        output = serialize_analysis(analysis)
+                        (args.evidence_dir / f"{dag}.json").write_text(
+                            json.dumps(output, indent=2) + "\n"
+                        )
+                        snapshot["dags"][dag]["analysis"] = {
+                            "runs_analyzed": analysis.runs_analyzed,
+                            "severity": str(analysis.overall_severity),
+                            "anomalous_tasks": analysis.summary.anomalous_tasks,
+                        }
+                except Exception as exc:
+                    ready = False
+                    exporter.record_failure(
+                        dag, duration_seconds=time.monotonic() - started
+                    )
+                    snapshot["dags"][dag] = {"error": type(exc).__name__}
+                    print(f"{dag}: {type(exc).__name__}: {exc}", flush=True)
+            exporter.activity = "\n".join(activity) + "\n"
+            (args.evidence_dir / "runs.json").write_text(
+                json.dumps(snapshot, indent=2) + "\n"
+            )
+            print(
+                json.dumps(
+                    {
+                        dag: value.get("states", value)
+                        for dag, value in snapshot["dags"].items()
+                    }
+                ),
+                flush=True,
+            )
+            if (
+                ready
+                and cycles < args.live_cycles
+                and time.monotonic() - last_wave >= 60
+            ):
+                for dag in DAGS:
+                    trigger(
+                        dag,
+                        f"flowsense_showcase_live_{session}_{cycles:02d}",
+                        14 + cycles % 6,
+                    )
+                cycles += 1
+                last_wave = time.monotonic()
+                print(f"Live wave {cycles}/{args.live_cycles} submitted", flush=True)
+            time.sleep(2)
+    finally:
+        server.shutdown()
+        server.server_close()
+        client.close()
+
+
+if __name__ == "__main__":
+    main()

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowsense-engine"
-version = "0.5.0"
+version = "0.5.1"
 description = "Temporal drift and anomaly detection for Apache Airflow"
 readme = "README.md"
 license = "Apache-2.0"

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/src/flowsense/infrastructure/airflow/client.py

@@ -381,7 +381,7 @@ class AirflowClient:
             return self._get_paginated(
                 self._api_url(f"/dags/{dag_id}/dagRuns"),
                 "dag_runs",
-                params={"states": ["success"], "order_by": "-run_after"},
+                params={"state": ["success"], "order_by": "-run_after"},
                 item_limit=self.history_run_limit,
             )
         except AirflowApiError as exc:
@@ -408,7 +408,7 @@ class AirflowClient:
             return self._get_paginated(
                 self._api_url(f"/dags/{dag_id}/dagRuns/~/taskInstances"),
                 "task_instances",
-                params={"dag_run_ids": dag_run_ids, "states": ["success"]},
+                params={"dag_run_ids": dag_run_ids, "state": ["success"]},
             )
         except AirflowApiError as exc:
             if exc.status_code not in UNSUPPORTED_FILTER_STATUS_CODES:

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1/src/flowsense_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowsense-engine
-Version: 0.5.0
+Version: 0.5.1
 Summary: Temporal drift and anomaly detection for Apache Airflow
 Author: Omer Cengiz
 License-Expression: Apache-2.0
@@ -36,9 +36,13 @@ Dynamic: license-file
 
 # FlowSense Engine
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/omercengiz/flowsense-engine/27f7db5e55bfefbba6e355c53c7c84ff34e6f37b/assets/branding/flowsense-engine-logo-v2.png" alt="FlowSense Engine logo" width="640">
+</p>
+
 Temporal drift, anomaly detection, and dependency-aware propagation analysis for Apache Airflow.
 
-Current package release: `0.5.0`. See [CHANGELOG.md](CHANGELOG.md) for release
+Current package release: `0.5.1`. See [CHANGELOG.md](CHANGELOG.md) for release
 notes, [docs/architecture.md](docs/architecture.md) for the system architecture,
 [docs/benchmarks.md](docs/benchmarks.md) for performance measurement, and
 [docs/production-quickstart.md](docs/production-quickstart.md) for a production

{flowsense_engine-0.5.0 → flowsense_engine-0.5.1}/src/flowsense_engine.egg-info/SOURCES.txt

@@ -14,9 +14,13 @@ docs/production-quickstart.md
 docs/prometheus.md
 docs/python-api.md
 docs/release-0.5.0.md
+docs/release-0.5.1.md
 docs/releasing.md
+docs/showcase.md
 examples/dags/flowsense_demo.py
+examples/dags/flowsense_showcase.py
 examples/python/production_batch.py
+examples/python/showcase.py
 src/flowsense/__init__.py
 src/flowsense/config.py
 src/flowsense/py.typed
@@ -121,5 +125,6 @@ tests/test_prometheus.py
 tests/test_propagation.py
 tests/test_public_api.py
 tests/test_root_cause.py
+tests/test_showcase.py
 tests/test_timing.py
 tests/test_trend.py