oneprocess 0.1.0__py3-none-any.whl

oneprocess/__init__.py

@@ -0,0 +1,11 @@
+"""OneProcess: An all-in-one data processing and analytics toolkit."""
+from oneprocess.core import DataProcessor
+from oneprocess.visuals import GraphAnalyzer
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "DataProcessor",
+    "GraphAnalyzer",
+]

oneprocess/app.py

@@ -0,0 +1,357 @@
+import streamlit as st
+import pandas as pd
+import io
+from oneprocess.core.processor import DataProcessor
+from oneprocess.visuals.charts import GraphAnalyzer
+
+st.set_page_config(page_title="OneProcess - Data Toolkit", layout="wide", page_icon="⚡")
+
+st.title("⚡ OneProcess")
+st.caption("A Unified Data Processing, Cloud Ingestion, and Analytics Toolkit")
+
+# Sidebar file uploader for active workspace
+# Sidebar file uploader for active workspace
+st.sidebar.header("📁 Primary Dataset")
+uploaded_file = st.sidebar.file_uploader("Upload CSV or Excel", type=["csv", "xlsx", "xls"])
+
+# Initialize session state keys
+if "df" not in st.session_state:
+    st.session_state.df = None
+if "original_df" not in st.session_state:
+    st.session_state.original_df = None
+if "last_uploaded_file" not in st.session_state:
+    st.session_state.last_uploaded_file = None
+
+# Only load when a file is uploaded AND it's new/changed
+if uploaded_file is not None:
+    if st.session_state.last_uploaded_file != uploaded_file.name:
+        loaded_df = DataProcessor.read_file(uploaded_file)
+        
+        # Save both current working copy and original backup
+        st.session_state.df = loaded_df
+        st.session_state.original_df = loaded_df.copy()
+        st.session_state.last_uploaded_file = uploaded_file.name
+        st.session_state.last_action = None
+
+    if st.session_state.df is not None:
+        st.sidebar.success(f"Loaded: {st.session_state.df.shape[0]} rows, {st.session_state.df.shape[1]} cols")
+else:
+    # Clear state if user removes/clears the uploaded file
+    st.session_state.df = None
+    st.session_state.original_df = None
+    st.session_state.last_uploaded_file = None
+
+tabs = st.tabs([
+    "🔍 Schema & Inspection",
+    "🧹 Clean & Transform",
+    "📑 File Merger",
+    "📊 Bar Chart Analysis",
+])
+
+# TAB 1: Inspection
+with tabs[0]:
+    st.subheader("Data Column Type Identifier")
+    if st.session_state.df is not None:
+        processor = DataProcessor(st.session_state.df)
+        info_df = processor.identify_column_types()
+
+        # Transpose so columns are along the top and metrics are on the left
+        transposed_info = info_df.set_index("Column Name").T
+        transposed_info.index.name = "Metric"
+
+        st.dataframe(transposed_info, use_container_width=True)
+        st.subheader("Data Preview")
+        st.dataframe(st.session_state.df.head(10), use_container_width=True)
+    else:
+        st.info("Upload a file in the sidebar to inspect columns.")
+        
+# TAB 2: Cleaning (Deduplication & Dynamic Distinct Value Filtering)
+with tabs[1]:
+    st.subheader("File Processing & Cleaning")
+
+    if "df" in st.session_state and st.session_state.df is not None:
+        if "data_version" not in st.session_state:
+            st.session_state.data_version = 0
+
+        # =========================================================
+        # 1. PREVIEW 1: BEFORE APPLYING (Original Uploaded File)
+        # =========================================================
+        top_header_col, top_reset_col = st.columns([4, 1])
+        with top_header_col:
+            orig_df = st.session_state.original_df
+            st.write(f"##### 📊 Preview 1: Original Uploaded Data ({len(orig_df)} rows × {len(orig_df.columns)} cols)")
+        with top_reset_col:
+            if st.button("🔄 Reset All Changes"):
+                st.session_state.df = st.session_state.original_df.copy()
+                st.session_state.last_action = "Reset back to original upload."
+                st.session_state.data_version += 1
+                st.rerun()
+
+        st.dataframe(orig_df.head(50), use_container_width=True)
+        st.caption(f"Showing first {min(50, len(orig_df))} of {len(orig_df)} rows.")
+
+        st.divider()
+
+        # =========================================================
+        # 2. CONTROLS: DEDUPLICATION & DYNAMIC VALUE FILTERING
+        # =========================================================
+        current_working_df = st.session_state.df
+
+        # -----------------------------
+        # Deduplication Section
+        # -----------------------------
+        st.write("##### 1. Deduplication")
+        col_dedup1, col_dedup2 = st.columns([3, 1])
+        with col_dedup1:
+            cols_to_check = st.multiselect(
+                "Columns to check for duplicates (leave blank for all)",
+                current_working_df.columns,
+                key=f"dedup_cols_{st.session_state.data_version}"
+            )
+        with col_dedup2:
+            keep_strategy = st.radio("Keep record:", ["first", "last"], horizontal=True, key="keep_rad")
+
+        subset_param = cols_to_check if cols_to_check else None
+        dup_mask = current_working_df.duplicated(subset=subset_param, keep=False)
+        dup_rows = current_working_df[dup_mask]
+        dup_count = len(dup_rows)
+
+        if dup_count > 0:
+            st.warning(f"⚠️ Found **{dup_count}** duplicate records.")
+            with st.expander("🔍 Preview Duplicate Records Only", expanded=False):
+                st.dataframe(
+                    dup_rows.sort_values(by=subset_param if subset_param else list(current_working_df.columns)),
+                    use_container_width=True
+                )
+        else:
+            st.success("✅ No duplicate records detected.")
+
+        if st.button("Run Deduplication", disabled=(dup_count == 0)):
+            cleaned = current_working_df.drop_duplicates(subset=subset_param, keep=keep_strategy)
+            removed_count = len(current_working_df) - len(cleaned)
+            st.session_state.df = cleaned
+            st.session_state.last_action = f"Deduplication removed {removed_count} duplicate rows."
+            st.session_state.data_version += 1
+            st.rerun()
+
+        st.divider()
+
+        # ---------------------------------------------------------
+        # Dynamic Multi-Column Distinct Values Filter Section
+        # ---------------------------------------------------------
+        st.write("##### 2. Dynamic Value Filtering")
+        st.caption("Select columns to filter, then choose specific distinct values from each.")
+
+        # Step A: Select which columns the user wants to filter by
+        selected_filter_columns = st.multiselect(
+            "Select columns to add filters for:",
+            options=list(current_working_df.columns),
+            key=f"active_filter_cols_{st.session_state.data_version}"
+        )
+
+        filter_selections = {}
+        if selected_filter_columns:
+            # Dynamically generate input columns (up to 3 dropdowns per row)
+            num_cols = min(3, len(selected_filter_columns))
+            ui_cols = st.columns(num_cols)
+
+            for idx, col_name in enumerate(selected_filter_columns):
+                # Extract sorted distinct non-null values
+                distinct_values = sorted(current_working_df[col_name].dropna().unique().tolist())
+
+                with ui_cols[idx % num_cols]:
+                    chosen_values = st.multiselect(
+                        f"Values for '{col_name}':",
+                        options=distinct_values,
+                        key=f"val_filter_{col_name}_{st.session_state.data_version}",
+                        placeholder="Select values to keep..."
+                    )
+                    if chosen_values:
+                        filter_selections[col_name] = chosen_values
+
+        # Build dynamic boolean mask across all selected dropdowns
+        active_filtered_df = current_working_df.copy()
+        if filter_selections:
+            mask = pd.Series(True, index=current_working_df.index)
+            for col_name, values in filter_selections.items():
+                mask = mask & current_working_df[col_name].isin(values)
+            active_filtered_df = current_working_df[mask]
+
+            st.info(f"🔎 Match found: **{len(active_filtered_df)}** out of **{len(current_working_df)}** rows.")
+
+            # Live preview before applying
+            with st.expander("👁️ Preview Filtered Rows Before Applying", expanded=True):
+                st.dataframe(active_filtered_df.head(50), use_container_width=True)
+
+            if st.button("✅ Confirm & Apply Filter"):
+                st.session_state.df = active_filtered_df
+                st.session_state.last_action = f"Filtered across {len(filter_selections)} column(s): retained {len(active_filtered_df)} rows."
+                st.session_state.data_version += 1
+                st.rerun()
+
+        st.divider()
+
+        # =========================================================
+        # 3. PREVIEW 2: AFTER APPLYING (Updated Working Dataset)
+        # =========================================================
+        active_df = st.session_state.df
+
+        st.write(f"##### 📊 Preview 2: After Applying ({len(active_df)} rows × {len(active_df.columns)} cols)")
+        if st.session_state.get("last_action"):
+            st.success(f"⚡ **Status:** {st.session_state.last_action}")
+
+        st.dataframe(
+            active_df.head(100),
+            use_container_width=True,
+            key=f"preview_after_table_{st.session_state.data_version}"
+        )
+        st.caption(f"Showing first {min(100, len(active_df))} of {len(active_df)} rows.")
+
+        # =========================================================
+        # 4. DOWNLOAD PROCESSED DATA (CSV & EXCEL)
+        # =========================================================
+        st.write("##### 📥 Download Processed Data")
+        dl_col1, dl_col2 = st.columns(2)
+
+        # 1. Download as CSV
+        with dl_col1:
+            csv_buf = active_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="📄 Download as CSV",
+                data=csv_buf,
+                file_name="oneprocess_processed.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+        # 2. Download as Excel (.xlsx)
+        with dl_col2:
+            import io
+            excel_buf = io.BytesIO()
+            with pd.ExcelWriter(excel_buf, engine="openpyxl") as writer:
+                active_df.to_excel(writer, index=False, sheet_name="ProcessedData")
+            excel_buf.seek(0)
+
+            st.download_button(
+                label="📊 Download as Excel (.xlsx)",
+                data=excel_buf.getvalue(),
+                file_name="oneprocess_processed.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                use_container_width=True
+            )
+
+    else:
+        st.info("Upload a dataset in the sidebar first.")
+
+# TAB 3: File Merger
+with tabs[2]:
+    st.subheader("File Merging Tool")
+    st.write("Merge two files that share identical or overlapping column names.")
+    file1 = st.file_uploader("Upload First File", type=["csv", "xlsx"], key="m_file1")
+    file2 = st.file_uploader("Upload Second File", type=["csv", "xlsx"], key="m_file2")
+    merge_mode = st.radio("Merge Mode", ["concat (Vertical Stack)", "inner (Common Columns Only)"], horizontal=True)
+
+    if file1 and file2 and st.button("Merge Files"):
+        mode = "concat" if "concat" in merge_mode else "inner"
+        merged_df = DataProcessor.merge_files(file1, file2, how=mode)
+        st.success(f"Successfully merged! Total rows: {len(merged_df)}")
+        st.dataframe(merged_df.head(10), use_container_width=True)
+        st.download_button(
+            label="📥 Download Merged File",
+            data=merged_df.to_csv(index=False).encode('utf-8'),
+            file_name="merged_output.csv",
+            mime="text/csv"
+        )
+
+# TAB 4: Bar Graphs with Notes
+with tabs[3]:
+    st.subheader("Bar Graph Analysis")
+
+    if st.session_state.get("df") is not None:
+        # Check if the active dataset was updated in Tab 2
+        current_data_version = st.session_state.get("data_version", 0)
+        if st.session_state.get("last_seen_data_version") != current_data_version:
+            st.session_state.chart_fig = None
+            st.session_state.chart_notes_saved = ""
+            st.session_state.last_seen_data_version = current_data_version
+
+        # Initialize chart state trackers
+        if "chart_fig" not in st.session_state:
+            st.session_state.chart_fig = None
+        if "chart_notes_saved" not in st.session_state:
+            st.session_state.chart_notes_saved = ""
+        if "chart_version" not in st.session_state:
+            st.session_state.chart_version = 0
+
+        # Display reset notification if user recently reset the chart
+        if st.session_state.get("show_filter_reset_msg"):
+            st.warning("ℹ️ Chart reset! If you want to analyze the full original dataset, please reset the filtering in the **Clean & Transform** tab.")
+
+        df = st.session_state.df
+
+        # Controls & Dropdowns
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            x_axis = st.selectbox(
+                "Category (X-axis)", 
+                df.columns, 
+                key=f"chart_x_{st.session_state.chart_version}"
+            )
+        with c2:
+            num_cols = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
+            y_axis = st.selectbox(
+                "Metric (Y-axis)", 
+                num_cols if num_cols else df.columns, 
+                key=f"chart_y_{st.session_state.chart_version}"
+            )
+        with c3:
+            agg = st.selectbox(
+                "Aggregation", 
+                ["sum", "mean", "count"], 
+                key=f"chart_agg_{st.session_state.chart_version}"
+            )
+
+        chart_notes = st.text_area(
+            "Analysis / Observation Notes", 
+            value=st.session_state.chart_notes_saved,
+            placeholder="Type key insights about this distribution...",
+            key=f"chart_notes_input_{st.session_state.chart_version}"
+        )
+
+        # Action Buttons: Generate & Reset
+        btn_col1, btn_col2, _ = st.columns([1.5, 1.5, 5])
+
+        with btn_col1:
+            if st.button("📊 Generate Chart", type="primary", use_container_width=True):
+                # Clear the reminder message on new generation
+                st.session_state.show_filter_reset_msg = False
+                
+                fig = GraphAnalyzer.create_bar_chart(
+                    df, 
+                    x_col=x_axis, 
+                    y_col=y_axis, 
+                    aggregation=agg, 
+                    title=f"{agg.capitalize()} of {y_axis} by {x_axis}"
+                )
+                st.session_state.chart_fig = fig
+                st.session_state.chart_notes_saved = chart_notes
+                st.rerun()
+
+        with btn_col2:
+            if st.button("🔄 Reset Chart", use_container_width=True):
+                st.session_state.chart_fig = None
+                st.session_state.chart_notes_saved = ""
+                st.session_state.chart_version += 1
+                # Trigger the reminder message
+                st.session_state.show_filter_reset_msg = True
+                st.rerun()
+
+        # Display chart and notes if generated
+        if st.session_state.chart_fig is not None:
+            st.divider()
+            st.plotly_chart(st.session_state.chart_fig, use_container_width=True)
+            if st.session_state.chart_notes_saved:
+                st.info(f"**Section Notes:** {st.session_state.chart_notes_saved}")
+
+    else:
+        st.info("Upload data in the sidebar to generate charts.")

