umpyre 0.1.7__tar.gz → 0.1.9__tar.gz

{umpyre-0.1.7 → umpyre-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: umpyre
-Version: 0.1.7
+Version: 0.1.9
 Summary: Code analysis and quality metrics tracking system for CI/CD
 Project-URL: Homepage, https://github.com/i2mint/umpyre
 License: Apache-2.0
@@ -144,9 +144,9 @@ history_dir = Path("history")
 
 # Parse filename
 info = parse_metric_filename("2025_11_14_22_45_00__700e012__0.1.0.json")
-print(info['commit_sha'])    # '700e012'
-print(info['pypi_version'])  # '0.1.0'
-print(info['timestamp'])     # datetime object
+print(info["commit_sha"])  # '700e012'
+print(info["pypi_version"])  # '0.1.0'
+print(info["timestamp"])  # datetime object
 
 # Find by commit
 metrics = find_metrics_by_commit(history_dir, "700e012")
@@ -318,7 +318,7 @@ import collections
 modules_info_df(collections)
 
 # Compare multiple packages
-stats_of(['urllib', 'json', 'collections'])
+stats_of(["urllib", "json", "collections"])
 ```
 
 See original README examples above for detailed usage.

{umpyre-0.1.7 → umpyre-0.1.9}/README.md

@@ -129,9 +129,9 @@ history_dir = Path("history")
 
 # Parse filename
 info = parse_metric_filename("2025_11_14_22_45_00__700e012__0.1.0.json")
-print(info['commit_sha'])    # '700e012'
-print(info['pypi_version'])  # '0.1.0'
-print(info['timestamp'])     # datetime object
+print(info["commit_sha"])  # '700e012'
+print(info["pypi_version"])  # '0.1.0'
+print(info["timestamp"])  # datetime object
 
 # Find by commit
 metrics = find_metrics_by_commit(history_dir, "700e012")
@@ -303,7 +303,7 @@ import collections
 modules_info_df(collections)
 
 # Compare multiple packages
-stats_of(['urllib', 'json', 'collections'])
+stats_of(["urllib", "json", "collections"])
 ```
 
 See original README examples above for detailed usage.

umpyre-0.1.9/actions/track-metrics/action.yml

@@ -0,0 +1,90 @@
+name: Track Code Metrics
+description: Collect and store code quality metrics for CI/CD pipelines
+
+inputs:
+  config-path:
+    description: 'Path to umpyre config file'
+    default: '.github/umpyre-config.yml'
+    required: false
+  
+  storage-branch:
+    description: 'Branch to store metrics on (the default leaves the choice to storage.branch in the config file)'
+    default: 'code-metrics'
+    required: false
+  
+  github-token:
+    description: 'GitHub token: read by the workflow_status collector and used to push the metrics branch (needs contents: write; with a read-only token the push fails, non-fatally)'
+    required: true
+  
+  force-run:
+    description: "Run even if an earlier step of the action failed ('true' or 'false'). To run after a failed step of the calling job, also give the calling step `if: always()`"
+    default: 'false'
+    required: false
+  
+  python-version:
+    description: 'Python version to use'
+    default: '3.10'
+    required: false
+
+runs:
+  using: composite
+  steps:
+    - name: Setup Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+    
+    - name: Install umpyre and dependencies
+      shell: bash
+      run: |
+        pip install umpyre coverage wily bandit interrogate
+    
+    - name: Collect and Store Metrics
+      # Run on success, or on failure too when `force-run` is 'true'.
+      if: ${{ success() || (inputs.force-run == 'true' && !cancelled()) }}
+      shell: bash
+      env:
+        # Inputs reach the script as environment variables, never pasted into it.
+        CONFIG_PATH: ${{ inputs.config-path }}
+        STORAGE_BRANCH: ${{ inputs.storage-branch }}
+        # Used by the workflow_status collector and to push the metrics branch.
+        GITHUB_TOKEN: ${{ inputs.github-token }}
+      run: |
+        echo "::group::Collecting Code Metrics"
+
+        # Set up error handling - continue even if collection fails
+        set +e
+
+        # Build the command. Run from $RUNNER_TEMP in isolated mode (-I) so that a
+        # file in the checked-out repo (umpyre/, yaml.py, ...) can't shadow an
+        # installed package; the repository is passed explicitly.
+        cmd=(python -I -m umpyre.cli collect --repo-path "$GITHUB_WORKSPACE")
+        if [ -n "$CONFIG_PATH" ] && [ -f "$GITHUB_WORKSPACE/$CONFIG_PATH" ]; then
+          cmd+=(--config "$GITHUB_WORKSPACE/$CONFIG_PATH")
+        elif [ -n "$CONFIG_PATH" ] && [ -f "$CONFIG_PATH" ]; then
+          cmd+=(--config "$CONFIG_PATH")
+        fi
+        # The input's default leaves the choice to the config file (storage.branch).
+        if [ -n "$STORAGE_BRANCH" ] && [ "$STORAGE_BRANCH" != "code-metrics" ]; then
+          cmd+=(--storage-branch "$STORAGE_BRANCH")
+        fi
+
+        (cd "${RUNNER_TEMP:-/tmp}" && "${cmd[@]}")
+        EXIT_CODE=$?
+
+        # Report status but don't fail
+        if [ $EXIT_CODE -eq 0 ]; then
+          echo "✅ Metrics collection completed successfully"
+        else
+          echo "⚠️ Metrics collection failed with exit code $EXIT_CODE"
+          echo "This is informational only - CI pipeline continues"
+        fi
+
+        echo "::endgroup::"
+
+        # Always exit successfully to not break CI
+        exit 0
+
+branding:
+  icon: 'bar-chart-2'
+  color: 'blue'

{umpyre-0.1.7 → umpyre-0.1.9}/misc/docs/FAILURE_PROTECTION.md

@@ -59,12 +59,12 @@ def cmd_collect(args):
         return 0
     except Exception as e:
         print(f"❌ Error during metrics collection: {e}")
-        
+
         # In CI mode, log but don't fail
-        if os.getenv('CI') or os.getenv('GITHUB_ACTIONS'):
+        if os.getenv("CI") or os.getenv("GITHUB_ACTIONS"):
             print("⚠️  Running in CI - treating as non-fatal")
             return 0
-        
+
         return 1  # Fail in local development
 ```
 
@@ -136,10 +136,7 @@ def collect(self) -> dict:
         # ... collect metrics ...
         return metrics
     except Exception as e:
-        return {
-            "num_functions": 0,
-            "error": str(e)
-        }
+        return {"num_functions": 0, "error": str(e)}
 ```
 
 This ensures one broken collector doesn't fail the entire collection.

{umpyre-0.1.7 → umpyre-0.1.9}/misc/docs/PHASE_2_PLAN.md

@@ -27,12 +27,13 @@ Generate visual charts showing metric trends over time.
 ```python
 # umpyre/visualization/plots.py
 
+
 class PlotGenerator:
     """Generate time-series plots from metrics history."""
-    
+
     def __init__(self, metrics_branch: str = "code-metrics"):
         self.branch = metrics_branch
-    
+
     def generate_coverage_plot(self) -> Path:
         """Generate coverage trend plot."""
         # Parse history/*.json files
@@ -40,11 +41,11 @@ class PlotGenerator:
         # Plot with matplotlib/plotly
         # Save as PNG/SVG
         pass
-    
+
     def generate_maintainability_plot(self) -> Path:
         """Generate maintainability trend plot."""
         pass
-    
+
     def generate_all_plots(self) -> dict[str, Path]:
         """Generate all standard plots."""
         pass
@@ -132,21 +133,22 @@ Version: 0.1.0
 ```python
 # umpyre/visualization/readme_generator.py
 
+
 class ReadmeGenerator:
     """Generate METRICS.md from metrics history."""
-    
+
     def generate_summary_table(self) -> str:
         """Create latest metrics table."""
         pass
-    
+
     def generate_trend_section(self) -> str:
         """Embed plot images."""
         pass
-    
+
     def generate_badges(self) -> str:
         """Create shields.io badges."""
         pass
-    
+
     def generate_full_readme(self) -> str:
         """Generate complete METRICS.md."""
         pass
@@ -179,18 +181,14 @@ Aggregate metrics across multiple repositories to provide organization-wide insi
 ```python
 # umpyre/collectors/aggregation_collector.py
 
+
 class AggregationCollector(MetricCollector):
     """Aggregate metrics across multiple repositories."""
-    
-    def __init__(
-        self,
-        org: str,
-        repos: list[str],
-        github_token: Optional[str] = None
-    ):
+
+    def __init__(self, org: str, repos: list[str], github_token: Optional[str] = None):
         """
         Initialize aggregator.
-        
+
         Args:
             org: GitHub organization name
             repos: List of repository names
@@ -199,11 +197,11 @@ class AggregationCollector(MetricCollector):
         self.org = org
         self.repos = repos
         self.token = github_token
-    
+
     def collect(self) -> dict:
         """
         Aggregate metrics from multiple repos.
-        
+
         Returns:
             Aggregated metrics dictionary
         """
@@ -211,7 +209,7 @@ class AggregationCollector(MetricCollector):
         #   1. Clone code-metrics branch
         #   2. Read latest metrics.json
         #   3. Aggregate
-        
+
         return {
             "total_repos": len(self.repos),
             "avg_coverage": 82.5,
@@ -267,16 +265,17 @@ Create interactive HTML dashboard with organization-wide metrics.
 ```python
 # umpyre/visualization/dashboard.py
 
+
 class DashboardGenerator:
     """Generate interactive HTML dashboard."""
-    
+
     def generate_html(self, aggregated_metrics: dict) -> str:
         """
         Generate dashboard HTML.
-        
+
         Args:
             aggregated_metrics: Output from AggregationCollector
-            
+
         Returns:
             HTML string
         """

{umpyre-0.1.7 → umpyre-0.1.9}/misc/docs/PHASE_3_PLAN.md

@@ -32,30 +32,33 @@ Enforce quality standards by validating metrics against configurable thresholds.
 ```python
 # umpyre/validation/thresholds.py
 
+
 @dataclass
 class Threshold:
     """Threshold definition."""
+
     metric_path: str  # e.g., "metrics.coverage.line_coverage"
-    operator: str     # ">=", "<=", "==", "!=", ">", "<"
+    operator: str  # ">=", "<=", "==", "!=", ">", "<"
     value: float
-    action: str       # "warn", "fail", "notify", "comment"
+    action: str  # "warn", "fail", "notify", "comment"
     message: Optional[str] = None
 
+
 class ThresholdValidator:
     """Validate metrics against thresholds."""
-    
+
     def __init__(self, thresholds: list[Threshold]):
         self.thresholds = thresholds
-    
+
     def validate(self, metrics: dict) -> list[ThresholdViolation]:
         """
         Validate metrics against all thresholds.
-        
+
         Returns:
             List of violations
         """
         violations = []
-        
+
         for threshold in self.thresholds:
             value = self._extract_metric(metrics, threshold.metric_path)
             if not self._check_threshold(value, threshold):
@@ -66,9 +69,9 @@ class ThresholdValidator:
                         expected_value=threshold.value,
                     )
                 )
-        
+
         return violations
-    
+
     def _check_threshold(self, value: float, threshold: Threshold) -> bool:
         """Check if value passes threshold."""
         ops = {
@@ -119,17 +122,18 @@ thresholds:
 ```python
 # umpyre/validators.py
 
+
 def check_docstring_ratio(metrics: dict) -> tuple[bool, str]:
     """
     Custom validator: check if docstring ratio is acceptable.
-    
+
     Returns:
         (passed, message)
     """
     docs = metrics["metrics"]["umpyre_stats"]["docs_lines"]
     total = metrics["metrics"]["umpyre_stats"]["total_lines"]
     ratio = docs / total if total > 0 else 0
-    
+
     if ratio < 0.1:
         return False, f"Docstring ratio {ratio:.1%} is below 10%"
     return True, "Docstring ratio acceptable"
@@ -158,13 +162,14 @@ python -m umpyre.cli validate --violations-only
 ```python
 # umpyre/collectors/bandit_collector.py
 
+
 class BanditCollector(MetricCollector):
     """Collect security metrics using Bandit."""
-    
+
     def collect(self) -> dict:
         """
         Run bandit security scan.
-        
+
         Returns:
             {
                 "total_issues": 12,
@@ -206,13 +211,14 @@ collectors:
 ```python
 # umpyre/collectors/interrogate_collector.py
 
+
 class InterrogateCollector(MetricCollector):
     """Collect docstring coverage using interrogate."""
-    
+
     def collect(self) -> dict:
         """
         Run interrogate to check docstring coverage.
-        
+
         Returns:
             {
                 "coverage": 78.5,
@@ -237,13 +243,14 @@ class InterrogateCollector(MetricCollector):
 ```python
 # umpyre/collectors/mypy_collector.py
 
+
 class MyPyCollector(MetricCollector):
     """Collect type checking results using mypy."""
-    
+
     def collect(self) -> dict:
         """
         Run mypy type checker.
-        
+
         Returns:
             {
                 "total_errors": 15,
@@ -273,13 +280,14 @@ class MyPyCollector(MetricCollector):
 ```python
 # umpyre/collectors/pylint_collector.py
 
+
 class PylintCollector(MetricCollector):
     """Collect code quality score using Pylint."""
-    
+
     def collect(self) -> dict:
         """
         Run pylint code analysis.
-        
+
         Returns:
             {
                 "score": 8.5,  # Out of 10
@@ -314,13 +322,14 @@ Manage metrics history efficiently (pruning, compression, rotation).
 ```python
 # umpyre/storage/pruning.py
 
+
 class MetricsPruner:
     """Prune old metrics to save space."""
-    
+
     def prune(self, branch: str = "code-metrics"):
         """
         Prune metrics history based on retention policy.
-        
+
         Strategy:
         - Keep all metrics < 30 days old
         - Keep weekly snapshots for 30-90 days
@@ -353,17 +362,16 @@ storage:
 ```python
 # umpyre/storage/compression.py
 
+
 class MetricsCompressor:
     """Compress old metrics files."""
-    
+
     def compress_old_files(
-        self,
-        branch: str = "code-metrics",
-        older_than_days: int = 90
+        self, branch: str = "code-metrics", older_than_days: int = 90
     ):
         """
         Compress metrics older than N days.
-        
+
         Changes:
         - 2024_01_15_10_30_00__abc1234__0.1.0.json
         → 2024_01_15_10_30_00__abc1234__0.1.0.json.gz
@@ -383,14 +391,11 @@ class MetricsCompressor:
 ```python
 # umpyre/storage/rotation.py
 
+
 class MetricsRotator:
     """Rotate out very old metrics."""
-    
-    def rotate(
-        self,
-        branch: str = "code-metrics",
-        max_age_days: int = 365
-    ):
+
+    def rotate(self, branch: str = "code-metrics", max_age_days: int = 365):
         """Delete metrics older than max_age_days."""
         # Parse timestamps
         # Delete files older than threshold
@@ -418,47 +423,48 @@ Handle schema version changes gracefully with automatic migrations.
 ```python
 # umpyre/schema.py (enhanced)
 
+
 class MetricSchema:
     """Versioned schema with migration support."""
-    
+
     version: str = "1.1"  # Bump version
-    
+
     @classmethod
     def migrate(cls, data: dict, from_version: str) -> dict:
         """
         Migrate data from old schema to current.
-        
+
         Migration chain:
         1.0 → 1.1 → 1.2 → ...
         """
         if from_version == cls.current_version():
             return data
-        
+
         # Migration registry
         migrations = {
             "1.0": cls._migrate_1_0_to_1_1,
             "1.1": cls._migrate_1_1_to_1_2,
         }
-        
+
         # Apply migrations in sequence
         current_version = from_version
         current_data = data
-        
+
         while current_version != cls.current_version():
             if current_version not in migrations:
                 raise ValueError(f"No migration path from {current_version}")
-            
+
             migrator = migrations[current_version]
             current_data = migrator(current_data)
             current_version = cls._next_version(current_version)
-        
+
         return current_data
-    
+
     @classmethod
     def _migrate_1_0_to_1_1(cls, data: dict) -> dict:
         """
         Migrate from schema 1.0 to 1.1.
-        
+
         Changes in 1.1:
         - Added pypi_version field
         - Added collection_duration_seconds
@@ -468,10 +474,10 @@ class MetricSchema:
             for collector_name, metrics in data["metrics"].items():
                 if "pypi_version" not in metrics:
                     metrics["pypi_version"] = None
-        
+
         data["schema_version"] = "1.1"
         return data
-    
+
     @classmethod
     def _migrate_1_1_to_1_2(cls, data: dict) -> dict:
         """Future migration example."""
@@ -484,22 +490,23 @@ class MetricSchema:
 ```python
 # umpyre/storage/formats.py (enhanced)
 
+
 def load_metrics(filepath: Path) -> dict:
     """
     Load metrics with automatic schema migration.
-    
+
     If old schema detected, automatically migrates to current.
     """
     with open(filepath) as f:
         data = json.load(f)
-    
+
     schema_version = data.get("schema_version", "1.0")
     current_version = MetricSchema.current_version()
-    
+
     if schema_version != current_version:
         print(f"Migrating from schema {schema_version} to {current_version}")
         data = MetricSchema.migrate(data, from_version=schema_version)
-    
+
     return data
 ```
 

{umpyre-0.1.7 → umpyre-0.1.9}/misc/docs/STORAGE_STRUCTURE.md

@@ -128,10 +128,11 @@ ls -t history/*__0.1.0.json | head -1
 import re
 from pathlib import Path
 
+
 def parse_metric_filename(filename: str) -> dict:
     """
     Parse metric filename into components.
-    
+
     Example: "2025_11_14_22_45_00__700e012__0.1.0.json"
     Returns: {
         "timestamp": "2025-11-14T22:45:00",
@@ -139,27 +140,32 @@ def parse_metric_filename(filename: str) -> dict:
         "pypi_version": "0.1.0",
     }
     """
-    pattern = r'(\d{4}_\d{2}_\d{2}_\d{2}_\d{2}_\d{2})__(\w{7})__(.+)\.json'
+    pattern = r"(\d{4}_\d{2}_\d{2}_\d{2}_\d{2}_\d{2})__(\w{7})__(.+)\.json"
     match = re.match(pattern, filename)
-    
+
     if not match:
         raise ValueError(f"Invalid filename format: {filename}")
-    
+
     timestamp_str, sha, version = match.groups()
-    
+
     # Convert timestamp to ISO format
-    timestamp = timestamp_str.replace('_', '-', 2).replace('_', ':', 2).replace('_', 'T', 1)
-    
+    timestamp = (
+        timestamp_str.replace("_", "-", 2).replace("_", ":", 2).replace("_", "T", 1)
+    )
+
     return {
         "timestamp": timestamp,
         "commit_sha": sha,
         "pypi_version": None if version == "none" else version,
     }
 
+
 # Usage
 for file in Path("history").glob("*.json"):
     info = parse_metric_filename(file.name)
-    print(f"Commit {info['commit_sha']} at {info['timestamp']} (v{info['pypi_version']})")
+    print(
+        f"Commit {info['commit_sha']} at {info['timestamp']} (v{info['pypi_version']})"
+    )
 ```
 
 ## Metrics Schema

{umpyre-0.1.7 → umpyre-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "umpyre"
-version = "0.1.7"
+version = "0.1.9"
 description = "Code analysis and quality metrics tracking system for CI/CD"
 readme = "README.md"
 requires-python = ">=3.10"

{umpyre-0.1.7 → umpyre-0.1.9}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = umpyre
-version = 0.1.7
+version = 0.1.9
 url = https://github.com/i2mint/umpyre
 platforms = any
 description_file = README.md

umpyre-0.1.9/tests/test_git_branch_storage.py

@@ -0,0 +1,77 @@
+"""GitBranchStorage pushes to the repository's real remote, not to the local workspace (umpyre#8)."""
+
+import os
+import subprocess
+
+import pytest
+
+from umpyre.storage.git_branch import GitBranchStorage
+
+
+def _git(*args, cwd):
+    return subprocess.run(
+        ["git", *args], cwd=cwd, capture_output=True, text=True, check=True
+    ).stdout.strip()
+
+
+@pytest.fixture
+def workspace(tmp_path):
+    """A workspace whose ``origin`` is a bare repo standing in for GitHub."""
+    remote = tmp_path / "remote.git"
+    work = tmp_path / "work"
+    _git("init", "--bare", "-q", str(remote), cwd=tmp_path)
+    _git("init", "-q", str(work), cwd=tmp_path)
+    for k, v in (("user.name", "t"), ("user.email", "t@t")):
+        _git("config", k, v, cwd=work)
+    (work / "a.txt").write_text("a")
+    _git("add", ".", cwd=work)
+    _git("commit", "-qm", "init", cwd=work)
+    _git("remote", "add", "origin", str(remote), cwd=work)
+    return work, remote
+
+
+def test_metrics_land_on_the_remote_and_accumulate(workspace):
+    work, remote = workspace
+    storage = GitBranchStorage(str(work))
+    storage.store_metrics({"metrics": {"n": 1}}, "a" * 40, branch="code-metrics")
+    # on the (bare) remote, not merely in the local workspace
+    assert _git("rev-parse", "--verify", "code-metrics", cwd=remote)
+    storage.store_metrics({"metrics": {"n": 2}}, "b" * 40, branch="code-metrics")
+    log = _git("log", "--format=%s", "code-metrics", cwd=remote).splitlines()
+    assert log == [f"Update metrics for {'b' * 7}", f"Update metrics for {'a' * 7}"]
+
+
+def test_token_becomes_a_host_scoped_auth_header_not_a_url(monkeypatch):
+    monkeypatch.delenv("GIT_CONFIG_COUNT", raising=False)
+    monkeypatch.delenv("GITHUB_SERVER_URL", raising=False)
+    storage = GitBranchStorage.__new__(GitBranchStorage)
+    storage.token = "s3cret"
+    env = storage._git_env("https://user@github.com/org/repo.git")
+    assert int(env["GIT_CONFIG_COUNT"]) == 2
+    key = "http.https://github.com/.extraheader"
+    assert [env["GIT_CONFIG_KEY_0"], env["GIT_CONFIG_KEY_1"]] == [key, key]
+    # an empty header first clears the one actions/checkout leaves in the config
+    assert env["GIT_CONFIG_VALUE_0"] == ""
+    assert env["GIT_CONFIG_VALUE_1"].startswith("AUTHORIZATION: basic ")
+    assert "s3cret" not in env["GIT_CONFIG_VALUE_1"]  # base64, not plain
+
+
+def test_token_header_appends_to_existing_git_config_env(monkeypatch):
+    monkeypatch.setenv("GIT_CONFIG_COUNT", "1")
+    monkeypatch.delenv("GITHUB_SERVER_URL", raising=False)
+    storage = GitBranchStorage.__new__(GitBranchStorage)
+    storage.token = "t"
+    env = storage._git_env("https://github.com/o/r")
+    assert env["GIT_CONFIG_COUNT"] == "3" and "GIT_CONFIG_KEY_2" in env
+
+
+def test_no_header_without_token_for_local_ssh_or_foreign_hosts(monkeypatch):
+    monkeypatch.delenv("GITHUB_SERVER_URL", raising=False)
+    storage = GitBranchStorage.__new__(GitBranchStorage)
+    storage.token = "t"
+    for url in ("/some/local/path", "git@github.com:o/r.git", None):
+        assert storage._git_env(url) == dict(os.environ)
+    monkeypatch.setenv("GITHUB_SERVER_URL", "https://github.com")
+    assert storage._git_env("https://evil.example/o/r") == dict(os.environ)
+    storage.token = None
+    assert storage._git_env("https://github.com/o/r") == dict(os.environ)

{umpyre-0.1.7 → umpyre-0.1.9}/umpyre/cli.py

@@ -106,14 +106,15 @@ def cmd_collect(args):
 
             print(json.dumps(metric_data, indent=2))
         else:
-            storage = GitBranchStorage(repo_path)
+            branch = args.storage_branch or config.storage_branch
+            storage = GitBranchStorage(repo_path, token=os.getenv("GITHUB_TOKEN"))
             storage.store_metrics(
                 metric_data,
                 commit_sha,
-                branch=config.storage_branch,
+                branch=branch,
                 formats=config.storage_formats,
             )
-            print(f"Metrics stored to branch '{config.storage_branch}'")
+            print(f"Metrics stored to branch '{branch}'")
 
         print(f"Collection completed in {duration:.2f}s")
         return 0
@@ -202,6 +203,11 @@ def main():
     collect_parser.add_argument(
         "--message", help="Commit message (default: auto-detect from git)"
     )
+    collect_parser.add_argument(
+        "--storage-branch",
+        help="Branch to store metrics on (default: storage.branch of the config, "
+        "else 'code-metrics')",
+    )
     collect_parser.add_argument(
         "--no-store", action="store_true", help="Collect but don't store (dry-run)"
     )

{umpyre-0.1.7 → umpyre-0.1.9}/umpyre/python_code_stats.py

@@ -341,12 +341,3 @@ def stats_of(
     put_at_the_front = [x for x in df.index if x not in put_at_the_end]
     df = df.loc[put_at_the_front + put_at_the_end]
     return df
-
-
-if __name__ == "__main__":
-    from dol.util import ModuleNotFoundErrorNiceMessage
-
-    with ModuleNotFoundErrorNiceMessage():
-        import argh
-
-        argh.dispatch_commands([modules_info_df, modules_info_df_stats, stats_of])

{umpyre-0.1.7 → umpyre-0.1.9}/umpyre/storage/git_branch.py

@@ -1,10 +1,13 @@
 """Git branch-based storage operations."""
 
+import base64
+import os
 import subprocess
 import tempfile
 from datetime import datetime
 from pathlib import Path
 from typing import Optional
+from urllib.parse import urlsplit
 
 from umpyre.storage.formats import serialize_metrics
 
@@ -22,16 +25,25 @@ class GitBranchStorage:
         >>> storage.store_metrics(metrics, "abc123", branch="code-metrics")  #doctest: +SKIP
     """
 
-    def __init__(self, repo_path: str, remote: str = "origin"):
+    def __init__(
+        self, repo_path: str, remote: str = "origin", *, token: Optional[str] = None
+    ):
         """
         Initialize storage.
 
+        Metrics are pushed to the URL of ``remote`` in ``repo_path`` (e.g. GitHub),
+        not to ``repo_path`` itself.
+
         Args:
             repo_path: Path to git repository
             remote: Git remote name
+            token: Access token used (as an HTTP auth header scoped to the remote's
+                host, never written to a URL or config) to push to an https remote.
+                Without it, the push uses whatever credentials git already has.
         """
         self.repo_path = Path(repo_path)
         self.remote = remote
+        self.token = token
 
         if not (self.repo_path / ".git").exists():
             raise ValueError(f"Not a git repository: {repo_path}")
@@ -91,9 +103,46 @@ class GitBranchStorage:
                 elif fmt == "csv":
                     serialize_metrics(metrics, tmpdir / "metrics.csv", format="csv")
 
-            # Commit and push
+            # Commit and push (to the real remote, not to the local workspace)
             self._commit_and_push(tmpdir, branch, commit_sha)
 
+    def _remote_url(self) -> Optional[str]:
+        """URL of the real remote of ``repo_path``, or ``None`` if it has none."""
+        result = subprocess.run(
+            ["git", "remote", "get-url", self.remote],
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.stdout.strip() or None if result.returncode == 0 else None
+
+    def _git_env(self, url: Optional[str]) -> dict:
+        """Environment for git commands that talk to the remote (auth header, if any)."""
+        env = dict(os.environ)
+        parts = urlsplit(url or "")
+        host = parts.netloc.rsplit("@", 1)[-1]
+        server_host = urlsplit(env.get("GITHUB_SERVER_URL", "")).netloc
+        if (
+            self.token
+            and parts.scheme in ("http", "https")
+            and host
+            and (not server_host or host == server_host)
+        ):
+            env["GIT_TERMINAL_PROMPT"] = "0"  # fail, don't wait for a password
+            key = f"http.{parts.scheme}://{host}/.extraheader"
+            credentials = base64.b64encode(f"x-access-token:{self.token}".encode())
+            n = int(env.get("GIT_CONFIG_COUNT") or 0)
+            # actions/checkout leaves its own Authorization header in the repo config,
+            # and GitHub rejects two (HTTP 400): an empty value clears earlier ones.
+            for i, value in enumerate(
+                ("", f"AUTHORIZATION: basic {credentials.decode()}")
+            ):
+                env[f"GIT_CONFIG_KEY_{n + i}"] = key
+                env[f"GIT_CONFIG_VALUE_{n + i}"] = value
+            env["GIT_CONFIG_COUNT"] = str(n + 2)
+        return env
+
     def _fetch_branch(self, branch: str):
         """Fetch metrics branch from remote."""
         try:
@@ -103,6 +152,7 @@ class GitBranchStorage:
                 capture_output=True,
                 check=False,  # May not exist yet
                 timeout=30,
+                env=self._git_env(self._remote_url()),
             )
         except subprocess.TimeoutExpired:
             pass
@@ -158,6 +208,17 @@ class GitBranchStorage:
 
     def _commit_and_push(self, work_dir: Path, branch: str, commit_sha: str):
         """Commit changes and push to remote."""
+        # The clone's origin is the local workspace; point it at the real remote.
+        remote_url = self._remote_url()
+        if remote_url:
+            subprocess.run(
+                ["git", "remote", "set-url", "origin", remote_url],
+                cwd=work_dir,
+                capture_output=True,
+                check=True,
+            )
+        env = self._git_env(remote_url)
+
         # Configure git
         subprocess.run(
             ["git", "config", "user.name", "umpyre-bot"],
@@ -202,21 +263,24 @@ class GitBranchStorage:
             for attempt in range(3):
                 try:
                     subprocess.run(
-                        ["git", "push", self.remote, branch],
+                        ["git", "push", "origin", branch],
                         cwd=work_dir,
                         capture_output=True,
                         check=True,
                         timeout=60,
+                        env=env,
                     )
                     break
                 except subprocess.CalledProcessError:
                     if attempt < 2:
                         # Pull and try again
                         subprocess.run(
-                            ["git", "pull", "--rebase", self.remote, branch],
+                            ["git", "pull", "--rebase", "origin", branch],
                             cwd=work_dir,
                             capture_output=True,
                             check=False,
+                            timeout=60,
+                            env=env,
                         )
                     else:
                         raise

umpyre-0.1.7/actions/track-metrics/action.yml

@@ -1,74 +0,0 @@
-name: Track Code Metrics
-description: Collect and store code quality metrics for CI/CD pipelines
-
-inputs:
-  config-path:
-    description: 'Path to umpyre config file'
-    default: '.github/umpyre-config.yml'
-    required: false
-  
-  storage-branch:
-    description: 'Branch to store metrics'
-    default: 'code-metrics'
-    required: false
-  
-  github-token:
-    description: 'GitHub token for API access'
-    required: true
-  
-  force-run:
-    description: 'Run even if workflow failed'
-    default: 'false'
-    required: false
-  
-  python-version:
-    description: 'Python version to use'
-    default: '3.10'
-    required: false
-
-runs:
-  using: composite
-  steps:
-    - name: Setup Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ inputs.python-version }}
-    
-    - name: Install umpyre and dependencies
-      shell: bash
-      run: |
-        pip install umpyre coverage wily bandit interrogate
-    
-    - name: Collect and Store Metrics
-      shell: bash
-      run: |
-        echo "::group::Collecting Code Metrics"
-        
-        # Set up error handling - continue even if collection fails
-        set +e
-        
-        # Run umpyre collect
-        if [ -f "${{ inputs.config-path }}" ]; then
-          python -m umpyre.cli collect --config "${{ inputs.config-path }}"
-          EXIT_CODE=$?
-        else
-          python -m umpyre.cli collect
-          EXIT_CODE=$?
-        fi
-        
-        # Report status but don't fail
-        if [ $EXIT_CODE -eq 0 ]; then
-          echo "✅ Metrics collection completed successfully"
-        else
-          echo "⚠️ Metrics collection failed with exit code $EXIT_CODE"
-          echo "This is informational only - CI pipeline continues"
-        fi
-        
-        echo "::endgroup::"
-        
-        # Always exit successfully to not break CI
-        exit 0
-
-branding:
-  icon: 'bar-chart-2'
-  color: 'blue'