Master trends with salary negotiation and open-source: Benchmark

import requests
import os
import time
from typing import Dict, List, Optional
import json

class OpenSourceLeverageCalculator:
    """Calculate salary negotiation leverage score based on GitHub contribution history.

    Leverage score is computed as:
    (merged_prs * 0.4) + (starred_repos * 0.2) + (years_active * 0.4)
    Scores range 0-100, with 80+ considered high leverage for senior roles.
    """

    def __init__(self, github_token: str):
        self.github_token = github_token
        self.base_url = "https://api.github.com"
        self.headers = {
            "Authorization": f"token {github_token}",
            "Accept": "application/vnd.github.v3+json"
        }
        self.rate_limit_remaining = 5000  # Initial authenticated rate limit

    def _handle_rate_limit(self, response: requests.Response) -> None:
        """Check rate limit headers and sleep if needed."""
        remaining = int(response.headers.get("X-RateLimit-Remaining", 0))
        self.rate_limit_remaining = remaining
        if remaining < 10:
            reset_time = int(response.headers.get("X-RateLimit-Reset", time.time() + 60))
            sleep_duration = reset_time - time.time() + 5  # Buffer
            print(f"Rate limit low ({remaining}). Sleeping {sleep_duration:.2f}s")
            time.sleep(max(sleep_duration, 0))

    def get_user_contribution_metrics(self, username: str) -> Optional[Dict]:
        """Fetch merged PR count, starred repos, and years active for a user."""
        try:
            # Get user public info
            user_resp = requests.get(f"{self.base_url}/users/{username}", headers=self.headers)
            self._handle_rate_limit(user_resp)
            user_resp.raise_for_status()
            user_data = user_resp.json()

            # Calculate years active
            created_at = user_data.get("created_at", "")
            if not created_at:
                return None
            years_active = max(0, 2024 - int(created_at[:4]))

            # Get merged PRs (search across all public repos)
            pr_search_url = f"{self.base_url}/search/issues?q=type:pr+author:{username}+state:merged"
            pr_resp = requests.get(pr_search_url, headers=self.headers)
            self._handle_rate_limit(pr_resp)
            pr_resp.raise_for_status()
            merged_prs = pr_resp.json().get("total_count", 0)

            # Get starred repos count
            starred_resp = requests.get(f"{self.base_url}/users/{username}/starred", headers=self.headers)
            self._handle_rate_limit(starred_resp)
            starred_resp.raise_for_status()
            # Starred count is in Link header, or we can paginate, but for brevity use total_count if available
            starred_count = int(starred_resp.headers.get("X-Total-Count", 0))

            return {
                "username": username,
                "merged_prs": merged_prs,
                "starred_repos": starred_count,
                "years_active": years_active
            }
        except requests.exceptions.RequestException as e:
            print(f"API error for {username}: {str(e)}")
            return None
        except Exception as e:
            print(f"Unexpected error for {username}: {str(e)}")
            return None

    def calculate_leverage_score(self, metrics: Dict) -> float:
        """Compute leverage score from contribution metrics."""
        if not metrics:
            return 0.0
        pr_component = min(metrics["merged_prs"] / 100, 1.0) * 40  # Cap at 40 points for 100+ PRs
        star_component = min(metrics["starred_repos"] / 50, 1.0) * 20  # Cap at 20 points for 50+ stars
        years_component = min(metrics["years_active"] / 10, 1.0) * 40  # Cap at 40 points for 10+ years
        return round(pr_component + star_component + years_component, 2)

if __name__ == "__main__":
    # Load token from env var to avoid hardcoding
    token = os.getenv("GITHUB_TOKEN")
    if not token:
        print("Error: Set GITHUB_TOKEN environment variable")
        exit(1)

    calculator = OpenSourceLeverageCalculator(token)
    test_users = ["torvalds", "octocat", "sindresorhus"]  # Example high-impact contributors

    for user in test_users:
        metrics = calculator.get_user_contribution_metrics(user)
        if metrics:
            score = calculator.calculate_leverage_score(metrics)
            print(f"User: {user}")
            print(f"Merged PRs: {metrics['merged_prs']}")
            print(f"Starred Repos: {metrics['starred_repos']}")
            print(f"Years Active: {metrics['years_active']}")
            print(f"Leverage Score: {score}/100")
            print("-" * 40)
        time.sleep(1)  # Avoid rate limits

const fetch = require('node-fetch');
const { execSync } = require('child_process');
const fs = require('fs/promises');

/**
 * Simulate a full salary negotiation cycle and measure latency.
 * Cycle steps: 1) Receive initial offer, 2) Submit counter with OS leverage data,
 * 3) Verify contributor identity, 4) Finalize offer.
 */
class NegotiationSimulator {
  constructor(toolchain) {
    this.toolchain = toolchain; // 'github-cli', 'gitlab-api', 'manual', 'docusign'
    this.results = [];
    this.GITHUB_TOKEN = process.env.GITHUB_TOKEN;
    this.GITLAB_TOKEN = process.env.GITLAB_TOKEN;
  }

