analystx 0.1.0__tar.gz

analystx-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AnalystX Contributors
+
+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.

analystx-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: analystx
+Version: 0.1.0
+Summary: Advanced analytics and KPI engine for data-driven insights
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Keywords: analytics,kpi,insights,profiling,reporting
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: numpy>=1.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.10; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.9; extra == "dev"
+Dynamic: license-file
+
+# AnalystX
+
+Advanced analytics and KPI engine for data-driven insights.
+
+## Overview
+
+AnalystX is a Python library designed to provide comprehensive data profiling, KPI calculation, insight generation, and automated reporting capabilities. It simplifies complex analytics workflows and enables data-driven decision making.
+
+## Features
+
+- **Data Profiling**: Automatic data quality and statistical analysis
+- **KPI Engine**: Flexible and extensible key performance indicator calculation
+- **Insight Engine**: Generate actionable insights from data
+- **Report Generation**: Create professional analytics reports
+- **CLI Interface**: Command-line tools for easy integration
+
+## Installation
+
+```bash
+pip install analystx
+```
+
+Or from development source:
+
+```bash
+git clone <repository-url>
+cd analystx
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+```python
+from analystx import AnalystX
+
+# Initialize analyzer
+analyzer = AnalystX(data=df)
+
+# Run profiling
+profile = analyzer.profile()
+
+# Calculate KPIs
+kpis = analyzer.calculate_kpis()
+
+# Generate insights
+insights = analyzer.generate_insights()
+
+# Create report
+report = analyzer.create_report()
+```
+
+## Command Line Usage
+
+```bash
+analystx --help
+```
+
+## Documentation
+
+For detailed documentation, see the [docs](docs/) directory.
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Author
+
+Your Name <your.email@example.com>

analystx-0.1.0/README.md

@@ -0,0 +1,72 @@
+# AnalystX
+
+Advanced analytics and KPI engine for data-driven insights.
+
+## Overview
+
+AnalystX is a Python library designed to provide comprehensive data profiling, KPI calculation, insight generation, and automated reporting capabilities. It simplifies complex analytics workflows and enables data-driven decision making.
+
+## Features
+
+- **Data Profiling**: Automatic data quality and statistical analysis
+- **KPI Engine**: Flexible and extensible key performance indicator calculation
+- **Insight Engine**: Generate actionable insights from data
+- **Report Generation**: Create professional analytics reports
+- **CLI Interface**: Command-line tools for easy integration
+
+## Installation
+
+```bash
+pip install analystx
+```
+
+Or from development source:
+
+```bash
+git clone <repository-url>
+cd analystx
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+```python
+from analystx import AnalystX
+
+# Initialize analyzer
+analyzer = AnalystX(data=df)
+
+# Run profiling
+profile = analyzer.profile()
+
+# Calculate KPIs
+kpis = analyzer.calculate_kpis()
+
+# Generate insights
+insights = analyzer.generate_insights()
+
+# Create report
+report = analyzer.create_report()
+```
+
+## Command Line Usage
+
+```bash
+analystx --help
+```
+
+## Documentation
+
+For detailed documentation, see the [docs](docs/) directory.
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Author
+
+Your Name <your.email@example.com>

