tangra-dataforge 0.1.0a1__py3-none-any.whl

tangra_dataforge/analyze.py

@@ -0,0 +1,83 @@
+
+"""Statistical analysis utilities for TANGRA DataForge."""
+
+import pandas as pd
+
+
+def describe_data(df: pd.DataFrame) -> pd.DataFrame:
+    """Calculate descriptive statistics for numeric columns."""
+    return df.describe()
+
+
+def calculate_percentage_change(
+    df: pd.DataFrame,
+    column: str,
+    periods: int = 1,
+) -> pd.Series:
+    """Calculate percentage change between observations."""
+    if column not in df.columns:
+        raise KeyError(f"Column not found: {column}")
+
+    if periods < 1:
+        raise ValueError("periods must be at least 1")
+
+    return df[column].pct_change(periods=periods) * 100
+
+
+def calculate_growth_rate(
+    initial_value: float,
+    final_value: float,
+) -> float:
+    """Calculate growth between two values as a percentage."""
+    if initial_value == 0:
+        raise ValueError("Initial value cannot be zero.")
+
+    return (
+        (final_value - initial_value)
+        / abs(initial_value)
+    ) * 100
+
+
+def compare_columns(
+    df: pd.DataFrame,
+    column_a: str,
+    column_b: str,
+) -> pd.DataFrame:
+    """Compare two numeric columns using absolute differences."""
+    if column_a not in df.columns or column_b not in df.columns:
+        raise KeyError("One or both columns were not found.")
+
+    result = df[[column_a, column_b]].copy()
+    result["difference"] = result[column_a] - result[column_b]
+
+    return result
+
+
+def detect_outliers(
+    df: pd.DataFrame,
+    column: str,
+    threshold: float = 1.5,
+) -> pd.DataFrame:
+    """Detect outliers using the interquartile range (IQR)."""
+    if column not in df.columns:
+        raise KeyError(f"Column not found: {column}")
+
+    if threshold <= 0:
+        raise ValueError("threshold must be positive")
+
+    values = df[column].dropna()
+
+    if values.empty:
+        return df.iloc[0:0].copy()
+
+    q1 = values.quantile(0.25)
+    q3 = values.quantile(0.75)
+    iqr = q3 - q1
+
+    lower_bound = q1 - threshold * iqr
+    upper_bound = q3 + threshold * iqr
+
+    return df[
+        (df[column] < lower_bound)
+        | (df[column] > upper_bound)
+    ].copy()

tangra_dataforge/clean.py

@@ -0,0 +1,13 @@
+"""Data cleaning utilities for TANGRA DataForge."""
+
+import pandas as pd
+
+
+def remove_duplicates(df: pd.DataFrame) -> pd.DataFrame:
+    """Remove duplicate rows and reset the index."""
+    return df.drop_duplicates().reset_index(drop=True)
+
+
+def remove_empty_rows(df: pd.DataFrame) -> pd.DataFrame:
+    """Remove rows where all values are missing."""
+    return df.dropna(how="all").reset_index(drop=True)

tangra_dataforge/collect.py

