tlf-correlation-engine 0.1.0__tar.gz

tlf_correlation_engine-0.1.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Sanchita Karki
+
+Permission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tlf_correlation_engine-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: tlf-correlation-engine
+Version: 0.1.0
+Summary: Country-agnostic Pearson/Spearman/Kendall correlation analysis over pandas DataFrames — part of The Living Facts (TLF).
+Author-email: Sanchita Karki <karkisanchu06@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ctpl-git/TLF-Data-Analysis
+Project-URL: Repository, https://github.com/ctpl-git/TLF-Data-Analysis
+Project-URL: Issues, https://github.com/ctpl-git/TLF-Data-Analysis/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5
+Requires-Dist: scipy>=1.9
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: questionary>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# tlf-correlation-engine
+
+Country-agnostic correlation analysis — part of **TLF** ("The Living Facts").
+
+Computes Pearson, Spearman, or Kendall correlations across any pandas
+DataFrame's numeric columns, along with p-values and observation counts,
+and produces a sorted, filterable long-form report of the strongest and
+most statistically significant relationships in a dataset.
+
+Unlike `tlf-census-stats`, this package has no dependency on a specific
+country schema — it works on any DataFrame with 2+ numeric columns.
+
+---
+
+## Install
+
+```bash
+pip install tlf-correlation-engine
+```
+
+Or from source, inside the `TLF-Data-Analysis` monorepo:
+
+```bash
+cd tlf-correlation-engine
+pip install -e ".[dev]"
+```
+
+---
+
+## Usage
+
+```python
+import pandas as pd
+from tlf_correlation_engine import CorrelationEngine
+
+df = pd.read_csv("census_data.csv")
+
+engine = CorrelationEngine(df, method="pearson")  # or "spearman" / "kendall"
+
+# Coefficient matrix (like df.corr(), but validated numeric-only)
+engine.matrix()
+
+# P-value matrix, aligned with matrix()
+engine.pvalue_matrix()
+
+# One specific pair, with n and p-value
+engine.pairwise("literacy_rate", "urban_population")
+
+# Long-form report of all pairs, strongest relationship first
+engine.report()
+
+# Only strong (|r| >= 0.5) and statistically significant (p < 0.05) pairs
+engine.report(threshold=0.5, significant_only=True)
+```
+
+### Methods
+
+| Method | Use for |
+|---|---|
+| `pearson` | Linear relationships between continuous variables |
+| `spearman` | Monotonic (rank-based) relationships, robust to outliers/non-linearity |
+| `kendall` | Rank concordance, more robust on small samples or many tied ranks |
+
+---
+
+## CLI
+
+```bash
+tlf-correlation-engine --data census.csv --method spearman --output report --export csv --export-path out.csv
+```
+
+Run with no flags at all for a fully interactive walkthrough (file path → sheet selection → method → output type → report filters → export format):
+
+```bash
+tlf-correlation-engine
+```
+
+For unattended/scripted runs, `--yes` disables all prompting and fails loudly (rather than silently guessing) if something required — like `--data` — is missing:
+
+```bash
+tlf-correlation-engine --data census.csv --yes --method pearson --output matrix
+```
+
+### CLI flags
+
+| Flag | Description |
+|---|---|
+| `--data` | Path to a CSV, Excel, or JSON file |
+| `--sheet` | Excel sheet name (default: first sheet) |
+| `--method` | `pearson` \| `spearman` \| `kendall` |
+| `--output` | `report` \| `matrix` \| `pvalues` |
+| `--threshold` | Report only: minimum \|coefficient\| to include |
+| `--significant-only` | Report only: only include pairs with p < `--alpha` |
+| `--alpha` | Significance threshold for `--significant-only` (default 0.05) |
+| `--export` | `csv` \| `json` |
+| `--export-path` | Export file path |
+| `--yes` | Non-interactive mode: never prompt, error on missing required values |
+
+---
+
+## Errors
+
+- `InvalidMethodError` — unsupported `method` value
+- `InsufficientDataError` — fewer than 2 numeric columns in the DataFrame
+
+---
+
+## License
+
+MIT — see `LICENSE`.

tlf_correlation_engine-0.1.0/README.md