analystx-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "analystx"
+version = "0.1.0"
+description = "Advanced analytics and KPI engine for data-driven insights"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+keywords = ["analytics", "kpi", "insights", "profiling", "reporting"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+
+dependencies = [
+    "pandas>=1.0.0",
+    "numpy>=1.19.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0",
+    "pytest-cov>=2.10",
+    "black>=21.0",
+    "flake8>=3.9",
+]
+
+[project.scripts]
+analystx = "analystx.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

analystx-0.1.0/setup.cfg

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

analystx-0.1.0/src/analystx/__init__.py

@@ -0,0 +1,11 @@
+"""
+AnalystX: Advanced analytics and KPI engine for data-driven insights.
+"""
+
+__version__ = "0.1.0"
+__author__ = "AnalystX Contributors"
+__license__ = "MIT"
+
+from .main import AnalystX
+
+__all__ = ["AnalystX"]

analystx-0.1.0/src/analystx/cli.py

@@ -0,0 +1,111 @@
+"""
+Command-line interface for AnalystX.
+"""
+
+import argparse
+import sys
+import pandas as pd
+from .main import AnalystX
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="AnalystX: Advanced analytics and KPI engine"
+    )
+
+    parser.add_argument(
+        "command",
+        choices=["profile", "kpi", "insight", "report"],
+        help="Command to execute"
+    )
+
+    parser.add_argument(
+        "--data",
+        type=str,
+        help="Path to input data file (CSV, Excel, etc.)"
+    )
+
+    parser.add_argument(
+        "--output",
+        type=str,
+        help="Path to output file"
+    )
+
+    parser.add_argument(
+        "--format",
+        choices=["html", "markdown", "pdf"],
+        default="html",
+        help="Output format for reports"
+    )
+
+    parser.add_argument(
+        "--config",
+        type=str,
+        help="Path to configuration file (JSON)"
+    )
+
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version="%(prog)s 0.1.0"
+    )
+
+    args = parser.parse_args()
+
+    try:
+        if not args.data:
+            parser.print_help()
+            print("\nError: --data argument is required")
+            sys.exit(1)
+
+        # Load data
+        if args.data.endswith(".csv"):
+            data = pd.read_csv(args.data)
+        elif args.data.endswith((".xlsx", ".xls")):
+            data = pd.read_excel(args.data)
+        else:
+            print(f"Unsupported file format: {args.data}")
+            sys.exit(1)
+
+        # Initialize analyzer
+        analyzer = AnalystX(data=data)
+
+        # Execute command
+        if args.command == "profile":
+            result = analyzer.profile()
+            print("Data Profile:")
+            print(result)
+
+        elif args.command == "kpi":
+            result = analyzer.calculate_kpis()
+            print("KPIs:")
+            for kpi, value in result.items():
+                print(f"  {kpi}: {value}")
+
+        elif args.command == "insight":
+            result = analyzer.generate_insights()
+            print("Insights:")
+            for insight in result:
+                print(f"  - {insight.get('message', 'N/A')}")
+
+        elif args.command == "report":
+            result = analyzer.create_report(output_format=args.format)
+            if args.output:
+                if args.format == "html":
+                    with open(args.output, "w") as f:
+                        f.write(result)
+                else:
+                    with open(args.output, "w") as f:
+                        f.write(result)
+                print(f"Report saved to {args.output}")
+            else:
+                print(result)
+
+    except Exception as e:
+        print(f"Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

analystx-0.1.0/src/analystx/dictionary.py

@@ -0,0 +1,78 @@
+"""
+Dictionary module for managing business logic and metadata.
+"""
+
+
+class DataDictionary:
+    """Manage data dictionary, metadata, and business logic definitions."""
+
+    def __init__(self):
+        """Initialize data dictionary."""
+        self.definitions = {}
+        self.metrics = {}
+        self.transformations = {}
+
+    def add_definition(self, name, definition):
+        """
+        Add a column or metric definition.
+
+        Parameters
+        ----------
+        name : str
+            Name of the item
+        definition : dict
+            Definition details (type, description, format, etc.)
+        """
+        self.definitions[name] = definition
+
+    def add_metric(self, name, formula, description=""):
+        """
+        Add a business metric definition.
+
+        Parameters
+        ----------
+        name : str
+            Metric name
+        formula : str
+            Metric calculation formula or expression
+        description : str, optional
+            Metric description
+        """
+        self.metrics[name] = {
+            "formula": formula,
+            "description": description
+        }
+
+    def add_transformation(self, name, func, description=""):
+        """
+        Register a data transformation.
+
+        Parameters
+        ----------
+        name : str
+            Transformation name
+        func : callable
+            Transformation function
+        description : str, optional
+            Description of the transformation
+        """
+        self.transformations[name] = {
+            "function": func,
+            "description": description
+        }
+
+    def get_definition(self, name):
+        """Get a definition."""
+        return self.definitions.get(name)
+
+    def get_metric(self, name):
+        """Get a metric definition."""
+        return self.metrics.get(name)
+
+    def list_all(self):
+        """List all definitions and metrics."""
+        return {
+            "definitions": self.definitions,
+            "metrics": self.metrics,
+            "transformations": list(self.transformations.keys())
+        }

analystx-0.1.0/src/analystx/insight_engine.py

@@ -0,0 +1,97 @@
+"""
+Insight Engine for generating actionable insights from data analysis.
+"""
+
+import pandas as pd
+import numpy as np
+
+
+class InsightEngine:
+    """Generate actionable insights from data and analysis results."""
+
+    def generate(self, data, profile=None, kpis=None):
+        """
+        Generate insights from data and analysis results.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            Input data
+        profile : dict, optional
+            Data profile results
+        kpis : dict, optional
+            KPI calculation results
+
+        Returns
+        -------
+        list
+            List of insight dictionaries
+        """
+        insights = []
+
+        if profile:
+            insights.extend(self._quality_insights(profile))
+            insights.extend(self._distribution_insights(data))
+
+        if kpis:
+            insights.extend(self._kpi_insights(kpis))
+
+        return insights
+
+    @staticmethod
+    def _quality_insights(profile):
+        """Generate insights about data quality."""
+        insights = []
+        quality = profile.get("quality_metrics", {})
+
+        if quality.get("completeness_pct", 100) < 90:
+            insights.append({
+                "type": "warning",
+                "message": f"Data completeness is {quality.get('completeness_pct', 0)}%. "
+                          "Consider addressing missing values.",
+                "severity": "high"
+            })
+
+        if quality.get("duplicate_rows", 0) > 0:
+            insights.append({
+                "type": "warning",
+                "message": f"Found {quality.get('duplicate_rows', 0)} duplicate rows.",
+                "severity": "medium"
+            })
+
+        return insights
+
+    @staticmethod
+    def _distribution_insights(data):
+        """Generate insights about data distribution."""
+        insights = []
+        numeric_cols = data.select_dtypes(include=[np.number]).columns
+
+        for col in numeric_cols:
+            skewness = data[col].skew()
+            if abs(skewness) > 1:
+                insights.append({
+                    "type": "observation",
+                    "message": f"Column '{col}' has significant skewness ({skewness:.2f}).",
+                    "column": col
+                })
+
+        return insights
+
+    @staticmethod
+    def _kpi_insights(kpis):
+        """Generate insights about KPI values."""
+        insights = []
+
+        # Example: Flag anomalies or trends
+        for kpi_name, kpi_value in kpis.items():
+            if isinstance(kpi_value, (int, float)):
+                if kpi_value < 0:
+                    insights.append({
+                        "type": "observation",
+                        "message": f"KPI '{kpi_name}' has a negative value: {kpi_value}",
+                        "kpi": kpi_name,
+                        "value": kpi_value
+                    })
+
+        return insights

analystx-0.1.0/src/analystx/kpi_engine.py

@@ -0,0 +1,71 @@
+"""
+KPI Engine for calculating key performance indicators from data.
+"""
+
+import pandas as pd
+import numpy as np
+
+
+class KPIEngine:
+    """Calculate and manage key performance indicators."""
+
+    def __init__(self):
+        """Initialize KPI engine with default metrics."""
+        self.custom_kpis = {}
+
+    def calculate(self, data, config=None):
+        """
+        Calculate KPIs from data.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            Data to calculate KPIs from
+        config : dict, optional
+            Configuration for KPI calculation
+
+        Returns
+        -------
+        dict
+            Dictionary of calculated KPIs
+        """
+        kpis = {}
+
+        # Basic numeric KPIs
+        numeric_cols = data.select_dtypes(include=[np.number]).columns
+        for col in numeric_cols:
+            kpis[f"{col}_mean"] = data[col].mean()
+            kpis[f"{col}_median"] = data[col].median()
+            kpis[f"{col}_std"] = data[col].std()
+            kpis[f"{col}_min"] = data[col].min()
+            kpis[f"{col}_max"] = data[col].max()
+
+        # Add custom KPIs if provided
+        if config:
+            kpis.update(self._calculate_custom_kpis(data, config))
+
+        return kpis
+
+    def register_kpi(self, name, func):
+        """
+        Register a custom KPI calculation function.
+
+        Parameters
+        ----------
+        name : str
+            Name of the KPI
+        func : callable
+            Function that calculates the KPI
+        """
+        self.custom_kpis[name] = func
+
+    def _calculate_custom_kpis(self, data, config):
+        """Calculate custom KPIs based on configuration."""
+        custom_results = {}
+        for kpi_name, kpi_config in config.items():
+            if kpi_name in self.custom_kpis:
+                try:
+                    custom_results[kpi_name] = self.custom_kpis[kpi_name](data, kpi_config)
+                except Exception as e:
+                    custom_results[kpi_name] = f"Error: {str(e)}"
+        return custom_results

analystx-0.1.0/src/analystx/main.py

@@ -0,0 +1,120 @@
+"""
+Main AnalystX module containing the core analyzer class.
+"""
+
+import pandas as pd
+from .profiling import DataProfiler
+from .kpi_engine import KPIEngine
+from .insight_engine import InsightEngine
+from .report import ReportGenerator
+
+
+class AnalystX:
+    """Main analyzer class for data profiling, KPI calculation, and insight generation."""
+
+    def __init__(self, data=None):
+        """
+        Initialize AnalystX analyzer.
+
+        Parameters
+        ----------
+        data : pd.DataFrame, optional
+            Input dataframe for analysis
+        """
+        self.data = data
+        self.profiler = DataProfiler()
+        self.kpi_engine = KPIEngine()
+        self.insight_engine = InsightEngine()
+        self.report_generator = ReportGenerator()
+        self._profile = None
+        self._kpis = None
+        self._insights = None
+
+    def load_data(self, data):
+        """
+        Load or update data for analysis.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            Dataframe to analyze
+        """
+        if not isinstance(data, pd.DataFrame):
+            raise TypeError("Data must be a pandas DataFrame")
+        self.data = data
+        return self
+
+    def profile(self):
+        """
+        Generate data profile including statistical summaries and quality metrics.
+
+        Returns
+        -------
+        dict
+            Profile results
+        """
+        if self.data is None:
+            raise ValueError("No data loaded. Use load_data() first.")
+        self._profile = self.profiler.analyze(self.data)
+        return self._profile
+
+    def calculate_kpis(self, config=None):
+        """
+        Calculate KPIs based on provided configuration.
+
+        Parameters
+        ----------
+        config : dict, optional
+            KPI configuration
+
+        Returns
+        -------
+        dict
+            Calculated KPIs
+        """
+        if self.data is None:
+            raise ValueError("No data loaded. Use load_data() first.")
+        self._kpis = self.kpi_engine.calculate(self.data, config)
+        return self._kpis
+
+    def generate_insights(self):
+        """
+        Generate insights from profiling and KPI results.
+
+        Returns
+        -------
+        list
+            List of insights
+        """
+        if self._profile is None:
+            self.profile()
+        self._insights = self.insight_engine.generate(self.data, self._profile, self._kpis)
+        return self._insights
+
+    def create_report(self, output_format="html"):
+        """
+        Create a comprehensive report.
+
+        Parameters
+        ----------
+        output_format : str, optional
+            Output format (html, pdf, markdown)
+
+        Returns
+        -------
+        str
+            Report content or file path
+        """
+        if self._profile is None:
+            self.profile()
+        if self._insights is None:
+            self.generate_insights()
+
+        report = self.report_generator.generate(
+            data=self.data,
+            profile=self._profile,
+            kpis=self._kpis,
+            insights=self._insights,
+            format=output_format
+        )
+        return report

analystx-0.1.0/src/analystx/profiling.py

@@ -0,0 +1,72 @@
+"""
+Data profiling module for comprehensive data analysis and quality assessment.
+"""
+
+import pandas as pd
+import numpy as np
+
+
+class DataProfiler:
+    """Generate detailed data profiles including statistics and quality metrics."""
+
+    def analyze(self, data):
+        """
+        Analyze dataset and generate comprehensive profile.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            Data to profile
+
+        Returns
+        -------
+        dict
+            Profile results including shape, dtypes, statistics, and quality metrics
+        """
+        profile = {
+            "shape": data.shape,
+            "columns": list(data.columns),
+            "dtypes": data.dtypes.to_dict(),
+            "summary_stats": self._get_summary_stats(data),
+            "missing_values": self._get_missing_values(data),
+            "unique_counts": self._get_unique_counts(data),
+            "quality_metrics": self._get_quality_metrics(data),
+        }
+        return profile
+
+    @staticmethod
+    def _get_summary_stats(data):
+        """Generate summary statistics for numeric columns."""
+        numeric_data = data.select_dtypes(include=[np.number])
+        if numeric_data.empty:
+            return {}
+        return numeric_data.describe().to_dict()
+
+    @staticmethod
+    def _get_missing_values(data):
+        """Calculate missing value statistics."""
+        missing = data.isnull().sum()
+        missing_pct = (missing / len(data) * 100).round(2)
+        return {
+            "count": missing.to_dict(),
+            "percentage": missing_pct.to_dict(),
+        }
+
+    @staticmethod
+    def _get_unique_counts(data):
+        """Get unique value counts for all columns."""
+        return data.nunique().to_dict()
+
+    @staticmethod
+    def _get_quality_metrics(data):
+        """Calculate data quality metrics."""
+        total_cells = data.shape[0] * data.shape[1]
+        missing_cells = data.isnull().sum().sum()
+        completeness = ((total_cells - missing_cells) / total_cells * 100)
+
+        return {
+            "completeness_pct": round(completeness, 2),
+            "total_cells": total_cells,
+            "missing_cells": missing_cells,
+            "duplicate_rows": data.duplicated().sum(),
+        }

analystx-0.1.0/src/analystx/report.py

@@ -0,0 +1,156 @@
+"""
+Report generation module for creating analytics reports in various formats.
+"""
+
+from datetime import datetime
+
+
+class ReportGenerator:
+    """Generate comprehensive analytics reports."""
+
+    def __init__(self):
+        """Initialize report generator."""
+        self.report_config = {}
+
+    def generate(self, data=None, profile=None, kpis=None, insights=None, format="html"):
+        """
+        Generate a report with provided analysis results.
+
+        Parameters
+        ----------
+        data : pd.DataFrame, optional
+            Original data
+        profile : dict, optional
+            Data profile results
+        kpis : dict, optional
+            KPI calculations
+        insights : list, optional
+            Generated insights
+        format : str, optional
+            Output format (html, markdown, pdf)
+
+        Returns
+        -------
+        str
+            Report content or file path
+        """
+        if format == "html":
+            return self._generate_html_report(data, profile, kpis, insights)
+        elif format == "markdown":
+            return self._generate_markdown_report(data, profile, kpis, insights)
+        elif format == "pdf":
+            return self._generate_pdf_report(data, profile, kpis, insights)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+
+    @staticmethod
+    def _generate_html_report(data, profile, kpis, insights):
+        """Generate HTML report."""
+        html = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>AnalystX Report</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; margin: 20px; }}
+                .section {{ margin: 20px 0; padding: 10px; border-left: 4px solid #007bff; }}
+                h2 {{ color: #007bff; }}
+                table {{ border-collapse: collapse; width: 100%; }}
+                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+                th {{ background-color: #f8f9fa; }}
+            </style>
+        </head>
+        <body>
+            <h1>AnalystX Report</h1>
+            <p>Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
+
+            <div class="section">
+                <h2>Data Profile</h2>
+                {ReportGenerator._format_profile_html(profile)}
+            </div>
+
+            <div class="section">
+                <h2>Key Performance Indicators</h2>
+                {ReportGenerator._format_kpis_html(kpis)}
+            </div>
+
+            <div class="section">
+                <h2>Insights</h2>
+                {ReportGenerator._format_insights_html(insights)}
+            </div>
+        </body>
+        </html>
+        """
+        return html
+
+    @staticmethod
+    def _generate_markdown_report(data, profile, kpis, insights):
+        """Generate Markdown report."""
+        md = f"""# AnalystX Report
+
+Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Data Profile
+
+{ReportGenerator._format_profile_markdown(profile)}
+
+## Key Performance Indicators
+
+{ReportGenerator._format_kpis_markdown(kpis)}
+
+## Insights
+
+{ReportGenerator._format_insights_markdown(insights)}
+"""
+        return md
+
+    @staticmethod
+    def _generate_pdf_report(data, profile, kpis, insights):
+        """Placeholder for PDF report generation."""
+        return "PDF report generation not yet implemented."
+
+    @staticmethod
+    def _format_profile_html(profile):
+        """Format profile results as HTML."""
+        if not profile:
+            return "<p>No profile data available.</p>"
+        return f"<p>Shape: {profile.get('shape', 'N/A')}</p>"
+
+    @staticmethod
+    def _format_profile_markdown(profile):
+        """Format profile results as Markdown."""
+        if not profile:
+            return "No profile data available."
+        return f"- Shape: {profile.get('shape', 'N/A')}"
+
+    @staticmethod
+    def _format_kpis_html(kpis):
+        """Format KPIs as HTML table."""
+        if not kpis:
+            return "<p>No KPI data available.</p>"
+        rows = "".join([f"<tr><td>{k}</td><td>{v}</td></tr>" for k, v in kpis.items()][:10])
+        return f"<table><tr><th>KPI</th><th>Value</th></tr>{rows}</table>"
+
+    @staticmethod
+    def _format_kpis_markdown(kpis):
+        """Format KPIs as Markdown table."""
+        if not kpis:
+            return "No KPI data available."
+        rows = "\n".join([f"| {k} | {v} |" for k, v in kpis.items()][:10])
+        return f"| KPI | Value |\n|-----|-------|\n{rows}"
+
+    @staticmethod
+    def _format_insights_html(insights):
+        """Format insights as HTML."""
+        if not insights:
+            return "<p>No insights available.</p>"
+        items = "".join([f"<li>{i.get('message', 'N/A')}</li>" for i in insights])
+        return f"<ul>{items}</ul>"
+
+    @staticmethod
+    def _format_insights_markdown(insights):
+        """Format insights as Markdown list."""
+        if not insights:
+            return "No insights available."
+        items = "\n".join([f"- {i.get('message', 'N/A')}" for i in insights])
+        return items

analystx-0.1.0/src/analystx.egg-info/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: analystx
+Version: 0.1.0
+Summary: Advanced analytics and KPI engine for data-driven insights
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Keywords: analytics,kpi,insights,profiling,reporting
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: numpy>=1.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.10; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.9; extra == "dev"
+Dynamic: license-file
+
+# AnalystX
+
+Advanced analytics and KPI engine for data-driven insights.
+
+## Overview
+
+AnalystX is a Python library designed to provide comprehensive data profiling, KPI calculation, insight generation, and automated reporting capabilities. It simplifies complex analytics workflows and enables data-driven decision making.
+
+## Features
+
+- **Data Profiling**: Automatic data quality and statistical analysis
+- **KPI Engine**: Flexible and extensible key performance indicator calculation
+- **Insight Engine**: Generate actionable insights from data
+- **Report Generation**: Create professional analytics reports
+- **CLI Interface**: Command-line tools for easy integration
+
+## Installation
+
+```bash
+pip install analystx
+```
+
+Or from development source:
+
+```bash
+git clone <repository-url>
+cd analystx
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+```python
+from analystx import AnalystX
+
+# Initialize analyzer
+analyzer = AnalystX(data=df)
+
+# Run profiling
+profile = analyzer.profile()
+
+# Calculate KPIs
+kpis = analyzer.calculate_kpis()
+
+# Generate insights
+insights = analyzer.generate_insights()
+
+# Create report
+report = analyzer.create_report()
+```
+
+## Command Line Usage
+
+```bash
+analystx --help
+```
+
+## Documentation
+
+For detailed documentation, see the [docs](docs/) directory.
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Author
+
+Your Name <your.email@example.com>

analystx-0.1.0/src/analystx.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/analystx/__init__.py
+src/analystx/cli.py
+src/analystx/dictionary.py
+src/analystx/insight_engine.py
+src/analystx/kpi_engine.py
+src/analystx/main.py
+src/analystx/profiling.py
+src/analystx/report.py
+src/analystx.egg-info/PKG-INFO
+src/analystx.egg-info/SOURCES.txt
+src/analystx.egg-info/dependency_links.txt
+src/analystx.egg-info/entry_points.txt
+src/analystx.egg-info/requires.txt
+src/analystx.egg-info/top_level.txt
+tests/test_basic.py

analystx-0.1.0/src/analystx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

analystx-0.1.0/src/analystx.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+analystx = analystx.cli:main

analystx-0.1.0/src/analystx.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pandas>=1.0.0
+numpy>=1.19.0
+
+[dev]
+pytest>=6.0
+pytest-cov>=2.10
+black>=21.0
+flake8>=3.9

analystx-0.1.0/src/analystx.egg-info/top_level.txt

@@ -0,0 +1 @@
+analystx

analystx-0.1.0/tests/test_basic.py

@@ -0,0 +1,142 @@
+"""
+Basic tests for AnalystX functionality.
+"""
+
+import pytest
+import pandas as pd
+import numpy as np
+from analystx import AnalystX
+
+
+@pytest.fixture
+def sample_data():
+    """Create sample data for testing."""
+    return pd.DataFrame({
+        "id": [1, 2, 3, 4, 5],
+        "value": [10.5, 20.3, 15.8, 30.1, 25.6],
+        "category": ["A", "B", "A", "B", "A"],
+        "flag": [True, False, True, False, True]
+    })
+
+
+class TestAnalystXBasic:
+    """Basic tests for AnalystX core functionality."""
+
+    def test_initialization(self):
+        """Test initialization without data."""
+        analyzer = AnalystX()
+        assert analyzer.data is None
+
+    def test_load_data(self, sample_data):
+        """Test loading data."""
+        analyzer = AnalystX()
+        analyzer.load_data(sample_data)
+        assert analyzer.data is not None
+        assert len(analyzer.data) == 5
+
+    def test_initialization_with_data(self, sample_data):
+        """Test initialization with data."""
+        analyzer = AnalystX(data=sample_data)
+        assert analyzer.data is not None
+
+    def test_profiling(self, sample_data):
+        """Test data profiling."""
+        analyzer = AnalystX(data=sample_data)
+        profile = analyzer.profile()
+
+        assert profile is not None
+        assert "shape" in profile
+        assert "columns" in profile
+        assert "dtypes" in profile
+        assert "missing_values" in profile
+
+    def test_kpi_calculation(self, sample_data):
+        """Test KPI calculation."""
+        analyzer = AnalystX(data=sample_data)
+        kpis = analyzer.calculate_kpis()
+
+        assert kpis is not None
+        assert isinstance(kpis, dict)
+        assert "value_mean" in kpis
+
+    def test_insight_generation(self, sample_data):
+        """Test insight generation."""
+        analyzer = AnalystX(data=sample_data)
+        insights = analyzer.generate_insights()
+
+        assert insights is not None
+        assert isinstance(insights, list)
+
+    def test_report_generation(self, sample_data):
+        """Test report generation."""
+        analyzer = AnalystX(data=sample_data)
+        report = analyzer.create_report(output_format="html")
+
+        assert report is not None
+        assert isinstance(report, str)
+        assert "AnalystX Report" in report
+
+    def test_report_markdown(self, sample_data):
+        """Test markdown report generation."""
+        analyzer = AnalystX(data=sample_data)
+        report = analyzer.create_report(output_format="markdown")
+
+        assert report is not None
+        assert isinstance(report, str)
+        assert "# AnalystX Report" in report
+
+    def test_error_on_missing_data(self):
+        """Test error when no data is loaded."""
+        analyzer = AnalystX()
+        with pytest.raises(ValueError):
+            analyzer.profile()
+
+    def test_invalid_data_type(self):
+        """Test error with invalid data type."""
+        analyzer = AnalystX()
+        with pytest.raises(TypeError):
+            analyzer.load_data([1, 2, 3])
+
+
+class TestDataProfiler:
+    """Tests for data profiling functionality."""
+
+    def test_profile_columns(self, sample_data):
+        """Test column detection in profile."""
+        analyzer = AnalystX(data=sample_data)
+        profile = analyzer.profile()
+
+        assert len(profile["columns"]) == 4
+        assert "id" in profile["columns"]
+        assert "value" in profile["columns"]
+
+    def test_profile_dtypes(self, sample_data):
+        """Test dtype detection in profile."""
+        analyzer = AnalystX(data=sample_data)
+        profile = analyzer.profile()
+
+        assert "id" in profile["dtypes"]
+
+
+class TestKPIEngine:
+    """Tests for KPI engine functionality."""
+
+    def test_kpi_mean(self, sample_data):
+        """Test mean KPI calculation."""
+        analyzer = AnalystX(data=sample_data)
+        kpis = analyzer.calculate_kpis()
+
+        expected_mean = sample_data["value"].mean()
+        assert abs(kpis["value_mean"] - expected_mean) < 0.01
+
+    def test_kpi_median(self, sample_data):
+        """Test median KPI calculation."""
+        analyzer = AnalystX(data=sample_data)
+        kpis = analyzer.calculate_kpis()
+
+        expected_median = sample_data["value"].median()
+        assert abs(kpis["value_median"] - expected_median) < 0.01
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])