Where analysis portfolio how to interview: A Comprehensive Guide

import os
import json
import subprocess
import sys
from typing import Dict, List, Optional, Tuple

class PortfolioComplianceChecker:
    """Validates analysis portfolio projects against common interview evaluation criteria.

    Checks for required files, runnable examples, dependency management, and test coverage.
    """

    REQUIRED_FILES = ["README.md", "requirements.txt", "src/analyze.py", "tests/test_analyze.py"]
    MIN_TEST_COVERAGE = 80  # Minimum 80% test coverage expected in interviews

    def __init__(self, repo_path: str):
        self.repo_path = os.path.abspath(repo_path)
        self.results: Dict[str, bool] = {}
        self.errors: List[str] = []

    def _check_file_exists(self, relative_path: str) -> bool:
        """Check if a file exists in the repo, log error if missing."""
        full_path = os.path.join(self.repo_path, relative_path)
        exists = os.path.isfile(full_path)
        self.results[f"file_exists:{relative_path}"] = exists
        if not exists:
            self.errors.append(f"Missing required file: {relative_path}")
        return exists

    def _check_requirements_installable(self) -> bool:
        """Verify requirements.txt can be installed in a virtual environment."""
        req_path = os.path.join(self.repo_path, "requirements.txt")
        if not os.path.isfile(req_path):
            self.errors.append("requirements.txt not found, skipping install check")
            return False

        try:
            # Create temporary venv to test install (avoid polluting global env)
            venv_path = os.path.join(self.repo_path, ".temp_venv")
            subprocess.run([sys.executable, "-m", "venv", venv_path], check=True, capture_output=True)
            pip_path = os.path.join(venv_path, "bin", "pip" if os.name != "nt" else "Scripts", "pip.exe")
            subprocess.run([pip_path, "install", "-r", req_path], check=True, capture_output=True)
            self.results["requirements_installable"] = True
            return True
        except subprocess.CalledProcessError as e:
            self.errors.append(f"Failed to install requirements: {e.stderr.decode()}")
            self.results["requirements_installable"] = False
            return False
        finally:
            # Clean up temp venv
            if os.path.exists(venv_path):
                import shutil
                shutil.rmtree(venv_path, ignore_errors=True)

    def _check_test_coverage(self) -> float:
        """Calculate test coverage using pytest-cov, return coverage percentage."""
        test_path = os.path.join(self.repo_path, "tests")
        if not os.path.isdir(test_path):
            self.errors.append("No tests directory found")
            return 0.0

        try:
            # Run pytest with coverage, output JSON report
            result = subprocess.run(
                ["pytest", test_path, "--cov=src", "--cov-report=json"],
                cwd=self.repo_path,
                capture_output=True,
                text=True
            )
            coverage_report_path = os.path.join(self.repo_path, "coverage.json")
            if not os.path.isfile(coverage_report_path):
                self.errors.append("Coverage report not generated")
                return 0.0

            with open(coverage_report_path) as f:
                coverage_data = json.load(f)
            coverage_pct = coverage_data.get("totals", {}).get("percent_covered", 0.0)
            self.results["test_coverage_pct"] = coverage_pct
            return coverage_pct
        except Exception as e:
            self.errors.append(f"Failed to calculate test coverage: {str(e)}")
            return 0.0
        finally:
            # Clean up coverage file
            if os.path.exists(coverage_report_path):
                os.remove(coverage_report_path)

    def run_compliance_check(self) -> Tuple[bool, Dict[str, bool], List[str]]:
        """Run all compliance checks, return pass/fail, results, and errors."""
        # Check required files
        for req_file in self.REQUIRED_FILES:
            self._check_file_exists(req_file)

        # Check requirements installable
        self._check_requirements_installable()

        # Check test coverage
        coverage = self._check_test_coverage()

        # Determine overall pass: all required files exist, requirements install, coverage >= min
        all_files_present = all(self.results[f"file_exists:{f}"] for f in self.REQUIRED_FILES)
        reqs_installable = self.results.get("requirements_installable", False)
        coverage_pass = coverage >= self.MIN_TEST_COVERAGE

        overall_pass = all_files_present and reqs_installable and coverage_pass
        return overall_pass, self.results, self.errors

