highlightjs-opl 1.0.2 → 1.0.4

package/.local/python/lib/python3.12/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,239 @@
+# don't import any costly modules
+import os
+import sys
+
+report_url = (
+    "https://github.com/pypa/setuptools/issues/new?template=distutils-deprecation.yml"
+)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Setuptools is replacing distutils. Support for replacing "
+        "an already imported distutils is deprecated. In the future, "
+        "this condition will fail. "
+        f"Register concerns at {report_url}"
+    )
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    if which == 'stdlib':
+        import warnings
+
+        warnings.warn(
+            "Reliance on distutils from stdlib is deprecated. Users "
+            "must rely on setuptools to provide the distutils module. "
+            "Avoid importing distutils or import setuptools first, "
+            "and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. "
+            f"Register concerns at {report_url}"
+        )
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns) -> None:
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self) -> None:
+        insert_shim()
+
+    def __exit__(self, exc: object, value: object, tb: object) -> None:
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim

package/.local/python/lib/python3.12/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

package/.local/python/lib/python3.12/site-packages/benchmarks/benchmark.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""
+Pipenv benchmark runner based on python-package-manager-shootout.
+"""
+import csv
+import os
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+from typing import List, Tuple
+
+
+def subprocess_env():
+    """Get environment variables for subprocess calls with CI-friendly settings."""
+    env = os.environ.copy()
+    # Ensure pipenv doesn't wait for user input
+    env["PIPENV_YES"] = "1"
+    env["PIPENV_NOSPIN"] = "1"
+    # Force pipenv to create its own venv, not use any existing one
+    env["PIPENV_IGNORE_VIRTUALENVS"] = "1"
+    # Suppress courtesy notices
+    env["PIPENV_VERBOSITY"] = "-1"
+    return env
+
+
+class PipenvBenchmark:
+    def __init__(self, benchmark_dir: Path):
+        self.benchmark_dir = benchmark_dir
+        self.timings_dir = benchmark_dir / "timings"
+        self.timings_dir.mkdir(exist_ok=True)
+        self.requirements_url = "https://raw.githubusercontent.com/getsentry/sentry/51281a6abd8ff4a93d2cebc04e1d5fc7aa9c4c11/requirements-base.txt"
+        self.test_package = "goodconf"
+
+    def run_timed_command(
+        self, command: List[str], timing_file: str, cwd: Path = None, timeout: int = 600
+    ) -> Tuple[float, int]:
+        """Run a command and measure execution time."""
+        if cwd is None:
+            cwd = self.benchmark_dir
+
+        # Set environment to prevent interactive prompts
+        env = subprocess_env()
+
+        print(f"  Running: {' '.join(command)}", flush=True)
+        start_time = time.time()
+
+        # Use Popen with communicate() to avoid pipe buffer deadlock
+        # that can occur with capture_output=True on commands with lots of output
+        process = subprocess.Popen(
+            command,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env=env,
+        )
+
+        try:
+            stdout, stderr = process.communicate(timeout=timeout)
+            elapsed = time.time() - start_time
+            returncode = process.returncode
+
+            if returncode != 0:
+                print(f"  ✗ Command failed after {elapsed:.3f}s: {' '.join(command)}")
+                print(f"  Return code: {returncode}")
+                if stderr and stderr.strip():
+                    print("  Error output:")
+                    for line in stderr.strip().split("\n")[:5]:
+                        print(f"    {line}")
+                if stdout and stdout.strip():
+                    print("  Stdout:")
+                    for line in stdout.strip().split("\n")[:3]:
+                        print(f"    {line}")
+                raise subprocess.CalledProcessError(returncode, command, stdout, stderr)
+
+            # Write timing info (simplified format for cross-platform compatibility)
+            timing_path = self.timings_dir / timing_file
+            with open(timing_path, "w") as f:
+                f.write(
+                    f"{elapsed:.3f},0,0,0,0,0,0\n"
+                )  # elapsed,system,user,cpu%,maxrss,inputs,outputs
+
+            print(f"  ✓ Completed in {elapsed:.3f}s")
+            if stdout and stdout.strip():
+                # Show first few lines of output
+                output_lines = stdout.strip().split("\n")[:3]
+                for line in output_lines:
+                    print(f"    {line[:100]}")
+                if len(stdout.strip().split("\n")) > 3:
+                    print("    ...")
+
+            return elapsed, returncode
+
+        except subprocess.TimeoutExpired:
+            process.kill()
+            stdout, stderr = process.communicate()
+            elapsed = time.time() - start_time
+            print(f"  ✗ Command timed out after {elapsed:.3f}s: {' '.join(command)}")
+            print(f"  Timeout was set to {timeout}s")
+            if stdout and stdout.strip():
+                print("  Stdout before timeout:")
+                for line in stdout.strip().split("\n")[-10:]:
+                    print(f"    {line}")
+            if stderr and stderr.strip():
+                print("  Stderr before timeout:")
+                for line in stderr.strip().split("\n")[-5:]:
+                    print(f"    {line}")
+            raise
+
+    def setup_requirements(self):
+        """Download and prepare requirements.txt."""
+        print("Setting up requirements.txt...")
+        requirements_path = self.benchmark_dir / "requirements.txt"
+
+        try:
+            with urllib.request.urlopen(self.requirements_url) as response:
+                content = response.read().decode("utf-8")
+
+            # Filter out --index-url lines like the original
+            filtered_lines = [
+                line
+                for line in content.splitlines()
+                if not line.strip().startswith("--index-url")
+            ]
+
+            with open(requirements_path, "w") as f:
+                f.write("\n".join(filtered_lines))
+
+            print(f"Downloaded {len(filtered_lines)} requirements")
+
+        except Exception as e:
+            print(f"Failed to download requirements: {e}")
+            raise
+
+    def clean_cache(self):
+        """Clean pipenv and pip caches."""
+        print("Cleaning caches...")
+        cache_dirs = [Path.home() / ".cache" / "pip", Path.home() / ".cache" / "pipenv"]
+
+        for cache_dir in cache_dirs:
+            if cache_dir.exists():
+                shutil.rmtree(cache_dir, ignore_errors=True)
+
+    def clean_venv(self):
+        """Clean virtual environment."""
+        print("Cleaning virtual environment...")
+        try:
+            # Get venv path
+            result = subprocess.run(
+                ["pipenv", "--venv"],
+                cwd=self.benchmark_dir,
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=30,
+                env=subprocess_env(),
+            )
+            if result.returncode == 0:
+                venv_path = Path(result.stdout.strip())
+                if venv_path.exists():
+                    print(f"  Removing venv: {venv_path}")
+                    shutil.rmtree(venv_path, ignore_errors=True)
+            else:
+                print("  No virtual environment found")
+        except subprocess.TimeoutExpired:
+            print("  Warning: pipenv --venv timed out")
+        except Exception as e:
+            print(f"  Warning: Could not clean venv: {e}")
+            pass  # Ignore errors if venv doesn't exist
+
+    def clean_lock(self):
+        """Remove Pipfile.lock."""
+        print("Cleaning lock file...")
+        lock_file = self.benchmark_dir / "Pipfile.lock"
+        if lock_file.exists():
+            lock_file.unlink()
+
+    def benchmark_tooling(self):
+        """Benchmark pipenv installation (using current dev version)."""
+        print("Benchmarking tooling...")
+        # Install current development version
+        parent_dir = self.benchmark_dir.parent
+        elapsed, _ = self.run_timed_command(
+            [sys.executable, "-m", "pip", "install", "-e", str(parent_dir)], "tooling.txt"
+        )
+        print(f"Tooling completed in {elapsed:.3f}s")
+
+    def benchmark_import(self):
+        """Benchmark importing requirements.txt to Pipfile."""
+        print("Benchmarking import...")
+        elapsed, _ = self.run_timed_command(
+            ["pipenv", "install", "-r", "requirements.txt"], "import.txt"
+        )
+        print(f"Import completed in {elapsed:.3f}s")
+
+    def benchmark_lock(self, timing_file: str):
+        """Benchmark lock file generation."""
+        print(f"Benchmarking lock ({timing_file})...")
+        elapsed, _ = self.run_timed_command(["pipenv", "lock"], timing_file)
+        print(f"Lock completed in {elapsed:.3f}s")
+
+    def benchmark_install(self, timing_file: str):
+        """Benchmark package installation."""
+        print(f"Benchmarking install ({timing_file})...")
+        elapsed, _ = self.run_timed_command(["pipenv", "sync"], timing_file)
+        print(f"Install completed in {elapsed:.3f}s")
+
+    def benchmark_update(self, timing_file: str):
+        """Benchmark package updates."""
+        print(f"Benchmarking update ({timing_file})...")
+        elapsed, _ = self.run_timed_command(["pipenv", "update"], timing_file)
+        print(f"Update completed in {elapsed:.3f}s")
+
+    def benchmark_add_package(self):
+        """Benchmark adding a new package."""
+        print("Benchmarking add package...")
+        elapsed, _ = self.run_timed_command(
+            ["pipenv", "install", self.test_package], "add-package.txt"
+        )
+        print(f"Add package completed in {elapsed:.3f}s")
+
+    def get_pipenv_version(self) -> str:
+        """Get pipenv version."""
+        try:
+            result = subprocess.run(
+                ["pipenv", "--version"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=30,
+                env=subprocess_env(),
+            )
+            # Extract version from "pipenv, version X.X.X"
+            return result.stdout.split()[-1]
+        except Exception:
+            return "unknown"
+
+    def generate_stats(self):
+        """Generate CSV stats file."""
+        print("Generating stats...")
+        version = self.get_pipenv_version()
+        timestamp = int(time.time())
+
+        stats_file = self.benchmark_dir / "stats.csv"
+
+        with open(stats_file, "w", newline="") as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(
+                [
+                    "tool",
+                    "version",
+                    "timestamp",
+                    "stat",
+                    "elapsed time",
+                    "system",
+                    "user",
+                    "cpu percent",
+                    "max rss",
+                    "inputs",
+                    "outputs",
+                ]
+            )
+
+            stats = [
+                "tooling",
+                "import",
+                "lock-cold",
+                "lock-warm",
+                "install-cold",
+                "install-warm",
+                "update-cold",
+                "update-warm",
+                "add-package",
+            ]
+
+            for stat in stats:
+                timing_file = self.timings_dir / f"{stat}.txt"
+                if timing_file.exists():
+                    with open(timing_file) as f:
+                        timing_data = f.read().strip()
+                    writer.writerow(["pipenv", version, timestamp, stat, timing_data])
+
+        print(f"Stats written to {stats_file}")
+
+    def run_full_benchmark(self):
+        """Run the complete benchmark suite."""
+        print("=" * 60)
+        print("Starting pipenv benchmark suite...")
+        print("=" * 60)
+
+        total_steps = 11
+
+        # Setup
+        print(f"\n[1/{total_steps}] Setup")
+        print("-" * 40)
+        self.setup_requirements()
+
+        # Tooling
+        print(f"\n[2/{total_steps}] Tooling")
+        print("-" * 40)
+        self.benchmark_tooling()
+
+        # Import
+        print(f"\n[3/{total_steps}] Import")
+        print("-" * 40)
+        self.benchmark_import()
+
+        # Lock cold
+        print(f"\n[4/{total_steps}] Lock (cold)")
+        print("-" * 40)
+        self.clean_cache()
+        self.clean_venv()
+        self.clean_lock()
+        self.benchmark_lock("lock-cold.txt")
+
+        # Lock warm
+        print(f"\n[5/{total_steps}] Lock (warm)")
+        print("-" * 40)
+        self.clean_lock()
+        self.benchmark_lock("lock-warm.txt")
+
+        # Install cold
+        print(f"\n[6/{total_steps}] Install (cold)")
+        print("-" * 40)
+        self.clean_cache()
+        self.clean_venv()
+        self.benchmark_install("install-cold.txt")
+
+        # Install warm
+        print(f"\n[7/{total_steps}] Install (warm)")
+        print("-" * 40)
+        self.clean_venv()
+        self.benchmark_install("install-warm.txt")
+
+        # Update cold
+        print(f"\n[8/{total_steps}] Update (cold)")
+        print("-" * 40)
+        self.clean_cache()
+        self.benchmark_update("update-cold.txt")
+
+        # Update warm
+        print(f"\n[9/{total_steps}] Update (warm)")
+        print("-" * 40)
+        self.benchmark_update("update-warm.txt")
+
+        # Add package
+        print(f"\n[10/{total_steps}] Add package")
+        print("-" * 40)
+        self.benchmark_add_package()
+
+        # Generate stats
+        print(f"\n[11/{total_steps}] Generate stats")
+        print("-" * 40)
+        self.generate_stats()
+
+        print("\n" + "=" * 60)
+        print("Benchmark suite completed!")
+        print("=" * 60)
+
+
+def main():
+    benchmark_dir = Path(__file__).parent
+    benchmark = PipenvBenchmark(benchmark_dir)
+
+    if len(sys.argv) > 1:
+        operation = sys.argv[1]
+        if operation == "setup":
+            benchmark.setup_requirements()
+        elif operation == "tooling":
+            benchmark.benchmark_tooling()
+        elif operation == "import":
+            benchmark.benchmark_import()
+        elif operation == "lock-cold":
+            benchmark.clean_cache()
+            benchmark.clean_venv()
+            benchmark.clean_lock()
+            benchmark.benchmark_lock("lock-cold.txt")
+        elif operation == "lock-warm":
+            benchmark.clean_lock()
+            benchmark.benchmark_lock("lock-warm.txt")
+        elif operation == "install-cold":
+            benchmark.clean_cache()
+            benchmark.clean_venv()
+            benchmark.benchmark_install("install-cold.txt")
+        elif operation == "install-warm":
+            benchmark.clean_venv()
+            benchmark.benchmark_install("install-warm.txt")
+        elif operation == "update-cold":
+            benchmark.clean_cache()
+            benchmark.benchmark_update("update-cold.txt")
+        elif operation == "update-warm":
+            benchmark.benchmark_update("update-warm.txt")
+        elif operation == "add-package":
+            benchmark.benchmark_add_package()
+        elif operation == "stats":
+            benchmark.generate_stats()
+        else:
+            print(f"Unknown operation: {operation}")
+            sys.exit(1)
+    else:
+        benchmark.run_full_benchmark()
+
+
+if __name__ == "__main__":
+    main()

package/.local/python/lib/python3.12/site-packages/certifi/__init__.py

@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2026.02.25"

package/.local/python/lib/python3.12/site-packages/certifi/__main__.py

@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())