@@ -0,0 +1,66 @@
+"""Data collection utilities for TANGRA DataForge."""
+
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+def load_csv(
+    path: str | Path,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Load a CSV file into a Pandas DataFrame."""
+    return pd.read_csv(path, **kwargs)
+
+
+def load_json(
+    path: str | Path,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Load a JSON file into a Pandas DataFrame."""
+    return pd.read_json(path, **kwargs)
+
+
+def load_excel(
+    path: str | Path,
+    sheet_name: str | int = 0,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Load one Excel worksheet into a DataFrame."""
+    return pd.read_excel(
+        path,
+        sheet_name=sheet_name,
+        **kwargs,
+    )
+
+
+def fetch_api(
+    url: str,
+    *,
+    timeout: float = 15.0,
+    params: dict[str, Any] | None = None,
+) -> pd.DataFrame:
+    """Fetch a JSON array of records from a public API.
+
+    The endpoint must return a JSON list of objects.
+    """
+    import requests
+
+    response = requests.get(
+        url,
+        params=params,
+        timeout=timeout,
+    )
+    response.raise_for_status()
+
+    data = response.json()
+
+    if not isinstance(data, list) or not all(
+        isinstance(item, dict) for item in data
+    ):
+        raise ValueError(
+            "API response must be a JSON list of objects."
+        )
+
+    return pd.DataFrame(data)

tangra_dataforge/database.py

@@ -0,0 +1,48 @@
+
+
+"""DuckDB integration for TANGRA DataForge.
+
+Query Pandas DataFrames, CSV files, and Parquet datasets
+using SQL.
+"""
+
+from pathlib import Path
+
+import duckdb
+import pandas as pd
+
+
+def query_dataframe(
+    df: pd.DataFrame,
+    sql: str,
+) -> pd.DataFrame:
+    """Query a DataFrame registered as 'data'."""
+    with duckdb.connect(database=":memory:") as con:
+        con.register("data", df)
+        return con.execute(sql).fetchdf()
+
+
+def query_csv(
+    path: str | Path,
+    sql: str,
+) -> pd.DataFrame:
+    """Query a CSV file registered as 'data'."""
+    path = Path(path)
+
+    with duckdb.connect(database=":memory:") as con:
+        data = con.read_csv(str(path))
+        con.register("data", data)
+        return con.execute(sql).fetchdf()
+
+
+def query_parquet(
+    path: str | Path,
+    sql: str,
+) -> pd.DataFrame:
+    """Query a Parquet file registered as 'data'."""
+    path = Path(path)
+
+    with duckdb.connect(database=":memory:") as con:
+        data = con.read_parquet(str(path))
+        con.register("data", data)
+        return con.execute(sql).fetchdf()

tangra_dataforge/interactive.py

@@ -0,0 +1,77 @@
+
+"""Interactive data visualization for TANGRA DataForge.
+
+Create interactive Plotly charts for research,
+data journalism, and web publishing.
+"""
+
+from pathlib import Path
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+
+
+def interactive_line(
+    df: pd.DataFrame,
+    x: str,
+    y: str,
+    title: str = "",
+) -> go.Figure:
+    """Create an interactive line chart."""
+    fig = px.line(
+        df,
+        x=x,
+        y=y,
+        title=title,
+        markers=True,
+    )
+    return fig
+
+
+def interactive_bar(
+    df: pd.DataFrame,
+    x: str,
+    y: str,
+    title: str = "",
+) -> go.Figure:
+    """Create an interactive bar chart."""
+    return px.bar(df, x=x, y=y, title=title)
+
+
+def interactive_scatter(
+    df: pd.DataFrame,
+    x: str,
+    y: str,
+    title: str = "",
+    color: str | None = None,
+) -> go.Figure:
+    """Create an interactive scatter plot."""
+    return px.scatter(
+        df,
+        x=x,
+        y=y,
+        color=color,
+        title=title,
+    )
+
+
+def save_interactive_chart(
+    fig: go.Figure,
+    path: str | Path,
+) -> Path:
+    """Export an interactive chart as standalone HTML."""
+    path = Path(path)
+
+    if path.suffix.lower() != ".html":
+        raise ValueError("Output file must have an .html extension.")
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    fig.write_html(
+        str(path),
+        include_plotlyjs=True,
+        full_html=True,
+    )
+
+    return path

tangra_dataforge/pipeline.py

@@ -0,0 +1,121 @@
+
+"""Reproducible data processing pipelines for TANGRA DataForge."""
+
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from tangra_dataforge.collect import load_csv, load_json
+from tangra_dataforge.clean import (
+    remove_duplicates,
+    remove_empty_rows,
+)
+from tangra_dataforge.analyze import describe_data
+from tangra_dataforge.visualize import line_chart, save_chart
+from tangra_dataforge.provenance import (
+    create_record,
+    save_record,
+)
+
+
+def run_pipeline(
+    input_path: str | Path,
+    output_dir: str | Path,
+    *,
+    source_url: str | None = None,
+    chart_x: str | None = None,
+    chart_y: str | None = None,
+) -> dict[str, Any]:
+    """Run a reproducible data analysis pipeline.
+
+    Supports CSV and JSON inputs. Outputs cleaned data,
+    descriptive statistics, optional visualization and
+    a provenance record.
+    """
+    input_path = Path(input_path)
+    output_dir = Path(output_dir)
+
+    if not input_path.is_file():
+        raise FileNotFoundError(input_path)
+
+    if input_path.suffix.lower() == ".csv":
+        df = load_csv(input_path)
+    elif input_path.suffix.lower() == ".json":
+        df = load_json(input_path)
+    else:
+        raise ValueError("Supported formats: CSV and JSON.")
+
+    original_rows = len(df)
+
+    df = remove_duplicates(df)
+    df = remove_empty_rows(df)
+
+    if (chart_x is None) != (chart_y is None):
+        raise ValueError(
+            "Both chart_x and chart_y must be provided."
+        )
+
+    if chart_x is not None:
+        missing = {
+            chart_x, chart_y
+        } - set(df.columns)
+
+        if missing:
+            raise KeyError(f"Missing chart columns: {missing}")
+
+    statistics = describe_data(df) if not df.empty else pd.DataFrame()
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    cleaned_path = output_dir / "cleaned_data.csv"
+    stats_path = output_dir / "statistics.csv"
+    provenance_path = output_dir / "provenance.json"
+
+    df.to_csv(cleaned_path, index=False)
+    statistics.to_csv(stats_path)
+
+    chart_path = None
+
+    if chart_x is not None and not df.empty:
+        import matplotlib.pyplot as plt
+
+        chart_path = output_dir / "chart.png"
+
+        fig = line_chart(
+            df,
+            chart_x,
+            chart_y,
+            title=f"{chart_y} by {chart_x}",
+        )
+        try:
+            save_chart(fig, chart_path)
+        finally:
+            plt.close(fig)
+
+    record = create_record(
+        source_url or input_path.resolve().as_uri(),
+        input_path,
+        transformations=[
+            "Removed duplicate rows",
+            "Removed completely empty rows",
+            "Calculated descriptive statistics",
+        ],
+    )
+
+    record["original_rows"] = original_rows
+    record["processed_rows"] = len(df)
+    record["outputs"] = {
+        "cleaned_data": str(cleaned_path),
+        "statistics": str(stats_path),
+        "chart": str(chart_path) if chart_path else None,
+    }
+
+    save_record(record, provenance_path)
+
+    return {
+        "data": df,
+        "statistics": statistics,
+        "provenance": record,
+        "output_dir": output_dir,
+    }

tangra_dataforge/provenance.py

@@ -0,0 +1,53 @@
+
+"""Dataset provenance tracking for TANGRA DataForge."""
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def file_checksum(path: str | Path) -> str:
+    """Calculate a SHA-256 checksum for a dataset."""
+    digest = hashlib.sha256()
+
+    with open(path, "rb") as file:
+        for chunk in iter(lambda: file.read(65536), b""):
+            digest.update(chunk)
+
+    return digest.hexdigest()
+
+
+def create_record(
+    source_url: str,
+    dataset_path: str | Path,
+    transformations: list[str] | None = None,
+) -> dict[str, Any]:
+    """Create a reproducible dataset provenance record."""
+    path = Path(dataset_path)
+
+    return {
+        "source_url": source_url,
+        "dataset": path.name,
+        "collected_at": datetime.now(
+            timezone.utc
+        ).isoformat(),
+        "sha256": file_checksum(path),
+        "transformations": transformations or [],
+    }
+
+
+def save_record(
+    record: dict[str, Any],
+    output_path: str | Path,
+) -> None:
+    """Save a provenance record as JSON."""
+    path = Path(output_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    path.write_text(
+        json.dumps(record, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+

tangra_dataforge/scrape.py

@@ -0,0 +1,90 @@
+
+"""Web scraping utilities for TANGRA DataForge.
+
+Extract structured information from web pages using Scrapy
+and convert the collected records into Pandas DataFrames.
+"""
+
+from typing import Any
+
+import pandas as pd
+
+
+def extract_data(
+    html: str,
+    selectors: dict[str, str],
+) -> pd.DataFrame:
+    """Extract fields from an HTML document using CSS selectors.
+
+    Each CSS selector extracts text from matching elements.
+    Fields are aligned by their order in the document.
+    Missing values are represented by None.
+    """
+    from scrapy import Selector
+
+    if not selectors:
+        raise ValueError("At least one selector is required.")
+
+    selector = Selector(text=html)
+    extracted = {}
+
+    for field, css in selectors.items():
+        values = selector.css(css).getall()
+        extracted[field] = [
+            Selector(text=value).xpath("string(.)").get(
+                default=""
+            ).strip()
+            for value in values
+        ]
+
+    max_length = max(
+        (len(values) for values in extracted.values()),
+        default=0,
+    )
+
+    for field, values in extracted.items():
+        values.extend([None] * (max_length - len(values)))
+
+    return pd.DataFrame(extracted)
+
+
+def extract_links(
+    html: str,
+    base_url: str,
+) -> list[str]:
+    """Extract and normalize links from an HTML document."""
+    from urllib.parse import urljoin, urlparse
+    from scrapy import Selector
+
+    selector = Selector(text=html)
+    links = []
+
+    for href in selector.css("a::attr(href)").getall():
+        url = urljoin(base_url, href)
+
+        if urlparse(url).scheme not in ("http", "https"):
+            continue
+
+        if url not in links:
+            links.append(url)
+
+    return links
+
+
+def extract_table(html: str) -> pd.DataFrame:
+    """Extract the first HTML table into a DataFrame."""
+    from io import StringIO
+
+    tables = pd.read_html(StringIO(html))
+
+    if not tables:
+        raise ValueError("No HTML tables found.")
+
+    return tables[0]
+
+
+def records_to_dataframe(
+    records: list[dict[str, Any]],
+) -> pd.DataFrame:
+    """Convert scraped records into a Pandas DataFrame."""
+    return pd.DataFrame.from_records(records)

tangra_dataforge/statistics.py

@@ -0,0 +1,158 @@
+
+"""Statistical research utilities for TANGRA DataForge.
+
+Correlation analysis, hypothesis testing, confidence
+intervals, and distribution analysis using SciPy.
+"""
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+
+def _paired_values(
+    df: pd.DataFrame,
+    column_a: str,
+    column_b: str,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return numeric pairs after removing missing observations."""
+    pairs = df[[column_a, column_b]].dropna()
+
+    a = pairs[column_a].to_numpy(dtype=float)
+    b = pairs[column_b].to_numpy(dtype=float)
+
+    if not np.isfinite(a).all() or not np.isfinite(b).all():
+        raise ValueError("Values must be finite.")
+
+    return a, b
+
+
+def pearson_correlation(
+    df: pd.DataFrame,
+    column_a: str,
+    column_b: str,
+) -> dict[str, float]:
+    """Calculate Pearson's linear correlation and p-value."""
+    a, b = _paired_values(df, column_a, column_b)
+
+    if len(a) < 3:
+        raise ValueError("At least 3 valid pairs are required.")
+
+    result = stats.pearsonr(a, b)
+
+    return {
+        "correlation": float(result.statistic),
+        "p_value": float(result.pvalue),
+        "sample_size": len(a),
+    }
+
+
+def spearman_correlation(
+    df: pd.DataFrame,
+    column_a: str,
+    column_b: str,
+) -> dict[str, float]:
+    """Calculate Spearman's rank correlation and p-value."""
+    a, b = _paired_values(df, column_a, column_b)
+
+    if len(a) < 3:
+        raise ValueError("At least 3 valid pairs are required.")
+
+    result = stats.spearmanr(a, b)
+
+    return {
+        "correlation": float(result.statistic),
+        "p_value": float(result.pvalue),
+        "sample_size": len(a),
+    }
+
+
+def compare_means(
+    group_a: pd.Series,
+    group_b: pd.Series,
+) -> dict[str, float]:
+    """Compare independent group means using Welch's t-test."""
+    a = np.asarray(pd.to_numeric(group_a.dropna()), dtype=float)
+    b = np.asarray(pd.to_numeric(group_b.dropna()), dtype=float)
+
+    if len(a) < 2 or len(b) < 2:
+        raise ValueError("Each group requires at least 2 values.")
+
+    if not np.isfinite(a).all() or not np.isfinite(b).all():
+        raise ValueError("Values must be finite.")
+
+    result = stats.ttest_ind(
+        a,
+        b,
+        equal_var=False,
+    )
+
+    return {
+        "mean_a": float(np.mean(a)),
+        "mean_b": float(np.mean(b)),
+        "t_statistic": float(result.statistic),
+        "p_value": float(result.pvalue),
+    }
+
+
+def confidence_interval(
+    values: pd.Series,
+    confidence: float = 0.95,
+) -> tuple[float, float]:
+    """Calculate a Student's t confidence interval for the mean."""
+    if not 0 < confidence < 1:
+        raise ValueError("confidence must be between 0 and 1.")
+
+    data = np.asarray(
+        pd.to_numeric(values.dropna()),
+        dtype=float,
+    )
+
+    if len(data) < 2:
+        raise ValueError("At least 2 values are required.")
+
+    if not np.isfinite(data).all():
+        raise ValueError("Values must be finite.")
+
+    mean = float(np.mean(data))
+    sem = float(stats.sem(data))
+
+    if sem == 0:
+        return mean, mean
+
+    lower, upper = stats.t.interval(
+        confidence=confidence,
+        df=len(data) - 1,
+        loc=mean,
+        scale=sem,
+    )
+
+    return float(lower), float(upper)
+
+
+def normality_test(
+    values: pd.Series,
+) -> dict[str, float]:
+    """Perform the Shapiro-Wilk normality test."""
+    data = np.asarray(
+        pd.to_numeric(values.dropna()),
+        dtype=float,
+    )
+
+    if not 3 <= len(data) <= 5000:
+        raise ValueError(
+            "Shapiro-Wilk requires 3 to 5000 observations."
+        )
+
+    if not np.isfinite(data).all():
+        raise ValueError("Values must be finite.")
+
+    result = stats.shapiro(data)
+
+    return {
+        "statistic": float(result.statistic),
+        "p_value": float(result.pvalue),
+        "sample_size": len(data),
+    }

tangra_dataforge/validate.py

@@ -0,0 +1,128 @@
+
+"""Data quality validation utilities for TANGRA DataForge.
+
+Validate datasets before statistical analysis,
+visualization, and investigative research.
+"""
+
+from typing import Any
+
+import pandas as pd
+from pandas.api.types import is_numeric_dtype
+
+
+def check_required_columns(
+    df: pd.DataFrame,
+    required: list[str],
+) -> list[str]:
+    """Return the names of missing required columns."""
+    return [col for col in required if col not in df.columns]
+
+
+def check_missing_values(
+    df: pd.DataFrame,
+) -> pd.DataFrame:
+    """Report missing values for every column."""
+    total = df.isna().sum()
+
+    percentage = (
+        total / len(df) * 100
+        if len(df)
+        else total.astype(float)
+    )
+
+    return pd.DataFrame({
+        "column": df.columns,
+        "missing_count": total.to_numpy(),
+        "missing_percent": percentage.to_numpy(),
+    })
+
+
+def check_duplicates(
+    df: pd.DataFrame,
+    subset: list[str] | None = None,
+) -> pd.DataFrame:
+    """Return duplicated rows, excluding first occurrences."""
+    return df.loc[
+        df.duplicated(subset=subset, keep="first")
+    ].copy()
+
+
+def check_numeric_range(
+    df: pd.DataFrame,
+    column: str,
+    minimum: float | None = None,
+    maximum: float | None = None,
+) -> pd.DataFrame:
+    """Return rows with values outside the allowed range."""
+    if column not in df.columns:
+        raise KeyError(f"Column not found: {column}")
+
+    if not is_numeric_dtype(df[column]):
+        raise TypeError(f"Column '{column}' must be numeric.")
+
+    if minimum is not None and maximum is not None:
+        if minimum > maximum:
+            raise ValueError("minimum cannot exceed maximum")
+
+    mask = pd.Series(False, index=df.index)
+
+    if minimum is not None:
+        mask |= df[column] < minimum
+
+    if maximum is not None:
+        mask |= df[column] > maximum
+
+    return df.loc[mask].copy()
+
+
+def validate_dataset(
+    df: pd.DataFrame,
+    required_columns: list[str] | None = None,
+    numeric_ranges: dict[
+        str, tuple[float | None, float | None]
+    ] | None = None,
+) -> dict[str, Any]:
+    """Generate a data quality validation report."""
+    required_columns = (
+        required_columns if required_columns is not None else []
+    )
+    numeric_ranges = (
+        numeric_ranges if numeric_ranges is not None else {}
+    )
+
+    missing_columns = check_required_columns(
+        df, required_columns
+    )
+
+    missing_values = check_missing_values(df)
+    duplicates = check_duplicates(df)
+
+    range_violations = {}
+
+    for column, (minimum, maximum) in numeric_ranges.items():
+        range_violations[column] = check_numeric_range(
+            df, column, minimum, maximum
+        )
+
+    has_missing = bool(df.isna().any().any())
+    has_duplicates = not duplicates.empty
+    has_range_errors = any(
+        not rows.empty
+        for rows in range_violations.values()
+    )
+
+    return {
+        "valid": not (
+            missing_columns
+            or has_missing
+            or has_duplicates
+            or has_range_errors
+        ),
+        "total_rows": len(df),
+        "total_columns": len(df.columns),
+        "missing_columns": missing_columns,
+        "missing_values": missing_values,
+        "duplicate_count": len(duplicates),
+        "range_violations": range_violations,
+    }

tangra_dataforge/visualize.py

@@ -0,0 +1,90 @@
+
+"""Data visualization utilities for TANGRA DataForge.
+
+Create and export charts for data journalism,
+economic research, and statistical analysis.
+"""
+
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.figure import Figure
+
+
+def line_chart(
+    df: pd.DataFrame,
+    x: str,
+    y: str,
+    title: str = "",
+) -> Figure:
+    """Create a line chart for trends over time."""
+    fig, ax = plt.subplots(figsize=(10, 6))
+
+    ax.plot(df[x], df[y], marker="o", linewidth=2)
+
+    ax.set_title(title)
+    ax.set_xlabel(x)
+    ax.set_ylabel(y)
+    ax.grid(True, alpha=0.3)
+
+    fig.tight_layout()
+    return fig
+
+
+def bar_chart(
+    df: pd.DataFrame,
+    x: str,
+    y: str,
+    title: str = "",
+) -> Figure:
+    """Create a bar chart for comparing categories."""
+    fig, ax = plt.subplots(figsize=(10, 6))
+
+    ax.bar(df[x], df[y])
+
+    ax.set_title(title)
+    ax.set_xlabel(x)
+    ax.set_ylabel(y)
+
+    fig.tight_layout()
+    return fig
+
+
+def scatter_chart(
+    df: pd.DataFrame,
+    x: str,
+    y: str,
+    title: str = "",
+) -> Figure:
+    """Create a scatter plot for exploring relationships."""
+    fig, ax = plt.subplots(figsize=(10, 6))
+
+    ax.scatter(df[x], df[y])
+
+    ax.set_title(title)
+    ax.set_xlabel(x)
+    ax.set_ylabel(y)
+
+    fig.tight_layout()
+    return fig
+
+
+def save_chart(
+    fig: Figure,
+    path: str | Path,
+    dpi: int = 300,
+) -> None:
+    """Save a chart to PNG, SVG, PDF, or another supported format."""
+    path = Path(path)
+
+    path.parent.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    fig.savefig(
+        path,
+        dpi=dpi,
+        bbox_inches="tight",
+    )

tangra_dataforge-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: tangra-dataforge
+Version: 0.1.0a1
+Summary: Python toolkit for data collection, cleaning, analysis, and investigative journalism.
+Author: Irena Popova
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pandas>=2.0
+Requires-Dist: requests>=2.31
+Provides-Extra: analytics
+Requires-Dist: duckdb>=1.1; extra == 'analytics'
+Requires-Dist: pyarrow>=17.0; extra == 'analytics'
+Requires-Dist: scipy>=1.13; extra == 'analytics'
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: mypy>=1.14; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Provides-Extra: scraping
+Requires-Dist: beautifulsoup4>=4.12; extra == 'scraping'
+Requires-Dist: httpx>=0.27; extra == 'scraping'
+Requires-Dist: lxml>=5.0; extra == 'scraping'
+Requires-Dist: playwright>=1.50; extra == 'scraping'
+Requires-Dist: scrapy>=2.12; extra == 'scraping'
+Provides-Extra: visualization
+Requires-Dist: geopandas>=1.0; extra == 'visualization'
+Requires-Dist: plotly>=5.24; extra == 'visualization'
+Description-Content-Type: text/markdown
+
+# TANGRA DataForge
+
+**Open-Source Python Toolkit for Data Engineering, Analysis & Investigative Journalism**
+
+TANGRA DataForge is an open-source Python project focused on collecting, processing, analyzing, and visualizing data. It is designed for data journalism, investigative research, and reproducible data analysis.
+
+The project aims to transform raw data from public datasets, websites, and APIs into structured, verifiable, and meaningful information.
+
+## Project Goals
+
+- Collect data from public APIs, websites, CSV, JSON, and Excel files.
+- Extract structured information through web scraping.
+- Clean, validate, and transform datasets using Python and Pandas.
+- Perform statistical analysis and identify patterns, trends, and anomalies.
+- Create informative visualizations and charts.
+- Support reproducible investigations with transparent methodologies and documented sources.
+
+## Technology Stack
+
+- **Python** — Core programming language
+- **Pandas** — Data manipulation and analysis
+- **NumPy** — Numerical computing
+- **Beautiful Soup** — HTML parsing and web scraping
+- **Requests** — HTTP requests and API integration
+- **Matplotlib / Plotly** — Data visualization
+- **pytest** — Automated testing
+- **Git / GitHub** — Version control and collaboration
+
+These technologies represent the planned toolkit. Dependencies will be introduced as features are implemented.
+
+## Planned Architecture
+
+```text
+tangra-dataforge/
+├── src/
+│   └── tangra_dataforge/
+│       ├── __init__.py
+│       ├── collect.py
+│       ├── clean.py
+│       ├── analyze.py
+│       └── visualize.py
+├── investigations/
+├── examples/
+├── tests/
+├── pyproject.toml
+├── README.md
+└── .gitignore
+```
+
+## Data Journalism & Research
+
+TANGRA DataForge is being developed to support data-driven investigations into economic, social, political, and technological developments.
+
+Planned research applications include:
+
+- Economic indicators and regional inequality
+- Housing affordability and income development
+- Labour markets and workforce shortages
+- Education and professional qualifications
+- Technology, digital transformation, and society
+
+Investigations will prioritize publicly accessible data, source attribution, transparent analysis, and reproducible results.
+
+## Development Status
+
+**Early development — project initialization**
+
+The toolkit is currently being established. Its first development phase will focus on Python/Pandas data processing, dataset validation, and reproducible analysis workflows.
+
+The project is not yet available as an installable Python package.
+
+## Roadmap
+
+- [ ] Establish Python package structure
+- [ ] Implement CSV and JSON data loading
+- [ ] Develop Pandas-based cleaning functions
+- [ ] Add data validation and descriptive statistics
+- [ ] Integrate API data collection
+- [ ] Implement web scraping components
+- [ ] Add visualization utilities
+- [ ] Create a reproducible journalism case study
+- [ ] Add automated tests and documentation
+- [ ] Publish an initial release on PyPI
+
+## Responsible Data Collection
+
+Data collection functionality will be developed with attention to applicable laws, data protection, website access policies, rate limits, and source attribution.
+
+## Author
+
+**Irena Popova**
+
+Independent Researcher | Python & Full-Stack Developer | Author & Publisher
+
+[Website](https://www.irena-popova.com) | [GitHub](https://github.com/irenapopova)
+
+## License
+
+An open-source license will be added before the first public software release.

tangra_dataforge-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,18 @@
+tangra_dataforge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tangra_dataforge/analyze.py,sha256=-bfBVdvC51mS2ACj9dsCR8BT1pm4zJVNq05LhjIe-kk,2062
+tangra_dataforge/browser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tangra_dataforge/clean.py,sha256=74WajaJ4K-dJLtRPyiC7e1RoW9RIDj8d94RRCkSSX4U,406
+tangra_dataforge/collect.py,sha256=nkXqJ5qvbz90-2JS0tJnMfylznHbzb7Fz1EUBIA32ZU,1365
+tangra_dataforge/database.py,sha256=Wypgmx85vUHmStwqx0EOcSkDgc_oX12Z8t1K31l8FFQ,1074
+tangra_dataforge/geospatial.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tangra_dataforge/interactive.py,sha256=kHeAvAOdmi6WkL3c97reHJzq_iiGhRQKX6Xg5RrmxjM,1459
+tangra_dataforge/pipeline.py,sha256=DLNgkEX66XJMh_PLGRkjFmdjzq4kyiPlZuiEtrYGSb4,3131
+tangra_dataforge/provenance.py,sha256=fhEakXVN0sYWK4Cf5StsvJ4w5nX-8oYRicfAXfSwALg,1272
+tangra_dataforge/scrape.py,sha256=_7zBegnrZEUIziJUiVA-B9aVE_6R8Y6Ihga2vWB2jwM,2184
+tangra_dataforge/statistics.py,sha256=PaFpa-Nq2qnem5IdxRALjCvsUUBxRXeaIo25792SQ-s,3862
+tangra_dataforge/validate.py,sha256=LnV96WufwbcM96aMDMhpt99VKsH_iF-K0Pn9gQTGUiw,3300
+tangra_dataforge/visualize.py,sha256=DdD2xhP4lhbTjwOQirBxu5pAftV6qf2-TmE3n17uDqY,1657
+tangra_dataforge-0.1.0a1.dist-info/METADATA,sha256=r0N0IBucaKTX_Zj3gOSuIjA7NdzvStjGg4Hb9Cvx1X8,4775
+tangra_dataforge-0.1.0a1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tangra_dataforge-0.1.0a1.dist-info/licenses/LICENSE,sha256=VpYmhrCp13HYZdQu-eQirM8bZ3MLYln1aHB0bpO1aPI,1069
+tangra_dataforge-0.1.0a1.dist-info/RECORD,,

tangra_dataforge-0.1.0a1.dist-info/WHEEL

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

tangra_dataforge-0.1.0a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Irena Popova
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of 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.