oneprocess/cli.py

@@ -0,0 +1,24 @@
+import os
+import subprocess
+import sys
+
+
+def run():
+    """CLI launcher for the OneProcess Streamlit dashboard."""
+    print("\n" + "=" * 55)
+    print("OneProcess Data Processing & Analytics Toolkit")
+    print("Launching Data Processing Tool...")
+    print("=" * 55 + "\n")
+
+    # Locate app.py in the same directory as this cli.py
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    app_path = os.path.join(current_dir, "app.py")
+
+    try:
+        subprocess.run([sys.executable, "-m", "streamlit", "run", app_path])
+    except KeyboardInterrupt:
+        print("\nOneProcess stopped.")
+
+
+if __name__ == "__main__":
+    run()

oneprocess/core/__init__.py

@@ -0,0 +1,4 @@
+from oneprocess.core.processor import DataProcessor
+from oneprocess.core.inspector import ColumnTypeIdentifier
+
+__all__ = ["DataProcessor", "ColumnTypeIdentifier"]

oneprocess/core/inspector.py

@@ -0,0 +1,38 @@
+import pandas as pd
+
+
+class ColumnTypeIdentifier:
+    """Utility class to analyze and inspect DataFrame schemas, missing values, and data types."""
+
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+
+    def inspect(self) -> pd.DataFrame:
+        """Inspects data types, missing values, uniqueness, and samples for all columns.
+        
+        Returns a DataFrame where:
+          - Columns (X-axis): Your dataset's column names
+          - Index (Y-axis): Metric names (Inferred Type, Missing Values, etc.)
+        """
+        metrics = {}
+        total_count = len(self.df)
+
+        for col in self.df.columns:
+            missing_count = int(self.df[col].isna().sum())
+            missing_pct = round((missing_count / total_count) * 100, 2) if total_count > 0 else 0.0
+            unique_count = int(self.df[col].nunique())
+            non_null_series = self.df[col].dropna()
+            sample_val = str(non_null_series.iloc[0]) if not non_null_series.empty else "None"
+
+            metrics[col] = {
+                "Inferred Type": str(self.df[col].dtype),
+                "Missing Values": missing_count,
+                "Missing %": f"{missing_pct}%",
+                "Unique Values": unique_count,
+                "Sample": sample_val
+            }
+
+        # Converting dict to DataFrame naturally places column names at top and metric keys on the Y-axis
+        result_df = pd.DataFrame(metrics)
+        result_df.index.name = "Metric"
+        return result_df