  async #sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  async #runGitHubCliStep(stepName) {
    /** Execute GitHub CLI command and measure latency */
    const start = Date.now();
    try {
      let cmd = '';
      switch (stepName) {
        case 'verify-contrib':
          cmd = `gh api -X GET /users/octocat/starred --jq 'length'`;
          break;
        case 'submit-counter':
          cmd = `gh gist create --public --file counter.json`;
          break;
        default:
          throw new Error(`Unknown GitHub CLI step: ${stepName}`);
      }
      execSync(cmd, { stdio: 'pipe' });
      return { latency: Date.now() - start, success: true };
    } catch (err) {
      console.error(`GitHub CLI error in ${stepName}: ${err.message}`);
      return { latency: Date.now() - start, success: false };
    }
  }

  async #runGitLabApiStep(stepName) {
    const start = Date.now();
    try {
      let url = '';
      switch (stepName) {
        case 'verify-contrib':
          url = 'https://gitlab.com/api/v4/users/sindresorhus/starred';
          break;
        case 'submit-counter':
          url = 'https://gitlab.com/api/v4/snippets';
          break;
        default:
          throw new Error(`Unknown GitLab API step: ${stepName}`);
      }
      const resp = await fetch(url, {
        headers: { 'PRIVATE-TOKEN': this.GITLAB_TOKEN }
      });
      if (!resp.ok) throw new Error(`GitLab API error: ${resp.status}`);
      return { latency: Date.now() - start, success: true };
    } catch (err) {
      console.error(`GitLab API error in ${stepName}: ${err.message}`);
      return { latency: Date.now() - start, success: false };
    }
  }

  async runCycle() {
    const cycleStart = Date.now();
    let steps = [];

    if (this.toolchain === 'github-cli') {
      // Step 1: Verify contributor (simulate initial offer verification)
      steps.push(await this.#runGitHubCliStep('verify-contrib'));
      await this.#sleep(100); // Simulate human review time
      // Step 2: Submit counter offer
      steps.push(await this.#runGitHubCliStep('submit-counter'));
    } else if (this.toolchain === 'gitlab-api') {
      steps.push(await this.#runGitLabApiStep('verify-contrib'));
      await this.#sleep(100);
      steps.push(await this.#runGitLabApiStep('submit-counter'));
    } else if (this.toolchain === 'manual') {
      // Simulate manual spreadsheet entry
      const start = Date.now();
      await fs.writeFile('manual_counter.json', JSON.stringify({ offer: 150000 }));
      steps.push({ latency: Date.now() - start, success: true });
      await this.#sleep(500); // Manual steps are slower
      steps.push({ latency: 2000, success: true }); // Simulate email send
    }

    const totalLatency = Date.now() - cycleStart;
    const success = steps.every(s => s.success);
    return { totalLatency, success, steps };
  }

  async runBenchmark(iterations = 10000) {
    console.log(`Running ${iterations} iterations for ${this.toolchain}...`);
    for (let i = 0; i < iterations; i++) {
      const result = await this.runCycle();
      this.results.push(result);
      if (i % 1000 === 0) console.log(`Completed ${i} iterations`);
    }
    return this.#calculateStats();
  }

  #calculateStats() {
    const successful = this.results.filter(r => r.success);
    const latencies = successful.map(r => r.totalLatency);
    const mean = latencies.reduce((a, b) => a + b, 0) / latencies.length;
    const sorted = latencies.sort((a, b) => a - b);
    const p99 = sorted[Math.floor(sorted.length * 0.99)];
    return {
      toolchain: this.toolchain,
      mean_latency: mean,
      p99_latency: p99,
      success_rate: (successful.length / this.results.length) * 100
    };
  }
}

// Main execution
(async () => {
  const toolchains = ['github-cli', 'gitlab-api', 'manual'];
  for (const tc of toolchains) {
    const sim = new NegotiationSimulator(tc);
    const stats = await sim.runBenchmark(1000); // 1000 iterations for demo, full bench uses 10k
    console.log(`Stats for ${tc}:`, stats);
  }
})();

import pandas as pd
import numpy as np
from scipy import stats
import os
from typing import Tuple

class SalaryOSCorrelationAnalyzer:
    """Analyze correlation between open-source contributions and salary outcomes.

    Uses anonymized dataset from Levels.fyi (2023-2024) with columns:
    - years_experience: int
    - base_salary: int (USD)
    - merged_prs: int (public open source merged PRs)
    - company_tier: str (FAANG, Unicorn, Mid-Size, Startup)
    - location: str (US state)
    """

    def __init__(self, dataset_path: str):
        self.dataset_path = dataset_path
        self.df = None
        self.cleaned_df = None

    def load_dataset(self) -> bool:
        """Load and validate input dataset."""
        try:
            if not os.path.exists(self.dataset_path):
                print(f"Error: Dataset not found at {self.dataset_path}")
                return False
            self.df = pd.read_csv(self.dataset_path)
            required_cols = ["years_experience", "base_salary", "merged_prs", "company_tier", "location"]
            missing = [col for col in required_cols if col not in self.df.columns]
            if missing:
                print(f"Error: Missing required columns: {missing}")
                return False
            print(f"Loaded {len(self.df)} records")
            return True
        except Exception as e:
            print(f"Error loading dataset: {str(e)}")
            return False

    def clean_dataset(self) -> pd.DataFrame:
        """Clean data: filter for US-based, 5-15 years experience, valid salaries."""
        if self.df is None:
            print("Error: Dataset not loaded")
            return None
        try:
            # Filter rows
            cleaned = self.df[
                (self.df["location"].str.contains("US-", na=False)) &
                (self.df["years_experience"].between(5, 15)) &
                (self.df["base_salary"].between(80000, 500000)) &
                (self.df["merged_prs"] >= 0)
            ].copy()
            # Remove outliers using IQR for salary
            q1 = cleaned["base_salary"].quantile(0.25)
            q3 = cleaned["base_salary"].quantile(0.75)
            iqr = q3 - q1
            cleaned = cleaned[
                (cleaned["base_salary"] >= q1 - 1.5 * iqr) &
                (cleaned["base_salary"] <= q3 + 1.5 * iqr)
            ]
            self.cleaned_df = cleaned
            print(f"Cleaned dataset: {len(cleaned)} records (removed {len(self.df) - len(cleaned)} outliers)")
            return cleaned
        except Exception as e:
            print(f"Error cleaning dataset: {str(e)}")
            return None

    def calculate_correlation(self) -> Tuple[float, float]:
        """Calculate Pearson correlation between merged_prs and base_salary, return (r, p-value)."""
        if self.cleaned_df is None:
            print("Error: Dataset not cleaned")
            return (0.0, 1.0)
        try:
            # Control for years_experience and company_tier using linear regression residual
            X = self.cleaned_df[["years_experience", "merged_prs"]]
            X = pd.get_dummies(X, columns=["years_experience"], drop_first=True)
            y = self.cleaned_df["base_salary"]

            # Fit model
            from sklearn.linear_model import LinearRegression
            model = LinearRegression()
            model.fit(X, y)

            # Get residuals for salary after controlling for experience
            residuals = y - model.predict(X)

            # Correlate residuals with merged_prs
            r, p = stats.pearsonr(self.cleaned_df["merged_prs"], residuals)
            return (round(r, 4), round(p, 6))
        except Exception as e:
            print(f"Error calculating correlation: {str(e)}")
            return (0.0, 1.0)

    def generate_negotiation_benchmark(self) -> pd.DataFrame:
        """Generate percentile benchmarks for salary by merged_prs tiers."""
        if self.cleaned_df is None:
            return None
        try:
            # Define PR tiers
            self.cleaned_df["pr_tier"] = pd.cut(
                self.cleaned_df["merged_prs"],
                bins=[-1, 0, 10, 50, 100, np.inf],
                labels=["0", "1-10", "11-50", "51-100", "100+"]
            )
            # Calculate percentiles per tier
            benchmarks = self.cleaned_df.groupby("pr_tier")["base_salary"].agg(
                ["mean", "median", "p25", "p75", "count"]
            ).reset_index()
            return benchmarks
        except Exception as e:
            print(f"Error generating benchmark: {str(e)}")
            return None

if __name__ == "__main__":
    # Note: Replace with actual dataset path, sample dataset available at
    # https://github.com/oss-salary/negotiation-benchmarks/blob/main/data/sample_salary_data.csv
    analyzer = SalaryOSCorrelationAnalyzer("sample_salary_data.csv")
    if analyzer.load_dataset():
        analyzer.clean_dataset()
        r, p = analyzer.calculate_correlation()
        print(f"Pearson correlation between merged PRs and salary (controlling for experience): r={r}, p={p}")
        if p < 0.05:
            print("Statistically significant correlation (p < 0.05)")
        benchmarks = analyzer.generate_negotiation_benchmark()
        if benchmarks is not None:
            print("\nSalary Benchmarks by Merged PR Tier:")
            print(benchmarks.to_string(index=False))

from leverage_calculator import OpenSourceLeverageCalculator
import os

calc = OpenSourceLeverageCalculator(os.getenv("GITHUB_TOKEN"))
metrics = calc.get_user_contribution_metrics("your-github-username")
score = calc.calculate_leverage_score(metrics)
print(f"My open-source leverage score is {score}/100, justifying a 18% counter to the initial offer.")

import requests
GITLAB_TOKEN = "your-gitlab-token"
resp = requests.get(
    "https://gitlab.com/api/v4/users/username/starred",
    headers={"PRIVATE-TOKEN": GITLAB_TOKEN}
)
print(f"Starred repos: {len(resp.json())}")

analyzer = SalaryOSCorrelationCalculator("salary_data.csv")
bands = analyzer.generate_negotiation_benchmark()
bands.to_csv("salary_bands.csv", index=False)
print("Salary bands generated and ready to commit to GitHub.")