processbehavior 0.2.0__py3-none-any.whl

processbehavior/types.py

@@ -0,0 +1,154 @@
+"""TypedDict definitions for the chart-info payload shape.
+
+Every entry under ``AnalysisResult.charts`` is structurally a
+:class:`ChartPayload` — a dict carrying the chart's data, statistics,
+metadata, and (for stratified results) its strata list. Until this
+module existed, the shape was an informal ``dict[str, Any]``; producer
+sites in :mod:`processbehavior.analysis` and consumer sites in
+:mod:`processbehavior.plotting` could disagree about keys silently. The
+strata-list bug (commit ``f938fdf``) and the Xbar dead-branch bug
+(commit ``1444b63``) were both producer/consumer disagreements about
+this contract.
+
+Typing the contract lets mypy catch the next drift at edit time.
+
+Usage
+-----
+At a producer site::
+
+    from processbehavior.types import ChartPayload, ChartMetadata
+
+    def _calculate_my_chart(self, ...) -> dict[str, ChartPayload]:
+        return {
+            'Xbar': ChartPayload(
+                data=df,
+                statistics={'N': 30, 'center': 100.0, 'lpl': 95.0, 'upl': 105.0},
+                metadata=ChartMetadata(chart_type='Xbar', value_col='y'),
+            )
+        }
+
+At a consumer site::
+
+    from processbehavior.types import ChartPayload
+
+    def render(info: ChartPayload) -> Figure:
+        df = info['data']               # mypy: pd.DataFrame
+        stats = info['statistics']      # mypy: ChartStatistics | nested dict
+        metadata = info['metadata']     # mypy: ChartMetadata
+        ...
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict
+
+try:  # Python 3.11+
+    from typing import NotRequired
+except ImportError:  # Python 3.9-3.10
+    from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class ChartStatistics(TypedDict):
+    """Statistics for one chart (unstratified) or one stratum (stratified).
+
+    Every control chart (X, mR, Xbar, S) and the Histogram emit this
+    same shape from ``get_statistics()``. Histogram additionally carries
+    :class:`HistogramExtras` keys.
+
+    When the control limits and/or subgroup size vary across subgroups
+    (e.g. Xbar/S with ``n_mode='actual'`` on unbalanced data),
+    ``N``, ``lpl``, and ``upl`` are ``None`` and the optional
+    ``limits_vary`` flag is ``True``. ``center`` remains a single scalar.
+    """
+
+    N: int | None
+    center: float | None
+    lpl: float | None
+    upl: float | None
+    limits_vary: NotRequired[bool]
+
+
+class HistogramExtras(TypedDict, total=False):
+    """Additional keys present in Histogram statistics dicts.
+
+    ``mean`` is an alias for :attr:`ChartStatistics.center`; ``n`` is an
+    alias for :attr:`ChartStatistics.N`. ``std`` is the sample standard
+    deviation. These keys exist for historical / convenience reasons.
+    """
+
+    mean: float | None
+    std: float | None
+    n: int
+
+
+class ChartMetadata(TypedDict, total=False):
+    """Per-chart metadata keys.
+
+    All keys are optional (``total=False``). Different chart variants
+    populate different subsets:
+
+    - ``chart_type`` / ``value_col`` / ``center_col``: every chart.
+    - ``stratified`` / ``stratify_col`` / ``stratify_by``: stratified
+      charts only.
+    - ``lane_boundaries``: stratified X/mR charts with collapsed factors.
+    - ``insufficient_strata``: mR/r charts that dropped first-per-stratum.
+    - ``phased`` / ``single_point_phases``: charts run with
+      ``phased=True``.
+    - ``run_rules_applicable``: present on charts where Western Electric
+      rules apply (or explicitly don't).
+    - ``limits_source`` / ``calibration``: reserved for the standards-
+      given charts feature (see issue #79).
+    """
+
+    chart_type: str
+    value_col: str
+    center_col: str
+    stratified: bool
+    stratify_col: str | None
+    stratify_by: list[str]
+    lane_boundaries: dict[str, list[float]] | None
+    insufficient_strata: list[str] | None
+    phased: bool
+    single_point_phases: int
+    run_rules_applicable: bool
+    bins: int  # Histogram only
+    focused_stratum: str  # After AnalysisResult.focus()
+    stratum_display: str  # Pretty-printed stratum label
+    residual_type: str  # 'R1'..'R6' for residual charts
+    recentered: bool  # Recentered residual charts
+    limits_source: str  # 'data' | 'calibration' (issue #79)
+    calibration: dict | None  # Mean/sd payload (issue #79)
+
+
+# Statistics can be flat (unstratified) or nested-by-stratum (stratified).
+ChartStatisticsValue = ChartStatistics | dict[str, ChartStatistics]
+
+
+class ChartPayload(TypedDict):
+    """The dict structure stored in ``AnalysisResult.charts[name]``.
+
+    Required: ``data``, ``statistics``, ``metadata``.
+    Optional: ``strata`` (present on stratified charts).
+    """
+
+    data: pd.DataFrame
+    statistics: ChartStatisticsValue
+    metadata: ChartMetadata
+    strata: NotRequired[list[str]]
+
+
+# Type alias for the full charts dict on AnalysisResult.
+Charts = dict[str, ChartPayload]
+
+
+__all__ = [
+    'ChartStatistics',
+    'HistogramExtras',
+    'ChartMetadata',
+    'ChartStatisticsValue',
+    'ChartPayload',
+    'Charts',
+]

processbehavior-0.2.0.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.5
+Name: processbehavior
+Version: 0.2.0
+Summary: Python-native Process Behavior & Control Charts (spec-driven SPC with tidy outputs)
+Project-URL: Homepage, https://github.com/cnicholas/processbehavior
+Project-URL: Repository, https://github.com/cnicholas/processbehavior
+Project-URL: Issues, https://github.com/cnicholas/processbehavior/issues
+Project-URL: Changelog, https://github.com/cnicholas/processbehavior/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://cnicholas.github.io/processbehavior/
+Author: cnicholas
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: bishop-vas,control-chart,control-charts,design-of-experiments,process-behavior,process-behavior-chart,quality-control,shewhart,spc,variance-analysis,wheeler,xmr
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: natsort>=8.0.0
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas<3,>=2.0
+Requires-Dist: plotly<7,>=5.18
+Requires-Dist: typing-extensions>=4.0; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: filelock>=3.20.3; extra == 'dev'
+Requires-Dist: ipykernel; extra == 'dev'
+Requires-Dist: jupyter-book>=2.0; extra == 'dev'
+Requires-Dist: kaleido>=0.2; extra == 'dev'
+Requires-Dist: lxml>=6.1.0; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: nbconvert>=7.17.1; extra == 'dev'
+Requires-Dist: nbmake>=1.5; extra == 'dev'
+Requires-Dist: openpyxl>=3.1; extra == 'dev'
+Requires-Dist: orjson>=3.11.6; extra == 'dev'
+Requires-Dist: pillow>=12.2.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.7; extra == 'dev'
+Requires-Dist: pyarrow>=14.0; extra == 'dev'
+Requires-Dist: pygments>=2.20.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.4; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
+Requires-Dist: requests>=2.33.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: tornado>=6.5.5; extra == 'dev'
+Requires-Dist: virtualenv>=20.36.1; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: ipykernel; extra == 'docs'
+Requires-Dist: jupyter-book>=2.0; extra == 'docs'
+Requires-Dist: lxml>=6.1.0; extra == 'docs'
+Requires-Dist: nbconvert>=7.17.1; extra == 'docs'
+Requires-Dist: orjson>=3.11.6; extra == 'docs'
+Requires-Dist: pillow>=12.2.0; extra == 'docs'
+Requires-Dist: pygments>=2.20.0; extra == 'docs'
+Requires-Dist: requests>=2.33.0; extra == 'docs'
+Requires-Dist: tornado>=6.5.5; extra == 'docs'
+Provides-Extra: excel
+Requires-Dist: openpyxl>=3.1; extra == 'excel'
+Provides-Extra: images
+Requires-Dist: kaleido>=0.2; extra == 'images'
+Provides-Extra: lint
+Requires-Dist: filelock>=3.20.3; extra == 'lint'
+Requires-Dist: mypy>=1.10; extra == 'lint'
+Requires-Dist: pre-commit>=3.7; extra == 'lint'
+Requires-Dist: ruff>=0.5; extra == 'lint'
+Requires-Dist: virtualenv>=20.36.1; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: nbmake>=1.5; extra == 'test'
+Requires-Dist: openpyxl>=3.1; extra == 'test'
+Requires-Dist: pyarrow>=14.0; extra == 'test'
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest-timeout>=2.4; extra == 'test'
+Requires-Dist: pytest>=9.0.3; extra == 'test'
+Description-Content-Type: text/markdown
+
+# processbehavior
+
+[![PyPI version](https://img.shields.io/pypi/v/processbehavior.svg)](https://pypi.org/project/processbehavior/)
+[![Python versions](https://img.shields.io/pypi/pyversions/processbehavior.svg)](https://pypi.org/project/processbehavior/)
+[![CI](https://github.com/cnicholas/processbehavior/actions/workflows/ci.yml/badge.svg)](https://github.com/cnicholas/processbehavior/actions/workflows/ci.yml)
+[![License](https://img.shields.io/pypi/l/processbehavior.svg)](https://github.com/cnicholas/processbehavior/blob/main/LICENSE)
+
+A Python library for **Process Behavior Analysis** following Thomas A. Bishop's Variance Analysis System (VAS) methodology.
+
+Unlike traditional SPC packages, processbehavior faithfully implements Bishop's VAS equation-by-equation: automatic detection of the three-state design lineage (PDS / ODS / ADS), variance decomposition via R1-R6 residuals, and chart selection routed by the data your study can actually analyze.
+
+## Installation
+
+```bash
+pip install processbehavior
+```
+
+Plotting (plotly) is included. For Excel export and static image export, install the corresponding extras:
+
+```bash
+pip install "processbehavior[excel]"   # openpyxl, for result.to_excel(...)
+pip install "processbehavior[images]"  # kaleido, for static plot images
+```
+
+## Quickstart
+
+```python
+import processbehavior as pb
+
+# Generate a sample dataset (replace with your own DataFrame)
+df = pb.make_design(state=1, seed=42)
+# Columns: 'time', 'factor 1', 'factor 2', 'y'
+
+# Formulate — detects PDS / ODS / ADS and builds the analysis dataset
+study = pb.formulate(
+    df,
+    response='y',
+    time='time',
+    factors=['factor 1', 'factor 2'],
+)
+print(f"Observed:   ODS {study.observed_design_state.sds}")
+print(f"Analytical: ADS {study.analytical_design_state.sds}")
+print(f"Recommended chart: {study.recommended_chart}")
+
+# Execute analysis (routes by ADS)
+result = study.execute()                       # uses the recommended chart
+stats = result.statistics('Xbar')              # always {'N', 'center', 'lpl', 'upl'}
+print(f"Center: {stats['center']}")
+
+# When subgroup sizes differ the limits differ per subgroup, so the scalar
+# 'lpl'/'upl' are None and stats['limits_vary'] is True. The per-subgroup
+# limits live in the chart table:
+print(result.get_chart('Xbar')[['center', 'lpl', 'upl']].head())
+
+# Plot (interactive plotly figure)
+result.plot()
+
+# Export to Excel (requires the [excel] extra)
+result.to_excel('analysis.xlsx')
+```
+
+The whole pipeline is one expression when you don't need the intermediate objects:
+
+```python
+pb.formulate(df, response='y', factors=['factor 1'], time='time').execute().plot()
+```
+
+Use `pb.ProcessBehavior(df)` directly when you want the fluent derived-variable verbs
+(`.transform(...)`, `.bin(...)`), which attach before formulating. With that object in hand,
+`pbd.cols.<column_name>` provides IDE auto-completion for column references.
+
+## Key Concepts
+
+### Two-Step Workflow
+
+The API mirrors how analysts think:
+
+1. **`formulate()`** - Understand your data structure. Detects PDS / ODS / ADS, identifies valid charts, and computes residuals. This is the expensive step.
+2. **`execute()`** - Run analysis. Produces charts from the pre-computed data. This is cheap and can be called multiple times for different charts from the same study.
+
+### Design-State Lineage (PDS / ODS / ADS)
+
+processbehavior reports three design states at three points in the analysis lifecycle:
+
+| State | Computed from | Codomain | Meaning |
+|-------|---------------|----------|---------|
+| **PDS** — Planned | Your declared `factors` and `time` (or an explicit `plan=`) | {1, 2} | What you intended to collect |
+| **ODS** — Observed | Raw data, before NA filtering | {1..6} | What was actually collected (cells with all-NA responses count as "attempted but empty") |
+| **ADS** — Analytical | Tidy data, after NA filtering | {0, 1, 2, 3} | What survives tidying; **drives chart selection, residual availability, and variance decomposition** |
+
+The integer codes are Bishop's reference scale ("Bishop Table 1"):
+
+| Code | Cell Sizes (N_kt) |
+|------|--------------------|
+| 1 | Complete grid, all N_kt >= 2 (full replication) |
+| 2 | Complete grid, all N_kt = 1 (no replication) |
+| 3 | Complete grid, mix of N_kt = 1 and N_kt >= 2 |
+| 4 | Incomplete grid, occupied cells N_kt >= 2 |
+| 5 | Incomplete grid, occupied cells N_kt = 1 |
+| 6 | Incomplete grid, mixed N_kt |
+
+ODS values in {4, 5, 6} collapse to ADS values in {1, 2, 3} during tidying (empty cells drop and the surviving subset becomes the analytical grid).
+
+Access the lineage on a formulated study:
+
+```python
+study.plan_design_state        # PDS (when a plan was supplied)
+study.observed_design_state    # ODS — what the raw data showed
+study.analytical_design_state  # ADS — what the analysis is fit for
+study.design()                 # DesignReport: full lineage in one object
+```
+
+### Residual System (R1-R6)
+
+For factorial designs (ADS 1-3), processbehavior decomposes variation into diagnostic residuals:
+
+- **R1** - The response centered at 0 (Bishop §13.1); the building block for the rest
+- **R2** - Within-cell noise (measurement error, short-term fluctuation)
+- **R3** - Interaction between design conditions and time
+- **R4** - Time main effects (trends, seasonality, batch effects)
+- **R5** - Design condition main effects, all factors combined
+- **R6** - A single design factor's main effect (machine-to-machine, operator bias)
+
+```python
+# Chart any residual
+result = study.execute(chart='Xbar', value='R4')  # Time main effects
+result = study.execute(chart='Xbar', value='R5')  # Design condition main effects
+result = study.execute(chart='Xbar', value='R6', by=['machine'])  # One factor's effect
+```
+
+Not every chart pairs with every residual — the valid pairs depend on the ADS.
+`study.residual_charts` lists them, and `study.why_not('X', value='R4')` explains
+any pair it refuses.
+
+### Stratified Analysis
+
+For X/mR charts with grouping factors, processbehavior produces a single combined chart with per-stratum limits:
+
+```python
+result = study.execute(chart='X', by=['machine'])
+
+# Drill into a specific stratum
+for stratum in result.strata:
+    focused = result.focus(stratum)
+    focused.plot()
+```
+
+## Validation
+
+processbehavior's analytical outputs are continuously verified against Dr. Thomas A. Bishop's Minitab reference results. The validator at `validation/e2e_bishop_report.py` runs **280 numerical assertions** through the full formulate → execute → capability / loss / maximum-information pipeline:
+
+| Analytical Design State | Datasets validated | Assertions | Status |
+|---|---|---|---|
+| ADS 1 (full replication) | `PM SDS 1` from `PBTESTDATABASE_T100.csv` | 102 | ✅ all pass |
+| ADS 2 (no replication) | `PM SDS 2` | 89 | ✅ all pass |
+| ADS 3 (partial replication) | `PM SDS 3` | 89 | ✅ all pass |
+
+Reference data is Bishop's published Minitab golden output. The library matches every chart center, control limit, signal classification, capability index, and loss-function value to within the precision Bishop reports.
+
+ODS 4–6 (incomplete-grid scenarios) are detected and routed correctly but their end-to-end Bishop-reference coverage is pending. The synthetic generators in `make_design(state=4|5|6)` produce data with the structural shape Bishop's Table 1 specifies; full numerical validation against Bishop's incomplete-grid Minitab output is on the roadmap (issue #109).
+
+The full report renders to `validation/e2e_bishop_report.html`.
+
+## Features
+
+- **Three-state lineage**: PDS / ODS / ADS detected automatically; chart selection routes by ADS
+- **Correct charts**: Xbar-S, X (Individual), mR (Moving Range), Histogram with proper limit calculations
+- **Variance decomposition**: R1-R6 residuals for factorial designs
+- **Effects analysis**: Main effects, time effects, and interaction effects
+- **Stratified charts**: Automatic per-stratum limits for grouped individual data
+- **Signal detection**: all eight Western Electric rules on X/mR; Rule 1 (3-sigma) on Xbar/S, where the run- and zone-based rules need a time order that subgroup comparisons don't have
+- **Beyond the charts**: capability indices (Cp/Cpk/Pp/Ppk), Taguchi loss decomposition, and maximum-information analysis — validated in the same Bishop-reference CI gate
+- **IDE support**: Column auto-completion via `ProcessBehavior(df).cols`
+- **Self-diagnostic errors**: Helpful messages that say what's available and how to fix it
+- **Excel export**: Publication-ready workbooks with charts and statistics
+- **Interactive plots**: Plotly-based charts with hover details
+
+## Scope
+
+processbehavior is the **computational engine** for Bishop's VAS methodology. It handles data ingestion, design-state lineage detection (PDS / ODS / ADS), residual computation, chart generation, and export.
+
+For the **curated analyst experience** — guided workflows, interactive dashboards, and collaboration features — see [processbehavior.com](https://processbehavior.com).
+
+For the **methodological foundation** — the theory behind VAS, design-state classification, and residual interpretation — see Bishop's published book below and the forthcoming book by Dr. Thomas A. Bishop and Chris Nicholas.
+
+## References
+
+The methodology this library implements:
+
+> Bishop, Thomas A. (2021). *[The Scientific Basis for Modern Analytic Practice](https://www.lulu.com/shop/thomas-bishop/the-scientific-basis-for-modern-analytic-practice/paperback/product-k7e8dk.html)*. Lulu Press. 279 pp.
+
+To cite the software itself, see [`CITATION.cff`](CITATION.cff).
+
+## License
+
+Apache 2.0

processbehavior-0.2.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+processbehavior/__init__.py,sha256=t0ESK8AXsRqRavP_7hZqD6Has5jIAX21sS90t5EFgeU,4097
+processbehavior/analysis.py,sha256=huEz6DxbAqgduuVYZKnijnJtrhLkvqmtOYClZX3iIJo,117738
+processbehavior/analysis_dataset.py,sha256=YBAKCh87dU9xNh89q33YVeZ_rT3bHG3iO6J1zhgyoH4,15040
+processbehavior/analysis_result.py,sha256=TCAOFT8De6wjIxALirIqbPFsnwgm6E1rDYQeLHCJjqI,46141
+processbehavior/calibration.py,sha256=0vZ6XxezPjk8hfDNf8p4TBt5XynnceSFMEH-F_REWpI,2841
+processbehavior/capability.py,sha256=xlPnPxhrzlKpRbi_ikTzvEPF5ceLjce9tgAlx5-ZzUw,24639
+processbehavior/data_preparation.py,sha256=XOBi3Kpdq_h2-pSHl5YhZyE57BCAVYv--hQN7DioILo,30808
+processbehavior/derivations.py,sha256=YJSy97GqR7khjlv4TU8TOAfr5K97NHbXm0LgvSt_3Oo,23684
+processbehavior/effects_calculator.py,sha256=D75tEY5IprLHUfgQpMAJT_zcqn9w7bVTLTvS8kzV_Mw,19234
+processbehavior/exceptions.py,sha256=Xxe_CMGcl7-B7tqfCpzrSc72RgixBTeXYK181-8arBg,6944
+processbehavior/focused_result.py,sha256=0IAUXvp1iD_uQy_ol4LnxeYu9yGO67IWsUYwLJdpHFE,12637
+processbehavior/formulation_spec.py,sha256=rnwxpy5Ms10NDuQbim4GUtsmjkdhaWMC_TzYT7T-nbw,4725
+processbehavior/loss_function.py,sha256=2z-xvE1UomxSRdh3HQ01D2_GC_cSAr9HkquVKkuEO04,16621
+processbehavior/maximum_information.py,sha256=UWj_Nw34XN1CuUF8OwbrbykSRtaz_aSL4EXoiRxs_Vo,7964
+processbehavior/process_behavior.py,sha256=YV_XJtZyUQZw9Y5wBa5CXAGpDr9wvbkHOEr3W0fYm24,51327
+processbehavior/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+processbehavior/residual_calculator.py,sha256=OlBq3717rHANeb_AsiZXYu1rFRbBnXatO1RAyrtoN64,18546
+processbehavior/result_signals.py,sha256=i4FI5VWkVREU-tEzX-JVoDinpf009MKq41GwALUnMPM,5000
+processbehavior/result_tabular.py,sha256=DQdvAqEjTY8v4cSP3xpeLcczL9DH32wW7s99qfnPe8c,10796
+processbehavior/sds_detector.py,sha256=BE5k9KDgNd-IMTFbTPOqt-Ln4kRLzyo5FyApjAWQr8k,55861
+processbehavior/spc_constants.py,sha256=puWrLDe9FrLnBqAKbzPHM8uDv4TZUySj1F_aIHQWjkU,24498
+processbehavior/study.py,sha256=ZpjMrCzM68d6ha1ZxcZgNAFyJQ-5ErlcYTqj_bE7mJo,107611
+processbehavior/types.py,sha256=WjDDSQMrH6SzZfQwgXIWdvpb823DXQ_HsTQz_8Sw-g4,5015
+processbehavior/datasets/__init__.py,sha256=tRHsamUxYQU1lbFQSynPO3e7dBOmeOrRJdNrzB1OMTw,694
+processbehavior/datasets/loaders.py,sha256=9HuK2kdbjYWFtaZG5xhRXhUQqoVR3Y6XAZgl7CJ0_vg,2945
+processbehavior/datasets/synthetic.py,sha256=tt6Cq66yHz8YSqzZK5U_6qrN69YLuc1vWLjgxpeuS54,63910
+processbehavior/datasets/data/coffee_shop_demo_long.csv,sha256=0NdPqhs_TqodFoCYKCICprpuDwv9yNw_c0aUWDi6EHM,15486
+processbehavior/exporters/__init__.py,sha256=Mqr4EaLtz7ILkMUijZ19uxa8indyiR-fwCxh6ZHhwus,110
+processbehavior/exporters/excel_exporter.py,sha256=W060uld632sAGXZwtMYAyu_i6ysock18T2YGzWHoGHw,29884
+processbehavior/plotting/__init__.py,sha256=b0qEpYUIZFNXY8wX1MXZN5Lq_Gt2PnIQPdkfy6OlcgA,1506
+processbehavior/plotting/_math.py,sha256=jAnMadBVt58L5LnYN96ZDLUnEv8TjFnYCFz3aIaxgOU,3311
+processbehavior/plotting/capability_chart.py,sha256=BXQ_yNBb03z65Ar6a9T1G-zOvruelZcLhAmVSePI7lE,27572
+processbehavior/plotting/contracts.py,sha256=D5PF3GLCp8K8y9FQbo8etVK7HsngsxdqiVoOJ46FSBE,5130
+processbehavior/plotting/control_chart.py,sha256=0y1QY18K3wKXXiETSjiFpSpiwt6nISuOd1q6tN-JycY,7455
+processbehavior/plotting/effects_charts.py,sha256=DPH_frTjp9w-bugeKQrMLwee1hjWBXHmCGr1Qt8aKfs,19495
+processbehavior/plotting/lane_boundaries.py,sha256=AkiDB2FWYfFfgkN-dxEIWijSNnzBIiwKHnqV-ODHe_E,2309
+processbehavior/plotting/limits.py,sha256=2Fu6qTV3-7GedDeR_sXxA4SRvw-5RwMi40ud5PWhxv0,4211
+processbehavior/plotting/maximum_information_chart.py,sha256=vCfgnyZkN8pG_K0t_xiYAxX6i40tFpuu5a8kYM0em_0,11157
+processbehavior/plotting/plotter.py,sha256=PUO8L-lK-Lr7Ys8RhITgW666LcM2tEC7hzHVZa82hgQ,52853
+processbehavior/plotting/renderers.py,sha256=l-5fKgBYyOkZbDcin_VglhhnO9oZ2qZ0FcLznXcXOik,20651
+processbehavior/plotting/report.py,sha256=y3d0Zwfr1p9w1Dm02KV1-qhKcV6GeUJi8VhCzGukaw8,6725
+processbehavior/plotting/residuals.py,sha256=4V2oBFV8yi1H2kpoC0irouOQNvE2mHQNd828b3cKg2Q,8573
+processbehavior/plotting/run_rules_viz.py,sha256=gsAMIql9-fXp4VxDthB8V1pEBlGm3N63GBy5wH9__AE,4428
+processbehavior/plotting/stats_box.py,sha256=tuJZkMh6KFkfRX7WdLM76O-dw-QuxHxBuQia5qot-1E,5450
+processbehavior/plotting/themes.py,sha256=z1Pvxvfb28ZB1Wcvu98mRYvR7QvAetqGdL7URBzN1lc,16090
+processbehavior/plotting/x_axis_layout.py,sha256=B3TG65vndWPqaNLJKjxkZgxRXJE86I9_BbKgvRuWZj8,17310
+processbehavior/plotting/zones.py,sha256=i7bHGkPT6rGV4z3xn8Pmm3pUdEHQDJayYM5OeD7tD_E,3793
+processbehavior/signals/__init__.py,sha256=CK07shlXxUFUzeo57qIiyMxGgi72Sq87sN3pOWbOYTU,430
+processbehavior/signals/config.py,sha256=x2enUInz9_n_-1F5lAuJExQEr_m1iNlEHGWEpl1P0x4,12728
+processbehavior/signals/detector.py,sha256=nMQ1EMs1C2uNQRS-v1Y174QBGBW2cO-Z1a-Oxx4rNsY,12097
+processbehavior/signals/detectors.py,sha256=ia-LHfS4fKkN4DZ2kZBvc_Z04em-FoVGu9xB09VuMVU,10203
+processbehavior/signals/result.py,sha256=wN2PIG_ASYFvLQlPrDwujm9lBfWWRsLSLfTyzEgeCIc,6875
+processbehavior-0.2.0.dist-info/METADATA,sha256=hsrVC4c1DwG5qbfjm5REhUhXor-YN-zEEMBgCKwPrjA,13388
+processbehavior-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+processbehavior-0.2.0.dist-info/licenses/LICENSE,sha256=GgI9nWoMCj2vWn2iisJHcHK_uYHWZ76s9jRsedoO_Wc,11281
+processbehavior-0.2.0.dist-info/RECORD,,

processbehavior-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any