oneprocess/core/processor.py

@@ -0,0 +1,105 @@
+"""
+Core file processing, cleaning, schema inspection, and merging operations.
+"""
+from typing import List, Optional, Union
+import io
+import pandas as pd
+
+
+class DataProcessor:
+    def __init__(self, data: Union[str, pd.DataFrame, io.BytesIO], sheet_name: Optional[str] = None):
+        """
+        Initialize with a file path, BytesIO buffer (from Streamlit), or existing DataFrame.
+        """
+        if isinstance(data, pd.DataFrame):
+            self.df = data.copy()
+        elif isinstance(data, (str, io.BytesIO)):
+            self.df = self.read_file(data, sheet_name=sheet_name)
+        else:
+            raise ValueError("Unsupported data source. Provide a file path, buffer, or DataFrame.")
+
+    @staticmethod
+    def read_file(source: Union[str, io.BytesIO], sheet_name: Optional[str] = None) -> pd.DataFrame:
+        """Helper to read either CSV or Excel seamlessly."""
+        if isinstance(source, str):
+            if source.endswith((".xlsx", ".xls")):
+                return pd.read_excel(source, sheet_name=sheet_name or 0)
+            return pd.read_csv(source)
+        else:
+            # BytesIO stream from file uploaders
+            try:
+                return pd.read_csv(source)
+            except Exception:
+                source.seek(0)
+                return pd.read_excel(source, sheet_name=sheet_name or 0)
+
+    def identify_column_types(self) -> pd.DataFrame:
+        """
+        Inspect columns, detect data types, count nulls, and provide sample values.
+        """
+        summary = []
+        for col in self.df.columns:
+            series = self.df[col]
+            null_count = int(series.isnull().sum())
+            null_pct = round((null_count / len(self.df)) * 100, 2) if len(self.df) > 0 else 0
+            
+            # Inferred logical category
+            dtype_str = str(series.dtype)
+            if pd.api.types.is_numeric_dtype(series):
+                category = "Numeric"
+            elif pd.api.types.is_datetime64_any_dtype(series):
+                category = "Datetime"
+            elif pd.api.types.is_bool_dtype(series):
+                category = "Boolean"
+            else:
+                category = "Categorical / Text"
+
+            sample_val = str(series.dropna().iloc[0]) if not series.dropna().empty else "None"
+
+            summary.append({
+                "Column Name": col,
+                "Inferred Category": category,
+                "Pandas Dtype": dtype_str,
+                "Missing Values": null_count,
+                "Missing (%)": f"{null_pct}%",
+                "Sample Value": sample_val
+            })
+        return pd.DataFrame(summary)
+
+    def deduplicate(self, subset: Optional[List[str]] = None, keep: str = "first") -> pd.DataFrame:
+        """Removes duplicate records based on optional primary key columns."""
+        initial_count = len(self.df)
+        self.df = self.df.drop_duplicates(subset=subset, keep=keep).reset_index(drop=True)
+        return self.df
+
+    def filter_data(self, query_string: str) -> pd.DataFrame:
+        """Filter dataset rows using standard pandas query syntax."""
+        self.df = self.df.query(query_string).reset_index(drop=True)
+        return self.df
+
+    def create_subset(self, columns: List[str], condition: Optional[str] = None) -> pd.DataFrame:
+        """Extracts specified columns and optional filtered rows into a new DataFrame."""
+        filtered_df = self.df.query(condition) if condition else self.df
+        return filtered_df[columns].copy().reset_index(drop=True)
+
+    @staticmethod
+    def merge_files(
+        first_source: Union[str, pd.DataFrame, io.BytesIO],
+        second_source: Union[str, pd.DataFrame, io.BytesIO],
+        how: str = "concat"
+    ) -> pd.DataFrame:
+        """
+        Merges two files or DataFrames having identical or compatible columns.
+        how: 'concat' (vertical stack) or 'inner' (only matching columns).
+        """
+        df1 = first_source if isinstance(first_source, pd.DataFrame) else DataProcessor.read_file(first_source)
+        df2 = second_source if isinstance(second_source, pd.DataFrame) else DataProcessor.read_file(second_source)
+
+        if how == "concat":
+            merged = pd.concat([df1, df2], ignore_index=True)
+        elif how == "inner":
+            common_cols = [c for c in df1.columns if c in df2.columns]
+            merged = pd.concat([df1[common_cols], df2[common_cols]], ignore_index=True)
+        else:
+            raise ValueError("Supported merge modes are 'concat' and 'inner'.")
+        return merged