@@ -0,0 +1,110 @@
+# tlf-correlation-engine
+
+Country-agnostic correlation analysis — part of **TLF** ("The Living Facts").
+
+Computes Pearson, Spearman, or Kendall correlations across any pandas
+DataFrame's numeric columns, along with p-values and observation counts,
+and produces a sorted, filterable long-form report of the strongest and
+most statistically significant relationships in a dataset.
+
+Unlike `tlf-census-stats`, this package has no dependency on a specific
+country schema — it works on any DataFrame with 2+ numeric columns.
+
+---
+
+## Install
+
+```bash
+pip install tlf-correlation-engine
+```
+
+Or from source, inside the `TLF-Data-Analysis` monorepo:
+
+```bash
+cd tlf-correlation-engine
+pip install -e ".[dev]"
+```
+
+---
+
+## Usage
+
+```python
+import pandas as pd
+from tlf_correlation_engine import CorrelationEngine
+
+df = pd.read_csv("census_data.csv")
+
+engine = CorrelationEngine(df, method="pearson")  # or "spearman" / "kendall"
+
+# Coefficient matrix (like df.corr(), but validated numeric-only)
+engine.matrix()
+
+# P-value matrix, aligned with matrix()
+engine.pvalue_matrix()
+
+# One specific pair, with n and p-value
+engine.pairwise("literacy_rate", "urban_population")
+
+# Long-form report of all pairs, strongest relationship first
+engine.report()
+
+# Only strong (|r| >= 0.5) and statistically significant (p < 0.05) pairs
+engine.report(threshold=0.5, significant_only=True)
+```
+
+### Methods
+
+| Method | Use for |
+|---|---|
+| `pearson` | Linear relationships between continuous variables |
+| `spearman` | Monotonic (rank-based) relationships, robust to outliers/non-linearity |
+| `kendall` | Rank concordance, more robust on small samples or many tied ranks |
+
+---
+
+## CLI
+
+```bash
+tlf-correlation-engine --data census.csv --method spearman --output report --export csv --export-path out.csv
+```
+
+Run with no flags at all for a fully interactive walkthrough (file path → sheet selection → method → output type → report filters → export format):
+
+```bash
+tlf-correlation-engine
+```
+
+For unattended/scripted runs, `--yes` disables all prompting and fails loudly (rather than silently guessing) if something required — like `--data` — is missing:
+
+```bash
+tlf-correlation-engine --data census.csv --yes --method pearson --output matrix
+```
+
+### CLI flags
+
+| Flag | Description |
+|---|---|
+| `--data` | Path to a CSV, Excel, or JSON file |
+| `--sheet` | Excel sheet name (default: first sheet) |
+| `--method` | `pearson` \| `spearman` \| `kendall` |
+| `--output` | `report` \| `matrix` \| `pvalues` |
+| `--threshold` | Report only: minimum \|coefficient\| to include |
+| `--significant-only` | Report only: only include pairs with p < `--alpha` |
+| `--alpha` | Significance threshold for `--significant-only` (default 0.05) |
+| `--export` | `csv` \| `json` |
+| `--export-path` | Export file path |
+| `--yes` | Non-interactive mode: never prompt, error on missing required values |
+
+---
+
+## Errors
+
+- `InvalidMethodError` — unsupported `method` value
+- `InsufficientDataError` — fewer than 2 numeric columns in the DataFrame
+
+---
+
+## License
+
+MIT — see `LICENSE`.