if __name__ == "__main__":
    # Example usage: check a portfolio repo at ./my-analysis-portfolio
    repo_path = sys.argv[1] if len(sys.argv) > 1 else "./my-analysis-portfolio"
    if not os.path.isdir(repo_path):
        print(f"Error: Repo path {repo_path} does not exist or is not a directory")
        sys.exit(1)

    checker = PortfolioComplianceChecker(repo_path)
    passed, results, errors = checker.run_compliance_check()

    print(f"\n=== Portfolio Compliance Report for {repo_path} ===")
    print(f"Overall Pass: {passed}")
    print("\nCheck Results:")
    for check, result in results.items():
        print(f"  {check}: {'PASS' if result else 'FAIL'}")

    if errors:
        print("\nErrors/Warnings:")
        for err in errors:
            print(f"  - {err}")

    sys.exit(0 if passed else 1)

import time
import psutil
import pandas as pd
import numpy as np
from typing import Dict, List, Optional
import json
import os

class PortfolioBenchmarker:
    """Benchmarks analysis portfolio projects against industry performance standards."""

    # 2024 industry benchmarks for senior analysis roles
    BENCHMARKS = {
        "csv_load_time_ms": 500,  # Max time to load 100MB CSV
        "etl_throughput_mb_s": 50,  # Min ETL throughput for 100MB data
        "query_latency_ms": 200,  # Max latency for aggregated SQL query
        "memory_usage_mb": 1024  # Max memory usage for standard analysis task
    }

    def __init__(self, project_path: str):
        self.project_path = os.path.abspath(project_path)
        self.results: Dict[str, float] = {}
        self.passed: Dict[str, bool] = {}

    def _benchmark_csv_load(self, csv_path: str) -> float:
        """Benchmark time to load a 100MB CSV file, return time in ms."""
        if not os.path.isfile(csv_path):
            raise FileNotFoundError(f"CSV file not found: {csv_path}")

        start = time.time()
        df = pd.read_csv(csv_path)
        end = time.time()
        load_time_ms = (end - start) * 1000
        self.results["csv_load_time_ms"] = load_time_ms
        self.passed["csv_load_time_ms"] = load_time_ms <= self.BENCHMARKS["csv_load_time_ms"]
        return load_time_ms

    def _benchmark_etl_throughput(self, etl_script: str, data_path: str) -> float:
        """Benchmark ETL throughput in MB/s for a given script and data path."""
        if not os.path.isfile(etl_script):
            raise FileNotFoundError(f"ETL script not found: {etl_script}")

        data_size_mb = os.path.getsize(data_path) / (1024 * 1024)
        start = time.time()
        # Run ETL script as subprocess
        result = subprocess.run([sys.executable, etl_script, data_path], capture_output=True, text=True)
        end = time.time()

        if result.returncode != 0:
            raise RuntimeError(f"ETL script failed: {result.stderr}")

        throughput = data_size_mb / (end - start)
        self.results["etl_throughput_mb_s"] = throughput
        self.passed["etl_throughput_mb_s"] = throughput >= self.BENCHMARKS["etl_throughput_mb_s"]
        return throughput

    def _benchmark_memory_usage(self, analysis_script: str) -> float:
        """Benchmark peak memory usage for an analysis script, return MB used."""
        if not os.path.isfile(analysis_script):
            raise FileNotFoundError(f"Analysis script not found: {analysis_script}")

        # Start process and monitor memory
        process = subprocess.Popen([sys.executable, analysis_script], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        peak_memory = 0
        while process.poll() is None:
            try:
                mem_info = psutil.Process(process.pid).memory_info()
                current_mem_mb = mem_info.rss / (1024 * 1024)
                peak_memory = max(peak_memory, current_mem_mb)
            except psutil.NoSuchProcess:
                break

        self.results["memory_usage_mb"] = peak_memory
        self.passed["memory_usage_mb"] = peak_memory <= self.BENCHMARKS["memory_usage_mb"]
        return peak_memory

    def run_benchmarks(self, csv_path: str, etl_script: str, analysis_script: str) -> Dict:
        """Run all benchmarks, return results and pass/fail status."""
        try:
            self._benchmark_csv_load(csv_path)
        except Exception as e:
            print(f"CSV load benchmark failed: {e}")

        try:
            self._benchmark_etl_throughput(etl_script, csv_path)
        except Exception as e:
            print(f"ETL benchmark failed: {e}")

        try:
            self._benchmark_memory_usage(analysis_script)
        except Exception as e:
            print(f"Memory benchmark failed: {e}")

        overall_pass = all(self.passed.values())
        return {
            "overall_pass": overall_pass,
            "results": self.results,
            "passed": self.passed,
            "benchmarks": self.BENCHMARKS
        }

if __name__ == "__main__":
    # Example usage: benchmark a portfolio project
    project_path = sys.argv[1] if len(sys.argv) > 1 else "./my-portfolio-project"
    csv_path = os.path.join(project_path, "data", "sample_100mb.csv")
    etl_script = os.path.join(project_path, "src", "etl.py")
    analysis_script = os.path.join(project_path, "src", "analyze.py")

    if not all(os.path.isfile(p) for p in [csv_path, etl_script, analysis_script]):
        print("Error: Missing required project files for benchmarking")
        sys.exit(1)

    benchmarker = PortfolioBenchmarker(project_path)
    report = benchmarker.run_benchmarks(csv_path, etl_script, analysis_script)

    # Save report to JSON
    report_path = os.path.join(project_path, "benchmark_report.json")
    with open(report_path, "w") as f:
        json.dump(report, f, indent=2)

    print(f"\n=== Benchmark Report for {project_path} ===")
    print(f"Overall Pass: {report['overall_pass']}")
    print("\nResults:")
    for metric, value in report["results"].items():
        benchmark = report["benchmarks"].get(metric, "N/A")
        passed = report["passed"].get(metric, False)
        print(f"  {metric}: {value:.2f} (Benchmark: {benchmark}, Pass: {passed})")

import os
import json
from typing import Dict, List
import datetime

class PortfolioDocGenerator:
    """Auto-generates interview-ready README files for analysis portfolio projects."""

    README_TEMPLATE = """# {project_name}

{project_description}

## Badges
{badges}

## Overview
- **Problem**: {problem_statement}
- **Solution**: {solution_summary}
- **Tools Used**: {tools_used}
- **Data Source**: {data_source}

## Quick Start
1. Clone the repository: `git clone {repo_url}`
2. Install dependencies: `pip install -r requirements.txt`
3. Run the analysis: `python src/analyze.py`
4. Run tests: `pytest tests/`
5. Run with Docker: `docker-compose up`

## Benchmark Results
{benchmark_results}

## Test Coverage
{coverage_badge}
Current test coverage: {coverage_pct}%

## Example Output
{example_output}

## Lessons Learned
{lessons_learned}

## Last Updated
{datetime}
"""

    def __init__(self, project_path: str, repo_url: str):
        self.project_path = os.path.abspath(project_path)
        self.repo_url = repo_url
        self.config: Dict = {}
        self.benchmark_data: Dict = {}
        self.coverage_pct: float = 0.0

    def load_config(self, config_path: str = "portfolio_config.json") -> None:
        """Load project configuration from JSON file."""
        full_path = os.path.join(self.project_path, config_path)
        if not os.path.isfile(full_path):
            raise FileNotFoundError(f"Config file not found: {full_path}")

        with open(full_path) as f:
            self.config = json.load(f)

    def load_benchmark_data(self, benchmark_path: str = "benchmark_report.json") -> None:
        """Load benchmark data from JSON report."""
        full_path = os.path.join(self.project_path, benchmark_path)
        if not os.path.isfile(full_path):
            print(f"Warning: Benchmark report not found at {full_path}")
            return

        with open(full_path) as f:
            self.benchmark_data = json.load(f)

    def load_coverage_data(self, coverage_path: str = "coverage.json") -> None:
        """Load test coverage data from JSON report."""
        full_path = os.path.join(self.project_path, coverage_path)
        if not os.path.isfile(full_path):
            print(f"Warning: Coverage report not found at {full_path}")
            self.coverage_pct = 0.0
            return

        with open(full_path) as f:
            coverage_data = json.load(f)
        self.coverage_pct = coverage_data.get("totals", {}).get("percent_covered", 0.0)

    def _generate_badges(self) -> str:
        """Generate Markdown badges for runnable examples, coverage, and benchmarks."""
        badges = []
        # Runnable example badge
        badges.append(f"[![Runnable](https://img.shields.io/badge/Runnable-Yes-green)]({self.repo_url})")
        # Coverage badge
        coverage_color = "green" if self.coverage_pct >= 80 else "orange" if self.coverage_pct >= 60 else "red"
        badges.append(f"[![Coverage](https://img.shields.io/badge/Coverage-{self.coverage_pct:.0f}%25-{coverage_color})]({self.repo_url})")
        # Benchmark pass badge
        if self.benchmark_data.get("overall_pass", False):
            badges.append("[![Benchmarks](https://img.shields.io/badge/Benchmarks-Pass-green)](benchmark_report.json)")
        else:
            badges.append("[![Benchmarks](https://img.shields.io/badge/Benchmarks-Fail-red)](benchmark_report.json)")
        return "\n".join(badges)

    def _format_benchmark_results(self) -> str:
        """Format benchmark results as a Markdown table."""
        if not self.benchmark_data:
            return "No benchmark data available."

        table = "| Metric | Value | Benchmark | Pass |\n"
        table += "| --- | --- | --- | --- |\n"
        for metric, value in self.benchmark_data.get("results", {}).items():
            benchmark = self.benchmark_data.get("benchmarks", {}).get(metric, "N/A")
            passed = self.benchmark_data.get("passed", {}).get(metric, False)
            table += f"| {metric} | {value:.2f} | {benchmark} | {'✅' if passed else '❌'} |\n"
        return table

    def generate_readme(self) -> str:
        """Generate README content using the template and loaded data."""
        badges = self._generate_badges()
        benchmark_results = self._format_benchmark_results()
        coverage_badge = f"![Coverage](https://img.shields.io/badge/Coverage-{self.coverage_pct:.0f}%25)"

        readme = self.README_TEMPLATE.format(
            project_name=self.config.get("project_name", "Unnamed Project"),
            project_description=self.config.get("description", "No description provided."),
            badges=badges,
            problem_statement=self.config.get("problem", "No problem statement provided."),
            solution_summary=self.config.get("solution", "No solution summary provided."),
            tools_used=", ".join(self.config.get("tools", [])),
            data_source=self.config.get("data_source", "No data source provided."),
            repo_url=self.repo_url,
            benchmark_results=benchmark_results,
            coverage_badge=coverage_badge,
            coverage_pct=self.coverage_pct,
            example_output=self.config.get("example_output", "No example output provided."),
            lessons_learned=self.config.get("lessons_learned", "No lessons learned provided."),
            datetime=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )
        return readme

if __name__ == "__main__":
    project_path = sys.argv[1] if len(sys.argv) > 1 else "./my-portfolio-project"
    repo_url = sys.argv[2] if len(sys.argv) > 2 else "https://github.com/your-username/my-portfolio-project"

    generator = PortfolioDocGenerator(project_path, repo_url)
    try:
        generator.load_config()
        generator.load_benchmark_data()
        generator.load_coverage_data()
        readme_content = generator.generate_readme()

        readme_path = os.path.join(project_path, "README.md")
        with open(readme_path, "w") as f:
            f.write(readme_content)

        print(f"Successfully generated README at {readme_path}")
    except Exception as e:
        print(f"Error generating README: {e}")
        sys.exit(1)

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
COPY tests/ ./tests/
EXPOSE 8501  # For Streamlit demos
CMD ["streamlit", "run", "src/analyze.py"]

import pytest
import pandas as pd

def test_etl_throughput(benchmark):
    df = pd.read_csv("data/sample_100mb.csv")
    result = benchmark(pd.to_parquet, df, "output.parquet")
    assert result is None

{
  "ci": {
    "collect": {
      "url": ["https://your-username.github.io/my-portfolio"]
    },
    "assert": {
      "assertions": {
        "categories:performance": ["error", {"minScore": 0.9}],
        "categories:accessibility": ["error", {"minScore": 0.8}]
      }
    }
  }
}

analysis-portfolio-interview-guide/
├── code-examples/
│   ├── 01-portfolio-compliance-checker.py
│   ├── 02-portfolio-performance-benchmarker.py
│   └── 03-portfolio-documentation-generator.py
├── case-studies/
│   └── faang-latency-optimization.md
├── templates/
│   ├── portfolio-readme-template.md
│   └── docker-compose.yml
├── benchmarks/
│   ├── 2024-portfolio-hosting-comparison.csv
│   └── karat-2024-interview-data.json
├── requirements.txt
└── README.md