oneprocess/visuals/__init__.py

@@ -0,0 +1,3 @@
+from oneprocess.visuals.charts import GraphAnalyzer
+
+__all__ = ["GraphAnalyzer"]

oneprocess/visuals/charts.py

@@ -0,0 +1,31 @@
+import pandas as pd
+import plotly.express as px
+
+class GraphAnalyzer:
+    @staticmethod
+    def create_bar_chart(
+        df: pd.DataFrame,
+        x_col: str,
+        y_col: str,
+        title: str = "Bar Chart",
+        aggregation: str = "sum"
+    ):
+        """Generates an interactive Plotly bar chart with aggregation."""
+        if aggregation == "sum":
+            grouped_df = df.groupby(x_col, as_index=False)[y_col].sum()
+        elif aggregation == "mean":
+            grouped_df = df.groupby(x_col, as_index=False)[y_col].mean()
+        elif aggregation == "count":
+            grouped_df = df.groupby(x_col, as_index=False)[y_col].count()
+        else:
+            grouped_df = df
+
+        fig = px.bar(
+            grouped_df,
+            x=x_col,
+            y=y_col,
+            title=title,
+            labels={x_col: x_col, y_col: f"{y_col} ({aggregation})"},
+            template="plotly_white"
+        )
+        return fig