tlf_correlation_engine-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tlf-correlation-engine"
+version = "0.1.0"
+description = "Country-agnostic Pearson/Spearman/Kendall correlation analysis over pandas DataFrames — part of The Living Facts (TLF)."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Sanchita Karki", email = "karkisanchu06@gmail.com" },
+]
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+
+dependencies = [
+    "pandas>=1.5",
+    "scipy>=1.9",
+    "openpyxl>=3.1",
+    "questionary>=2.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/ctpl-git/TLF-Data-Analysis"
+Repository = "https://github.com/ctpl-git/TLF-Data-Analysis"
+Issues = "https://github.com/ctpl-git/TLF-Data-Analysis/issues"
+
+[project.scripts]
+tlf-correlation-engine = "tlf_correlation_engine.main:main"
+
+[tool.setuptools]
+packages = ["tlf_correlation_engine"]

tlf_correlation_engine-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tlf_correlation_engine-0.1.0/tests/test_engine.py

@@ -0,0 +1,183 @@
+import os
+
+import pandas as pd
+import pytest
+
+from tlf_correlation_engine import (
+    CorrelationEngine,
+    pairwise_correlation,
+    InvalidMethodError,
+    InsufficientDataError,
+)
+
+FIXTURES_DIR = os.path.join(os.path.dirname(__file__), "fixtures")
+
+
+@pytest.fixture
+def census_df():
+    return pd.read_csv(os.path.join(FIXTURES_DIR, "nepal_census_2021.csv"))
+
+
+@pytest.fixture
+def perfectly_correlated_df():
+    return pd.DataFrame({
+        "a": [1, 2, 3, 4, 5],
+        "b": [2, 4, 6, 8, 10],   # perfectly, positively correlated with a
+        "c": [10, 8, 6, 4, 2],   # perfectly, negatively correlated with a
+    })
+
+
+class TestCorrelationEngineBasics:
+    def test_rejects_invalid_method(self, census_df):
+        with pytest.raises(InvalidMethodError):
+            CorrelationEngine(census_df, method="not_a_real_method")
+
+    def test_rejects_insufficient_numeric_columns(self):
+        df = pd.DataFrame({"only_col": [1, 2, 3], "text_col": ["a", "b", "c"]})
+        with pytest.raises(InsufficientDataError):
+            CorrelationEngine(df)
+
+    def test_ignores_non_numeric_columns(self, census_df):
+        engine = CorrelationEngine(census_df)
+        assert "Province" not in engine.columns
+        assert "District" not in engine.columns
+        assert "Total Population" in engine.columns
+
+
+class TestMatrix:
+    def test_matrix_diagonal_is_one(self, census_df):
+        engine = CorrelationEngine(census_df, method="pearson")
+        matrix = engine.matrix()
+        for col in engine.columns:
+            assert matrix.loc[col, col] == pytest.approx(1.0)
+
+    def test_matrix_is_symmetric(self, census_df):
+        engine = CorrelationEngine(census_df, method="spearman")
+        matrix = engine.matrix()
+        assert matrix.equals(matrix.T)
+
+    def test_perfect_positive_and_negative_correlation(self, perfectly_correlated_df):
+        engine = CorrelationEngine(perfectly_correlated_df, method="pearson")
+        matrix = engine.matrix()
+        assert matrix.loc["a", "b"] == pytest.approx(1.0)
+        assert matrix.loc["a", "c"] == pytest.approx(-1.0)
+
+
+class TestMatrixPairwiseConsistency:
+    """Regression tests: matrix(), pvalue_matrix(), and pairwise() must
+    all apply the same MIN_OBSERVATIONS floor, so they never disagree
+    about whether a given pair's coefficient is meaningful."""
+
+    def test_matrix_is_nan_below_min_observations(self):
+        # Only 2 rows — below MIN_OBSERVATIONS (3), so this must NOT
+        # silently produce a trivial +-1.0 the way a bare df.corr() would.
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+        engine = CorrelationEngine(df, method="pearson")
+        matrix = engine.matrix()
+        assert pd.isna(matrix.loc["a", "b"])
+        assert pd.isna(matrix.loc["b", "a"])
+
+    def test_matrix_agrees_with_pairwise_below_min_observations(self):
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+        engine = CorrelationEngine(df, method="pearson")
+        matrix_value = engine.matrix().loc["a", "b"]
+        pairwise_value = engine.pairwise("a", "b")["coefficient"]
+        assert pd.isna(matrix_value) and pd.isna(pairwise_value)
+
+    def test_matrix_diagonal_is_one_even_below_min_observations(self):
+        # Self-correlation is a definitional identity, not a statistical
+        # claim — it stays 1.0 regardless of n.
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+        engine = CorrelationEngine(df, method="pearson")
+        matrix = engine.matrix()
+        assert matrix.loc["a", "a"] == 1.0
+        assert matrix.loc["b", "b"] == 1.0
+
+    def test_matrix_matches_pairwise_above_min_observations(self, census_df):
+        engine = CorrelationEngine(census_df, method="pearson")
+        matrix = engine.matrix()
+        for col_a in engine.columns:
+            for col_b in engine.columns:
+                if col_a == col_b:
+                    continue
+                pairwise_value = engine.pairwise(col_a, col_b)["coefficient"]
+                assert matrix.loc[col_a, col_b] == pytest.approx(pairwise_value, nan_ok=True)
+
+
+class TestPvalueMatrix:
+    def test_pvalue_diagonal_is_zero(self, census_df):
+        engine = CorrelationEngine(census_df)
+        pvals = engine.pvalue_matrix()
+        for col in engine.columns:
+            assert pvals.loc[col, col] == 0.0
+
+    def test_pvalue_matrix_symmetric(self, census_df):
+        engine = CorrelationEngine(census_df)
+        pvals = engine.pvalue_matrix()
+        assert pvals.equals(pvals.T)
+
+    def test_perfect_correlation_has_near_zero_pvalue(self, perfectly_correlated_df):
+        engine = CorrelationEngine(perfectly_correlated_df, method="pearson")
+        pvals = engine.pvalue_matrix()
+        assert pvals.loc["a", "b"] < 0.01
+
+
+class TestPairwise:
+    def test_pairwise_matches_matrix(self, census_df):
+        engine = CorrelationEngine(census_df, method="pearson")
+        matrix = engine.matrix()
+        result = engine.pairwise("Total Population", "Households")
+        assert result["coefficient"] == pytest.approx(matrix.loc["Total Population", "Households"])
+        assert result["n"] == len(census_df)
+
+    def test_pairwise_correlation_function_all_methods(self, perfectly_correlated_df):
+        for method in ("pearson", "spearman", "kendall"):
+            result = pairwise_correlation(
+                perfectly_correlated_df["a"], perfectly_correlated_df["b"], method=method
+            )
+            assert result["coefficient"] == pytest.approx(1.0)
+            assert result["method"] == method
+
+    def test_pairwise_correlation_rejects_invalid_method(self, perfectly_correlated_df):
+        with pytest.raises(InvalidMethodError):
+            pairwise_correlation(perfectly_correlated_df["a"], perfectly_correlated_df["b"], method="bogus")
+
+    def test_handles_missing_values_pairwise(self):
+        a = pd.Series([1, 2, None, 4, 5])
+        b = pd.Series([2, 4, 6, 8, 10])
+        result = pairwise_correlation(a, b, method="pearson")
+        assert result["n"] == 4  # the row with a None in `a` is dropped
+        assert result["coefficient"] == pytest.approx(1.0)
+
+    def test_too_few_observations_returns_nan_not_error(self):
+        a = pd.Series([1, 2])
+        b = pd.Series([3, 4])
+        result = pairwise_correlation(a, b, method="pearson")
+        assert pd.isna(result["coefficient"])
+        assert pd.isna(result["p_value"])
+        assert result["n"] == 2
+
+
+class TestReport:
+    def test_report_sorted_by_strength_descending(self, census_df):
+        engine = CorrelationEngine(census_df, method="pearson")
+        report = engine.report()
+        coefficients = report["coefficient"].abs().tolist()
+        assert coefficients == sorted(coefficients, reverse=True)
+
+    def test_report_one_row_per_unique_pair(self, census_df):
+        engine = CorrelationEngine(census_df)
+        n = len(engine.columns)
+        expected_pairs = n * (n - 1) // 2
+        report = engine.report()
+        assert len(report) == expected_pairs
+
+    def test_report_threshold_filter(self, perfectly_correlated_df):
+        engine = CorrelationEngine(perfectly_correlated_df)
+        report = engine.report(threshold=0.99)
+        assert (report["coefficient"].abs() >= 0.99).all()
+
+    def test_report_significant_only_filter(self, census_df):
+        engine = CorrelationEngine(census_df)
+        report = engine.report(significant_only=True, alpha=0.05)
+        assert (report["p_value"] < 0.05).all()

tlf_correlation_engine-0.1.0/tests/test_interactive.py

@@ -0,0 +1,118 @@
+"""
+Tests for interactive.py, using unittest.mock to stand in for
+questionary's .ask() calls — no real terminal/TTY needed.
+
+The prompt_for_export tests specifically guard against a real bug
+found during manual testing: questionary.Choice(value=None) is treated
+by questionary as "no value provided", which makes it default to the
+choice's *title text* rather than a real None. Selecting "No, just
+print to terminal" was therefore silently mistaken for a truthy export
+format, still prompting for a path and printing a false "Exported to"
+message. The fix uses a distinct sentinel ("none") instead of None.
+"""
+
+from unittest.mock import patch, MagicMock
+
+from tlf_correlation_engine import interactive
+
+
+def _mock_ask(return_value):
+    """Builds a MagicMock standing in for a questionary prompt object,
+    whose .ask() returns the given value."""
+    mock_prompt = MagicMock()
+    mock_prompt.ask.return_value = return_value
+    return mock_prompt
+
+
+class TestPromptForExport:
+    def test_selecting_no_export_skips_path_prompt_entirely(self):
+        """Regression test for the value=None bug: choosing 'No, just
+        print to terminal' must return (None, None) and must NOT go on
+        to call questionary.text() asking for an export path."""
+        with patch("questionary.select", return_value=_mock_ask("none")) as mock_select, \
+             patch("questionary.text") as mock_text:
+            fmt, path = interactive.prompt_for_export()
+
+        assert fmt is None
+        assert path is None
+        mock_text.assert_not_called()
+
+    def test_ctrl_c_during_select_also_returns_none(self):
+        """questionary returns a real None if the user hits Ctrl+C /
+        Esc mid-prompt — that must be treated the same as 'no export'."""
+        with patch("questionary.select", return_value=_mock_ask(None)), \
+             patch("questionary.text") as mock_text:
+            fmt, path = interactive.prompt_for_export()
+
+        assert fmt is None
+        assert path is None
+        mock_text.assert_not_called()
+
+    def test_selecting_csv_prompts_for_and_returns_path(self):
+        with patch("questionary.select", return_value=_mock_ask("csv")), \
+             patch("questionary.text", return_value=_mock_ask("out.csv")) as mock_text:
+            fmt, path = interactive.prompt_for_export()
+
+        assert fmt == "csv"
+        assert path == "out.csv"
+        mock_text.assert_called_once()
+
+    def test_selecting_json_prompts_for_and_returns_path(self):
+        with patch("questionary.select", return_value=_mock_ask("json")), \
+             patch("questionary.text", return_value=_mock_ask("out.json")):
+            fmt, path = interactive.prompt_for_export()
+
+        assert fmt == "json"
+        assert path == "out.json"
+
+
+class TestPromptForMethod:
+    def test_returns_selected_method_value(self):
+        with patch("questionary.select", return_value=_mock_ask("spearman")):
+            assert interactive.prompt_for_method() == "spearman"
+
+
+class TestPromptForOutput:
+    def test_returns_selected_output_value(self):
+        with patch("questionary.select", return_value=_mock_ask("matrix")):
+            assert interactive.prompt_for_output() == "matrix"
+
+
+class TestPromptForReportFilters:
+    def test_no_threshold_when_declined(self):
+        with patch("questionary.confirm", side_effect=[_mock_ask(False), _mock_ask(False)]):
+            threshold, significant_only = interactive.prompt_for_report_filters()
+
+        assert threshold is None
+        assert significant_only is False
+
+    def test_threshold_captured_when_accepted(self):
+        with patch("questionary.confirm", side_effect=[_mock_ask(True), _mock_ask(True)]), \
+             patch("questionary.text", return_value=_mock_ask("0.7")):
+            threshold, significant_only = interactive.prompt_for_report_filters()
+
+        assert threshold == 0.7
+        assert significant_only is True
+
+
+class TestPromptForSheet:
+    def test_single_sheet_returned_without_prompting(self):
+        with patch("questionary.select") as mock_select:
+            result = interactive.prompt_for_sheet(["OnlySheet"])
+
+        assert result == "OnlySheet"
+        mock_select.assert_not_called()
+
+    def test_no_sheets_returns_none_without_prompting(self):
+        with patch("questionary.select") as mock_select:
+            result = interactive.prompt_for_sheet([])
+
+        assert result is None
+        mock_select.assert_not_called()
+
+    def test_multiple_sheets_prompts_and_returns_choice(self):
+        with patch("questionary.select", return_value=_mock_ask("SheetB")) as mock_select:
+            result = interactive.prompt_for_sheet(["SheetA", "SheetB"])
+
+        assert result == "SheetB"
+        mock_select.assert_called_once()

tlf_correlation_engine-0.1.0/tlf_correlation_engine/__init__.py

@@ -0,0 +1,28 @@
+"""
+tlf-correlation-engine
+-----------------------
+Country-agnostic correlation analysis (Pearson, Spearman, Kendall) over
+any pandas DataFrame's numeric columns — coefficient matrices, p-values,
+and a sortable/filterable long-form report of relationship strength.
+Part of the TLF-Data-Analysis repo, part of the TLF ("The Living Facts")
+initiative.
+"""
+
+from .engine import CorrelationEngine, SUPPORTED_METHODS
+from .methods import pairwise_correlation
+from .loader import TabularLoader, UnsupportedFileError
+from .errors import CorrelationEngineError, InvalidMethodError, InsufficientDataError
+
+__all__ = [
+    "__version__",
+    "CorrelationEngine",
+    "SUPPORTED_METHODS",
+    "pairwise_correlation",
+    "TabularLoader",
+    "UnsupportedFileError",
+    "CorrelationEngineError",
+    "InvalidMethodError",
+    "InsufficientDataError",
+]
+
+__version__ = "0.1.0"