oneprocess-0.1.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: oneprocess
+Version: 0.1.0
+Summary: A unified data processing, cleaning, and analytics toolkit with Streamlit support.
+Author: Merwin Pinto
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: xlsxwriter>=3.1.0
+Requires-Dist: plotly>=5.18.0
+Provides-Extra: streamlit
+Requires-Dist: streamlit>=1.35.0; extra == "streamlit"
+Dynamic: license-file
+
+# OneProcess
+
+[![PyPI version](https://img.shields.io/pypi/v/oneprocess.svg)](https://pypi.org/project/oneprocess/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/oneprocess.svg)](https://pypi.org/project/oneprocess/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**OneProcess** is a lightweight, unified data processing toolkit built for Data Analysts and Data Engineers. It eliminates the boilerplate code needed for everyday file wrangling, data cleaning, schema inspection, and exploratory data visualization.
+
+---
+
+## Key Capabilities
+
+### 1. Schema & Column Type Identification
+- **Schema Mapping:** Inspect files to infer data types, calculate missing value percentages, and preview samples across all columns.
+- **Transposed Inspection Layout:** View field properties with dataset columns organized horizontally across the top for easy side-by-side comparison.
+
+### 2. File Processing & Cleaning (CSV & Excel)
+- **Deduplication Engine:** Identify duplicate entries with full row previews before dropping, configure first/last retention strategies, and target specific primary keys or the entire dataset.
+- **Dynamic Multi-Column Filtering:** Automatically extract unique distinct values per column to filter records via intuitive dropdowns without writing manual queries.
+- **Two-Stage Preview Workflow:** Inspect your raw data prior to changes, preview filtered matches in real time, and verify the resulting dataset before committing.
+- **Dual Export Options:** Download cleaned and transformed datasets directly as CSV or Excel (`.xlsx`).
+
+### 3. File Merging
+- **Schema-Aligned Merging:** Combine multiple CSV or Excel files sharing matching column structures into a consolidated dataset.
+
+### 4. Graph & Visual Analysis
+- **Interactive Bar Charts:** Generate customizable Plotly bar charts with flexible aggregations (`sum`, `mean`, `count`) across categorical and numeric fields.
+- **Insight Notes & Quick Reset:** Annotate charts with contextual observations and reset chart configurations instantly with a single click.
+
+---
+
+## Installation
+
+```bash
+# Core library only
+pip install oneprocess
+
+# Complete installation with UI dashboard support
+pip install oneprocess[streamlit]
+
+# To run Code
+python -m oneprocess.cli

oneprocess-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+oneprocess/__init__.py,sha256=JhgXFeVWfIMIU5HzcaMvGMc0CXDRJ2rC3MOh_iZPKUM,266
+oneprocess/app.py,sha256=cq6LStsAWUBnZZQuC9SWwITCwKdjfQClM_Ahp1pX8fE,15768
+oneprocess/cli.py,sha256=c3SJ5uM7tpfvZBnR_hdTcDmEU4XLc0Oq26VVVJsmAfI,663
+oneprocess/core/__init__.py,sha256=opBSJPL3qaUK9tQsM-MgBt8NyxSgd6DDvyRjc4xAVLM,166
+oneprocess/core/inspector.py,sha256=kbzYbWkaqIhLNZW6j2xAJDhUcfGpyneY6d5hDbdDw3o,1521
+oneprocess/core/processor.py,sha256=ctTzADEKHyuHuwK1bMNqDCDTuZXTK9bGfKZ9p9w8VgE,4621
+oneprocess/visuals/__init__.py,sha256=JhNF-WJHz0yQluj2mmKrNnodgcEqe3NwRiT84h7HxDM,82
+oneprocess/visuals/charts.py,sha256=eqaRocNl4HIPHVSFu_4RuLK-HEfd730VCjRx5WBFJ6I,973
+oneprocess-0.1.0.dist-info/licenses/LICENSE,sha256=QT4LTVe-Yryc_10VzbWncDvo0rqKNqcEWZIhNGqcHik,1090
+oneprocess-0.1.0.dist-info/METADATA,sha256=DR6vModv_qc9CYQt0R2wk7TUZqGslAiKUqKbgm7kQEg,2889
+oneprocess-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+oneprocess-0.1.0.dist-info/entry_points.txt,sha256=8TXav0JU2G3jLMIZbUH_jhDB1og4h9nB6jkRKtMhNLk,86
+oneprocess-0.1.0.dist-info/top_level.txt,sha256=_7i14ITPjZGnmUlIBBkDpMpdQ33QHHQCjMw6ZQav4hU,11
+oneprocess-0.1.0.dist-info/RECORD,,

oneprocess-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

oneprocess-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+oneprocess = oneprocess.cli:run
+oneprocess-app = oneprocess.cli:run

oneprocess-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Merwin Pinto
+
+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.

oneprocess-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+oneprocess