From 6d34ff297e5ecda8d3c14fda0b3ed9bc2c04d063 Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Fri, 4 Sep 2026 10:53:20 -0700 Subject: [PATCH 01/29] init: job-bench Signed-off-by: Sugam Devare --- benchmarks/job_bench/data/.gitignore | 1 + benchmarks/job_bench/opencode.yaml | 42 ++ benchmarks/job_bench/prepare.py | 22 + resources_servers/job_bench/.gitignore | 1 + resources_servers/job_bench/Dockerfile | 60 ++ resources_servers/job_bench/README.md | 125 ++++ resources_servers/job_bench/__init__.py | 0 resources_servers/job_bench/app.py | 504 ++++++++++++++ .../job_bench/configs/job_bench.yaml | 49 ++ resources_servers/job_bench/data/.gitignore | 8 + .../job_bench/data/example.jsonl | 5 + resources_servers/job_bench/judge.py | 517 ++++++++++++++ resources_servers/job_bench/prepare.py | 205 ++++++ resources_servers/job_bench/requirements.txt | 7 + resources_servers/job_bench/task_data.py | 84 +++ resources_servers/job_bench/task_store.py | 189 ++++++ resources_servers/job_bench/tests/__init__.py | 0 resources_servers/job_bench/tests/conftest.py | 49 ++ resources_servers/job_bench/tests/test_app.py | 632 ++++++++++++++++++ .../job_bench/tests/test_judge.py | 621 +++++++++++++++++ .../job_bench/tests/test_prepare.py | 195 ++++++ .../job_bench/tests/test_task_store.py | 129 ++++ 22 files changed, 3445 insertions(+) create mode 100644 benchmarks/job_bench/data/.gitignore create mode 100644 benchmarks/job_bench/opencode.yaml create mode 100644 benchmarks/job_bench/prepare.py create mode 100644 resources_servers/job_bench/.gitignore create mode 100644 resources_servers/job_bench/Dockerfile create mode 100644 resources_servers/job_bench/README.md create mode 100644 resources_servers/job_bench/__init__.py create mode 100644 resources_servers/job_bench/app.py create mode 100644 resources_servers/job_bench/configs/job_bench.yaml create mode 100644 resources_servers/job_bench/data/.gitignore create mode 100644 resources_servers/job_bench/data/example.jsonl create mode 100644 resources_servers/job_bench/judge.py create mode 100644 resources_servers/job_bench/prepare.py create mode 100644 resources_servers/job_bench/requirements.txt create mode 100644 resources_servers/job_bench/task_data.py create mode 100644 resources_servers/job_bench/task_store.py create mode 100644 resources_servers/job_bench/tests/__init__.py create mode 100644 resources_servers/job_bench/tests/conftest.py create mode 100644 resources_servers/job_bench/tests/test_app.py create mode 100644 resources_servers/job_bench/tests/test_judge.py create mode 100644 resources_servers/job_bench/tests/test_prepare.py create mode 100644 resources_servers/job_bench/tests/test_task_store.py diff --git a/benchmarks/job_bench/data/.gitignore b/benchmarks/job_bench/data/.gitignore new file mode 100644 index 00000000000..b06d45fe69f --- /dev/null +++ b/benchmarks/job_bench/data/.gitignore @@ -0,0 +1 @@ +*benchmark.jsonl diff --git a/benchmarks/job_bench/opencode.yaml b/benchmarks/job_bench/opencode.yaml new file mode 100644 index 00000000000..ec915ad4948 --- /dev/null +++ b/benchmarks/job_bench/opencode.yaml @@ -0,0 +1,42 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +config_paths: + - responses_api_agents/opencode_sandboxed_agent/configs/opencode_sandboxed_agent.yaml + - resources_servers/job_bench/configs/job_bench.yaml + +job_bench_opencode_resources_server: + _inherit_from: job_bench_resources_server + resources_servers: + job_bench: + sandbox_model_server: + type: responses_api_models + name: policy_model + +job_bench_opencode_sandboxed_agent: + _inherit_from: opencode_sandboxed_agent + responses_api_agents: + opencode_sandboxed_agent: + # JobBench's OpenCode runner allows 2h per task before the first retry. + sandbox_timeout: 7200 + + # Several JobBench tasks expect the agent to rediscover reference material + # online, so the browsing tools the SWE presets disable are turned back on. + # These merge into the base opencode_config; the permission block is kept. + opencode_config: + tools: + webfetch: true + websearch: true + + resources_server: + type: resources_servers + name: job_bench_opencode_resources_server + datasets: + - name: job_bench_main + type: benchmark + jsonl_fpath: benchmarks/job_bench/data/job_bench_main_benchmark.jsonl + prepare_script: benchmarks/job_bench/prepare.py + num_repeats: 1 + - name: example + type: example + jsonl_fpath: resources_servers/job_bench/data/example.jsonl diff --git a/benchmarks/job_bench/prepare.py b/benchmarks/job_bench/prepare.py new file mode 100644 index 00000000000..057d00e7c95 --- /dev/null +++ b/benchmarks/job_bench/prepare.py @@ -0,0 +1,22 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Prepare the JobBench main-split benchmark dataset.""" + +from pathlib import Path + + +def prepare() -> Path: + """Materialize the private rubric cache and return the model-visible JSONL.""" + + # Imported lazily so the Hugging Face dependency is only needed when + # preparation actually runs, keeping cached evals runnable from Gym's + # base launcher environment. + from resources_servers.job_bench.prepare import prepare as prepare_job_bench + + _, jsonl_path = prepare_job_bench(split="main") + return jsonl_path + + +if __name__ == "__main__": + print(prepare()) diff --git a/resources_servers/job_bench/.gitignore b/resources_servers/job_bench/.gitignore new file mode 100644 index 00000000000..333c1e910a3 --- /dev/null +++ b/resources_servers/job_bench/.gitignore @@ -0,0 +1 @@ +logs/ diff --git a/resources_servers/job_bench/Dockerfile b/resources_servers/job_bench/Dockerfile new file mode 100644 index 00000000000..433ddac3c96 --- /dev/null +++ b/resources_servers/job_bench/Dockerfile @@ -0,0 +1,60 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +# Sandbox image for the JobBench agent. +# +# JobBench tasks are office data work: reconciling spreadsheets, tracing PDF +# citations, querying SQLite, producing xlsx/docx/pptx deliverables and plots. +# Upstream runs on the operator's workstation with those libraries already +# installed; the sandbox has no such luxury, so the stack is baked in here and +# the agent never needs to pip install (which also keeps hermetic runs working). +# +# docker build -t job-bench-sandbox:latest resources_servers/job_bench +# docker push /job-bench-sandbox:latest +# export JOB_BENCH_SANDBOX_IMAGE=/job-bench-sandbox:latest + +FROM python:3.12-slim-bookworm + +ENV DEBIAN_FRONTEND=noninteractive \ + PIP_NO_CACHE_DIR=1 \ + PYTHONUNBUFFERED=1 \ + MPLBACKEND=Agg + +# ca-certificates for TLS when the agent searches online; git/curl/unzip because +# tasks and agents routinely reach for them; the poppler and libreoffice bits +# cover PDF and Office conversions that pure-Python readers cannot handle. +RUN apt-get update && apt-get install -y --no-install-recommends \ + ca-certificates \ + curl \ + git \ + unzip \ + zip \ + jq \ + sqlite3 \ + poppler-utils \ + libreoffice-calc \ + libreoffice-writer \ + fonts-dejavu-core \ + && rm -rf /var/lib/apt/lists/* + +RUN pip install --no-cache-dir \ + pandas==2.2.3 \ + numpy==2.1.3 \ + scipy==1.14.1 \ + openpyxl==3.1.5 \ + xlrd==2.0.1 \ + XlsxWriter==3.2.0 \ + python-docx==1.1.2 \ + python-pptx==1.0.2 \ + mammoth==1.8.0 \ + pdfplumber==0.11.4 \ + pypdf==5.1.0 \ + reportlab==4.2.5 \ + matplotlib==3.9.2 \ + statsmodels==0.14.4 \ + beautifulsoup4==4.12.3 \ + lxml==5.3.0 \ + tabulate==0.9.0 \ + Pillow==11.0.0 + +WORKDIR /workspace diff --git a/resources_servers/job_bench/README.md b/resources_servers/job_bench/README.md new file mode 100644 index 00000000000..3f1f908a196 --- /dev/null +++ b/resources_servers/job_bench/README.md @@ -0,0 +1,125 @@ +# JobBench + +[JobBench](https://job-bench.github.io/) evaluates agents on the multi-source data preprocessing that professionals +most want offloaded: reconciling contradictory records, cross-referencing spreadsheets, tracing citations. Tasks come +from Workbank, a worker-desire survey spanning 35 white-collar occupations, so the benchmark asks what workers +actually want automated rather than what happens to be automatable. + +This resources server wraps the upstream [job-bench-eval](https://github.com/Job-Bench/job-bench-eval) harness. +An OpenCode agent works in a sandbox seeded with one task's `task_folder/` and writes deliverables to an output +directory; the server then pulls that directory back, renders every file as text, and grades it rubric-by-rubric with +an LLM judge. + +| | | +|---|---| +| Splits | `main` (65 tasks, the leaderboard split), `easy` (63 simplified tasks) | +| Dataset | [`JobBench/job-bench`](https://huggingface.co/datasets/JobBench/job-bench) | +| Agent | `opencode_sandboxed_agent` | +| Reward | Weighted normalized score — `total_score / max_score`, in `[0, 1]` | +| Domain | `agent` | + +## Reward + +Each task ships a `RUBRICS.json` of weighted rubrics, and each rubric holds several criteria. A rubric scores its full +weight only when the judge passes **every** criterion; otherwise it scores zero. The reward is the weighted sum over +the task's maximum weight, matching upstream's `normalized_score`. `pass_rate` (the fraction of rubrics fully passed) +is also reported but is not the reward. + +Because it is a weighted rubric score, the reward is continuous rather than binary — a partially correct deliverable +lands between 0 and 1. + +## Prepare + +`prepare.py` pulls the dataset from Hugging Face into a gitignored control-plane cache and writes the model-visible +JSONL. Rubrics, task cards and `files_required_to_search/` stay in the cache and never reach the agent or the JSONL. + +```bash +python -m resources_servers.job_bench.prepare --split main +``` + +The cache lands at `resources_servers/job_bench/data/cache/tasks////`, and the benchmark +JSONL at `benchmarks/job_bench/data/job_bench_main_benchmark.jsonl`. Re-running is a no-op; pass `--force` to +re-download. `--no-download` prepares from an existing cache. + +## Build the sandbox image + +JobBench tasks manipulate xlsx, docx, pdf and sqlite files and produce plots, so the sandbox needs a data stack. There +is no per-task image upstream, so this server ships one: + +```bash +docker build -t job-bench-sandbox:latest resources_servers/job_bench +docker push /job-bench-sandbox:latest +export JOB_BENCH_SANDBOX_IMAGE=/job-bench-sandbox:latest +``` + +`sandbox_image` defaults to `job-bench-sandbox:latest` and reads `JOB_BENCH_SANDBOX_IMAGE` when set. + +## Run OpenCode rollouts + +Launch with a model config and a sandbox-provider config. Add `+use_absolute_ip=true` when the sandbox needs a +host-routable model-server address. + +```bash +gym env start \ + --config benchmarks/job_bench/opencode.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml \ + --config responses_api_models//configs/.yaml \ + +job_bench_opencode_resources_server.resources_servers.job_bench.judge_model_server.name= +``` + +```bash +gym eval run --no-serve \ + --agent job_bench_opencode_sandboxed_agent \ + --input benchmarks/job_bench/data/job_bench_main_benchmark.jsonl \ + --output results/job_bench_rollouts.jsonl +``` + +## Judge + +Grading is one chat completion per rubric against `judge_model_server`, not an agentic judge loop — that is what keeps +a full pass affordable. Deliverables are rendered to text up front (`max_chars_per_file`, default 200k, guards against +a model dumping a multi-MB input into its output). Rubrics whose text mentions a plot, figure, histogram, Q-Q or +similar additionally get up to `max_vision_images` images attached, pulled from standalone image files, docx-embedded +media and notebook outputs; those rubrics need a judge that accepts multimodal input. + +Upstream validates rubric behavior against `grok-4.3` only. Other judges are exploratory — treat cross-judge +comparisons with care. + +A judge call that fails at the transport level raises `JudgeError`, and Gym routes the row to the failures sidecar +rather than scoring it zero. A reply that arrives but cannot be parsed is a genuine failed grade and scores zero. + +## Network posture and `files_required_to_search/` + +Upstream's runner copies only `task_folder/` into the agent's workspace and imposes no network restriction; several +tasks expect the agent to rediscover reference material online, and the upstream README notes that agents without +browsing score lower. This server matches that by default: + +- `enforce_agent_no_network: false` — the sandbox reaches the internet, and `benchmarks/job_bench/opencode.yaml` + re-enables OpenCode's `webfetch`/`websearch` tools that the SWE presets disable. +- `include_search_files: false` — `files_required_to_search/` is withheld, as upstream withholds it. + +Two knobs change this, both of which move results off the leaderboard's footing: + +- `enforce_agent_no_network: true` gives a hermetic run (deny-all egress, plus the model server when + `sandbox_model_server` is set). Search-dependent tasks will score near zero. +- `include_search_files: true` mounts the search corpus at `/workspace/files_required_to_search`. Combined with the + above it makes runs fully deterministic, but hands the agent material it was meant to find, inflating scores. + +Changing `include_search_files` also changes the agent prompt, so re-run `prepare.py` with +`--include-search-files` to keep the JSONL consistent with the server. + +## Sandbox layout + +``` +/workspace/task_folder/ # task materials, including TASK_INSTRUCTIONS.txt +/workspace/output/ # the agent writes its final deliverables here; this is what gets graded +``` + +Only `/workspace/output` is collected. Anything the agent leaves in `task_folder/` or elsewhere is ignored, exactly as +upstream ignores it. + +## Tests + +```bash +gym env test --resources-server job_bench +``` diff --git a/resources_servers/job_bench/__init__.py b/resources_servers/job_bench/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/job_bench/app.py b/resources_servers/job_bench/app.py new file mode 100644 index 00000000000..19ba4e4c998 --- /dev/null +++ b/resources_servers/job_bench/app.py @@ -0,0 +1,504 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""JobBench resources server. + +An OpenCode agent works in a sandbox seeded with one JobBench ``task_folder`` and +writes deliverables to an output directory. At verify time the server pulls that +directory back, renders every deliverable as text, and grades it rubric-by-rubric +with an LLM judge. The reward is JobBench's weighted normalized score. + +Rubrics never enter the sandbox and never appear in the model-visible JSONL; they +are read from the prepared control-plane cache keyed by task ID. +""" + +from __future__ import annotations + +import asyncio +import sys +import tarfile +import tempfile +from asyncio import Semaphore +from copy import deepcopy +from dataclasses import dataclass +from pathlib import Path +from time import monotonic +from traceback import format_exc +from typing import Any + +from fastapi import Request +from pydantic import BaseModel, ConfigDict, Field + +from nemo_gym.base_resources_server import ( + BaseResourcesServerConfig, + BaseSeedSessionRequest, + BaseSeedSessionResponse, + BaseVerifyRequest, + BaseVerifyResponse, + ReverifyMode, + SimpleResourcesServer, +) +from nemo_gym.config_types import ModelServerRef +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.judge import call_judge +from nemo_gym.openai_utils import NeMoGymChatCompletion, NeMoGymChatCompletionCreateParamsNonStreaming +from nemo_gym.sandbox import AsyncSandbox, SandboxResources, SandboxSpec +from nemo_gym.sandbox.config import resolve_provider_config, resolve_provider_metadata +from nemo_gym.server_utils import SESSION_ID_KEY, get_first_server_config_dict, is_nemo_gym_fastapi_entrypoint +from resources_servers.job_bench.judge import ( + JUDGE_SYSTEM_PROMPT, + MAX_CHARS_PER_FILE, + MAX_VISION_IMAGES, + build_failed_rubric_result, + build_rubric_prompt, + build_rubric_result, + build_scorecard, + build_user_content, + collect_image_attachments, + extract_all_file_contents, + parse_judge_json, + rubric_needs_vision, +) +from resources_servers.job_bench.task_store import ( + OUTPUT_DIR, + SEARCH_FILES_NAME, + TASK_FOLDER_DIR, + TASK_FOLDER_NAME, + WORKSPACE_DIR, + JobBenchTask, + JobBenchTaskStore, +) + + +PACKAGE_DIR = Path(__file__).resolve().parent +NEMO_GYM_ROOT = PACKAGE_DIR.parents[1] + +REMOTE_TASK_ARCHIVE = "/tmp/job_bench_task.tgz" +REMOTE_OUTPUT_ARCHIVE = "/tmp/job_bench_output.tgz" + + +def _resolve_repo_path(path: Path) -> Path: + expanded = path.expanduser() + if expanded.is_absolute(): + return expanded.resolve() + return (NEMO_GYM_ROOT / expanded).resolve() + + +class JobBenchResourcesServerConfig(BaseResourcesServerConfig): + # Verification consumes the agent's live sandbox, so a stored rollout cannot be replayed. + REVERIFY_MODE = ReverifyMode.UNSUPPORTED + + cache_dir: Path = Path("resources_servers/job_bench/data/cache/tasks") + archives_dir: Path = Path("resources_servers/job_bench/data/cache/archives") + split: str = "main" + expected_task_count: int | None = None + + # JobBench's own runner withholds files_required_to_search/ so the agent has to + # rediscover those references online. Enabling this mounts them in the sandbox, + # which makes runs hermetic but no longer comparable to the public leaderboard. + include_search_files: bool = False + + sandbox_provider: str + sandbox_image: str + sandbox_config: dict[str, Any] = Field(default_factory=dict) + # JobBench tasks legitimately need the open internet; deny-all costs the + # search-dependent tasks. Kept as a knob for hermetic runs. + enforce_agent_no_network: bool = False + sandbox_model_server: ModelServerRef | None = None + max_output_mib: int = 512 + + judge_model_server: ModelServerRef + judge_concurrency: int = Field(default=10, ge=1) + judge_max_tokens: int = 200_000 + judge_temperature: float = 0.0 + max_chars_per_file: int = Field(default=MAX_CHARS_PER_FILE, ge=1) + max_vision_images: int = Field(default=MAX_VISION_IMAGES, ge=0) + + include_rubric_details_in_response: bool = True + + +class JobBenchInstanceRequest(BaseModel): + model_config = ConfigDict(extra="allow") + + task_id: str | None = None + verifier_metadata: dict[str, Any] | None = None + + +class JobBenchSeedSessionRequest(JobBenchInstanceRequest, BaseSeedSessionRequest): + pass + + +class JobBenchSeedSessionResponse(BaseSeedSessionResponse): + sandbox_handle: str + sandbox_descriptor: dict[str, Any] + + +class JobBenchVerifyRequest(JobBenchInstanceRequest, BaseVerifyRequest): + sandbox_handle: str | None = None + + +class JobBenchVerifyResponse(BaseVerifyResponse): + model_config = ConfigDict(extra="allow") + + task_id: str + evaluation_completed: bool + + total_score: float = 0.0 + max_score: float = 0.0 + normalized_score: float = 0.0 + pass_rate: float = 0.0 + passed_count: int = 0 + total_count: int = 0 + + num_output_files: int = 0 + num_vision_images: int = 0 + rubrics: list[dict] | None = None + collection_error: str | None = None + + output_collection_time_s: float = 0.0 + judging_time_s: float = 0.0 + + +@dataclass +class AgentSandboxSession: + task_id: str + sandbox: AsyncSandbox + sandbox_handle: str + + +def _resolve_task_id(body: JobBenchInstanceRequest) -> str: + metadata_task_id = (body.verifier_metadata or {}).get("task_id") + if body.task_id and metadata_task_id and body.task_id != metadata_task_id: + raise ValueError( + f"Conflicting JobBench task IDs: task_id={body.task_id!r}, verifier_metadata.task_id={metadata_task_id!r}" + ) + task_id = body.task_id or metadata_task_id + if not isinstance(task_id, str) or not task_id: + raise ValueError("JobBench requests must provide verifier_metadata.task_id or task_id") + return task_id + + +def _build_archive(source_dirs: dict[str, Path], archive_path: Path) -> None: + """Write a gzipped tar containing each ``source_dir`` under its archive name.""" + archive_path.parent.mkdir(parents=True, exist_ok=True) + temporary_path = archive_path.with_suffix(archive_path.suffix + ".tmp") + with tarfile.open(temporary_path, "w:gz") as archive: + for arcname, source in source_dirs.items(): + archive.add(source, arcname=arcname) + # Rename last so a concurrent reader never sees a half-written archive. + temporary_path.replace(archive_path) + + +def _extract_archive(archive_path: Path, destination: Path) -> None: + destination.mkdir(parents=True, exist_ok=True) + with tarfile.open(archive_path, "r:gz") as archive: + # filter="data" drops absolute paths, symlink escapes and device nodes: + # the archive is built from untrusted agent output. + archive.extractall(destination, filter="data") + + +class JobBenchResourcesServer(SimpleResourcesServer): + config: JobBenchResourcesServerConfig + + def model_post_init(self, context: Any, /) -> None: + super().model_post_init(context) + self._task_store = JobBenchTaskStore( + _resolve_repo_path(self.config.cache_dir), + self.config.split, + expected_task_count=self.config.expected_task_count, + ) + self._agent_sessions: dict[str, AgentSandboxSession] = {} + self._judge_semaphore: Semaphore = Semaphore(self.config.judge_concurrency) + self._archive_locks: dict[str, asyncio.Lock] = {} + + # ---------------------------------------------------------------- sandbox + + def _model_egress_target(self) -> str | None: + if not self.config.sandbox_model_server: + return None + model_config = get_first_server_config_dict(get_global_config_dict(), self.config.sandbox_model_server.name) + target = str(model_config.get("host") or "") + if not target: + raise ValueError(f"Model server {self.config.sandbox_model_server.name!r} does not have a host") + if target in {"0.0.0.0", "127.0.0.1", "::", "::1", "localhost"}: + raise ValueError( + f"JobBench task sandboxes cannot reach loopback model host {target!r}; " + "set NEMO_GYM_SANDBOX_MODEL_BASE_URL or launch Gym with use_absolute_ip=true" + ) + return target + + def _provider_options(self) -> dict[str, Any]: + options = deepcopy(self.config.sandbox_config.get("provider_options", {})) + if not self.config.enforce_agent_no_network: + # JobBench's default posture is the open internet, as upstream runs it. + return options + + network_policy = options.setdefault("network_policy", {"defaultAction": "deny", "egress": []}) + if not isinstance(network_policy, dict): + raise TypeError("JobBench sandbox network_policy must be a mapping") + egress = network_policy.setdefault("egress", []) + if not isinstance(egress, list): + raise TypeError("JobBench sandbox network_policy.egress must be a list") + model_egress_target = self._model_egress_target() + if model_egress_target is not None: + model_rule = {"action": "allow", "target": model_egress_target} + if model_rule not in egress: + egress.append(model_rule) + return options + + async def _create_sandbox(self, task: JobBenchTask) -> AsyncSandbox: + global_config = get_global_config_dict() + provider = resolve_provider_config(self.config.sandbox_provider, global_config) + provider_metadata = resolve_provider_metadata(self.config.sandbox_provider, global_config) + + spec = SandboxSpec( + image=self.config.sandbox_image, + ttl_s=self.config.sandbox_config.get("ttl_s"), + ready_timeout_s=self.config.sandbox_config.get("ready_timeout_s"), + workdir=WORKSPACE_DIR, + env=dict(self.config.sandbox_config.get("env", {})), + files={}, + metadata=provider_metadata + | dict(self.config.sandbox_config.get("metadata", {})) + | { + "benchmark": "job-bench", + "job-bench-split": task.split, + "job-bench-task": task.label, + "nemo_gym_agent": self.config.name or "job_bench", + }, + resources=SandboxResources.from_mapping(dict(self.config.sandbox_config.get("resources", {}))), + provider_options=self._provider_options(), + ) + sandbox = AsyncSandbox(provider) + await sandbox.start(spec) + return sandbox + + async def _stop_sandbox(self, sandbox: AsyncSandbox, *, task_id: str) -> None: + try: + await sandbox.stop() + except Exception: + print(f"Failed to stop JobBench sandbox for {task_id}: {format_exc()}", file=sys.stderr) + + async def _task_archive(self, task: JobBenchTask) -> Path: + """Return a cached tarball of the task's sandbox-visible materials, building it once.""" + suffix = "with-search" if self.config.include_search_files else "task-only" + archive_path = ( + _resolve_repo_path(self.config.archives_dir) + / task.split + / task.profession + / f"{task.task_name}.{suffix}.tgz" + ) + lock = self._archive_locks.setdefault(str(archive_path), asyncio.Lock()) + async with lock: + if not archive_path.is_file(): + sources = {TASK_FOLDER_NAME: task.task_folder} + if self.config.include_search_files and task.search_files_dir.is_dir(): + sources[SEARCH_FILES_NAME] = task.search_files_dir + await asyncio.to_thread(_build_archive, sources, archive_path) + return archive_path + + async def _seed_workspace(self, sandbox: AsyncSandbox, task: JobBenchTask) -> None: + """Lay out /workspace with the task materials and an empty output directory.""" + archive_path = await self._task_archive(task) + await sandbox.upload(archive_path, REMOTE_TASK_ARCHIVE) + + setup = await sandbox.exec( + f"mkdir -p {WORKSPACE_DIR} {OUTPUT_DIR}" + f" && tar -xzf {REMOTE_TASK_ARCHIVE} -C {WORKSPACE_DIR}" + f" && rm -f {REMOTE_TASK_ARCHIVE}" + f" && test -f {TASK_FOLDER_DIR}/TASK_INSTRUCTIONS.txt", + timeout_s=600, + ) + if setup.return_code != 0: + details = ((setup.stderr or "") + (setup.stdout or "")).strip() + raise RuntimeError(f"Failed to seed JobBench workspace for {task.task_id}: {details[-4000:]}") + + async def _collect_output(self, sandbox: AsyncSandbox, task: JobBenchTask, destination: Path) -> None: + """Download the agent's output directory into ``destination``.""" + probe = await sandbox.exec(f"test -d {OUTPUT_DIR} && du -sm {OUTPUT_DIR} | cut -f1", timeout_s=120) + if probe.return_code != 0: + raise RuntimeError(f"JobBench output directory {OUTPUT_DIR} is missing in the agent sandbox") + try: + output_mib = int((probe.stdout or "0").strip().splitlines()[-1]) + except (ValueError, IndexError): + output_mib = 0 + if output_mib > self.config.max_output_mib: + raise RuntimeError( + f"JobBench output directory is {output_mib} MiB, above the {self.config.max_output_mib} MiB cap" + ) + + archive = await sandbox.exec( + f"tar -czf {REMOTE_OUTPUT_ARCHIVE} -C {WORKSPACE_DIR} output", + timeout_s=900, + ) + if archive.return_code != 0: + details = ((archive.stderr or "") + (archive.stdout or "")).strip() + raise RuntimeError(f"Failed to archive JobBench output for {task.task_id}: {details[-4000:]}") + + with tempfile.TemporaryDirectory(prefix="nemo-gym-job-bench-output-") as temporary_dir: + local_archive = Path(temporary_dir) / "output.tgz" + await sandbox.download(REMOTE_OUTPUT_ARCHIVE, local_archive) + await asyncio.to_thread(_extract_archive, local_archive, destination) + + # ------------------------------------------------------------------ judge + + async def _judge_rubric(self, rubric_index: int, rubric: dict, file_contents: str, attachments: list) -> dict: + """Grade one rubric; every criterion must pass for the rubric to score.""" + rubric_attachments = attachments if (attachments and rubric_needs_vision(rubric)) else [] + prompt = build_rubric_prompt(rubric, file_contents, vision_used=bool(rubric_attachments)) + + chat_params = NeMoGymChatCompletionCreateParamsNonStreaming( + messages=[ + {"role": "system", "content": JUDGE_SYSTEM_PROMPT}, + {"role": "user", "content": build_user_content(prompt, rubric_attachments)}, + ], + max_tokens=self.config.judge_max_tokens, + temperature=self.config.judge_temperature, + ) + async with self._judge_semaphore: + chat_response = await call_judge( + self.server_client, + server_name=self.config.judge_model_server.name, + url_path="/v1/chat/completions", + json=chat_params, + response_model=NeMoGymChatCompletion, + ) + + content = chat_response.choices[0].message.content if chat_response.choices else None + if not content or not content.strip(): + return build_failed_rubric_result(rubric_index, rubric, "Judge returned an empty response") + try: + parsed, _ = parse_judge_json(content.strip()) + except ValueError as error: + # A reply that arrived but cannot be parsed is a failed grade, not a + # failed call: score it zero rather than routing the row to the sidecar. + return build_failed_rubric_result(rubric_index, rubric, f"Unparseable judge response: {error}") + return build_rubric_result(rubric_index, rubric, parsed) + + async def _judge_output(self, task: JobBenchTask, output_dir: Path) -> tuple[list[dict], int, int]: + file_contents = await asyncio.to_thread( + extract_all_file_contents, output_dir, max_chars_per_file=self.config.max_chars_per_file + ) + attachments = await asyncio.to_thread(collect_image_attachments, output_dir, self.config.max_vision_images) + num_output_files = sum(1 for path in output_dir.rglob("*") if path.is_file()) + + results = await asyncio.gather( + *( + self._judge_rubric(index, rubric, file_contents, attachments) + for index, rubric in enumerate(task.rubrics) + ) + ) + return list(results), num_output_files, len(attachments) + + # -------------------------------------------------------------- endpoints + + async def seed_session(self, request: Request, body: JobBenchSeedSessionRequest) -> JobBenchSeedSessionResponse: + task = self._task_store.get(_resolve_task_id(body)) + session_id = str(request.session[SESSION_ID_KEY]) + + previous_session = self._agent_sessions.pop(session_id, None) + if previous_session is not None: + await self._stop_sandbox(previous_session.sandbox, task_id=previous_session.task_id) + + sandbox: AsyncSandbox | None = None + try: + sandbox = await self._create_sandbox(task) + descriptor = await sandbox.serialize() + sandbox_handle = descriptor.get("sandbox_id") if isinstance(descriptor, dict) else None + if not isinstance(sandbox_handle, str) or not sandbox_handle: + raise RuntimeError("JobBench sandbox provider did not return a sandbox_id") + + await self._seed_workspace(sandbox, task) + self._agent_sessions[session_id] = AgentSandboxSession( + task_id=task.task_id, + sandbox=sandbox, + sandbox_handle=sandbox_handle, + ) + return JobBenchSeedSessionResponse( + sandbox_handle=sandbox_handle, + sandbox_descriptor=dict(descriptor), + ) + except Exception: + if sandbox is not None: + await self._stop_sandbox(sandbox, task_id=task.task_id) + raise + + async def verify(self, request: Request, body: JobBenchVerifyRequest) -> JobBenchVerifyResponse: + task = self._task_store.get(_resolve_task_id(body)) + session_id = str(request.session.get(SESSION_ID_KEY, "unknown")) + + agent_session = self._agent_sessions.pop(session_id, None) + sandbox_handle = body.sandbox_handle + collection_error: str | None = None + output_collection_time_s = 0.0 + + def empty_response(error: str) -> JobBenchVerifyResponse: + return JobBenchVerifyResponse.model_validate( + body.model_dump() + | { + "task_id": task.task_id, + "sandbox_handle": sandbox_handle, + "reward": 0.0, + "evaluation_completed": False, + "max_score": float(task.max_score), + "total_count": len(task.rubrics), + "collection_error": error, + "failure_reason": error, + "output_collection_time_s": output_collection_time_s, + } + ) + + if agent_session is None: + return empty_response(f"No JobBench agent sandbox exists for session {session_id!r}") + sandbox_handle = agent_session.sandbox_handle + + with tempfile.TemporaryDirectory(prefix="nemo-gym-job-bench-verify-") as temporary_dir: + output_dir = Path(temporary_dir) / "output" + started = monotonic() + try: + if agent_session.task_id != task.task_id: + raise RuntimeError( + f"JobBench session task {agent_session.task_id!r} does not match verify task {task.task_id!r}" + ) + await self._collect_output(agent_session.sandbox, task, Path(temporary_dir)) + except Exception as error: + print(f"Failed to collect JobBench output for {task.task_id}: {format_exc()}", file=sys.stderr) + collection_error = f"{type(error).__name__}: {error}" + finally: + output_collection_time_s = monotonic() - started + await self._stop_sandbox(agent_session.sandbox, task_id=task.task_id) + + if collection_error is not None: + return empty_response(collection_error) + + started = monotonic() + results, num_output_files, num_vision_images = await self._judge_output(task, output_dir) + judging_time_s = monotonic() - started + + scorecard = build_scorecard(results) + return JobBenchVerifyResponse.model_validate( + body.model_dump() + | { + "task_id": task.task_id, + "sandbox_handle": sandbox_handle, + "reward": float(scorecard["normalized_score"]), + "evaluation_completed": True, + "total_score": float(scorecard["total_score"]), + "max_score": float(scorecard["max_score"]), + "normalized_score": float(scorecard["normalized_score"]), + "pass_rate": float(scorecard["pass_rate"]), + "passed_count": int(scorecard["passed_count"]), + "total_count": int(scorecard["total_count"]), + "num_output_files": num_output_files, + "num_vision_images": num_vision_images, + "rubrics": results if self.config.include_rubric_details_in_response else None, + "output_collection_time_s": output_collection_time_s, + "judging_time_s": judging_time_s, + } + ) + + +if __name__ == "__main__": + JobBenchResourcesServer.run_webserver() +elif is_nemo_gym_fastapi_entrypoint(__file__): + app = JobBenchResourcesServer.run_webserver() # noqa: F401 diff --git a/resources_servers/job_bench/configs/job_bench.yaml b/resources_servers/job_bench/configs/job_bench.yaml new file mode 100644 index 00000000000..fb5dca371c8 --- /dev/null +++ b/resources_servers/job_bench/configs/job_bench.yaml @@ -0,0 +1,49 @@ +job_bench_resources_server: + resources_servers: + job_bench: + allowed_agents: [opencode_sandboxed_agent] + entrypoint: app.py + domain: agent + verified: false + description: JobBench multi-source data preprocessing tasks across 35 white-collar professions, graded by rubric LLM judge + value: Measures agentic competence on the tedious real-world office work practitioners most want automated + + cache_dir: resources_servers/job_bench/data/cache/tasks + archives_dir: resources_servers/job_bench/data/cache/archives + split: main + # Defaults to the published count for the split (main=65, easy=63). + expected_task_count: null + + # Upstream withholds files_required_to_search/ so the agent must rediscover + # those references online. Turning this on makes runs hermetic but no longer + # comparable to the JobBench leaderboard. + include_search_files: false + + judge_model_server: + type: responses_api_models + name: ??? + judge_concurrency: 10 + judge_max_tokens: 200000 + judge_temperature: 0.0 + max_chars_per_file: 200000 + max_vision_images: 8 + include_rubric_details_in_response: true + + sandbox_provider: sandbox + sandbox_image: ${oc.env:JOB_BENCH_SANDBOX_IMAGE,job-bench-sandbox:latest} + # JobBench's runner grants the open internet, and several tasks need live + # search. Set true for a hermetic run, at the cost of those tasks. + enforce_agent_no_network: false + sandbox_model_server: null + max_output_mib: 512 + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + resources: + cpu: 2.0 + memory_mib: 8192 + disk_gib: 30 + provider_options: {} + metadata: + benchmark: job-bench + istio.io/dataplane-mode: none diff --git a/resources_servers/job_bench/data/.gitignore b/resources_servers/job_bench/data/.gitignore new file mode 100644 index 00000000000..3a6fe90aff7 --- /dev/null +++ b/resources_servers/job_bench/data/.gitignore @@ -0,0 +1,8 @@ +# Control-plane cache: task materials, rubrics and prebuilt archives. +cache/ +*train.jsonl +*validation.jsonl +*benchmark.jsonl +*train_prepare.jsonl +*validation_prepare.jsonl +*example_prepare.jsonl diff --git a/resources_servers/job_bench/data/example.jsonl b/resources_servers/job_bench/data/example.jsonl new file mode 100644 index 00000000000..be9ced98f46 --- /dev/null +++ b/resources_servers/job_bench/data/example.jsonl @@ -0,0 +1,5 @@ +{"task_id": "main/biostatisticians/task1", "responses_create_params": {"input": [{"role": "user", "content": "=== TASK FOLDER ===\n/workspace/task_folder\n\n=== INSTRUCTIONS ===\n1. Read the TASK_INSTRUCTIONS.txt file in the task folder above\n2. Based on the Reference Files section in TASK_INSTRUCTIONS.txt, read the corresponding files from the same task folder using appropriate tools.\n3. Complete the task as specified in TASK_INSTRUCTIONS.txt\n4. Only save the final deliverables to the output directory specified below. Do not save any intermediate or temporary files.\n\n=== OUTPUT DIRECTORY ===\n/workspace/output\n\nIMPORTANT:\n- All reference files are in the task folder: /workspace/task_folder\n- Only save the final deliverables to the output directory /workspace/output. Do not save any intermediate or temporary files.\n- You MUST only access files within /workspace or search online for new reference files if you find needed. Do NOT access any files or directories in this system outside of this path.\n- If you encounter ambiguous or conflicting information, analyze the conflict, explain your reasoning, and justify the approach you choose.\n- If a file cannot be read directly (e.g., .xlsx, .docx, .db, .pptx), use appropriate tools, MCP servers, or code to extract and process its contents."}]}, "verifier_metadata": {"task_id": "main/biostatisticians/task1", "split": "main", "profession": "biostatisticians", "task_name": "task1", "num_rubrics": 8, "max_score": 72, "rubrics_sha256": "fcf069f216f8ba61661ac81276f93a799387bc71e3f2c7e1890c35b97524a1da"}} +{"task_id": "main/biostatisticians/task2", "responses_create_params": {"input": [{"role": "user", "content": "=== TASK FOLDER ===\n/workspace/task_folder\n\n=== INSTRUCTIONS ===\n1. Read the TASK_INSTRUCTIONS.txt file in the task folder above\n2. Based on the Reference Files section in TASK_INSTRUCTIONS.txt, read the corresponding files from the same task folder using appropriate tools.\n3. Complete the task as specified in TASK_INSTRUCTIONS.txt\n4. Only save the final deliverables to the output directory specified below. Do not save any intermediate or temporary files.\n\n=== OUTPUT DIRECTORY ===\n/workspace/output\n\nIMPORTANT:\n- All reference files are in the task folder: /workspace/task_folder\n- Only save the final deliverables to the output directory /workspace/output. Do not save any intermediate or temporary files.\n- You MUST only access files within /workspace or search online for new reference files if you find needed. Do NOT access any files or directories in this system outside of this path.\n- If you encounter ambiguous or conflicting information, analyze the conflict, explain your reasoning, and justify the approach you choose.\n- If a file cannot be read directly (e.g., .xlsx, .docx, .db, .pptx), use appropriate tools, MCP servers, or code to extract and process its contents."}]}, "verifier_metadata": {"task_id": "main/biostatisticians/task2", "split": "main", "profession": "biostatisticians", "task_name": "task2", "num_rubrics": 7, "max_score": 58, "rubrics_sha256": "d085c8463adfffc2f07ab37ecdc27f4accfddde7363fd326956a4b01b732ff21"}} +{"task_id": "main/bookkeeping_accounting_and_auditing_clerks/task1", "responses_create_params": {"input": [{"role": "user", "content": "=== TASK FOLDER ===\n/workspace/task_folder\n\n=== INSTRUCTIONS ===\n1. Read the TASK_INSTRUCTIONS.txt file in the task folder above\n2. Based on the Reference Files section in TASK_INSTRUCTIONS.txt, read the corresponding files from the same task folder using appropriate tools.\n3. Complete the task as specified in TASK_INSTRUCTIONS.txt\n4. Only save the final deliverables to the output directory specified below. Do not save any intermediate or temporary files.\n\n=== OUTPUT DIRECTORY ===\n/workspace/output\n\nIMPORTANT:\n- All reference files are in the task folder: /workspace/task_folder\n- Only save the final deliverables to the output directory /workspace/output. Do not save any intermediate or temporary files.\n- You MUST only access files within /workspace or search online for new reference files if you find needed. Do NOT access any files or directories in this system outside of this path.\n- If you encounter ambiguous or conflicting information, analyze the conflict, explain your reasoning, and justify the approach you choose.\n- If a file cannot be read directly (e.g., .xlsx, .docx, .db, .pptx), use appropriate tools, MCP servers, or code to extract and process its contents."}]}, "verifier_metadata": {"task_id": "main/bookkeeping_accounting_and_auditing_clerks/task1", "split": "main", "profession": "bookkeeping_accounting_and_auditing_clerks", "task_name": "task1", "num_rubrics": 10, "max_score": 88, "rubrics_sha256": "79f01eae511d0db9598a2436476a1cc30a06d3ffb8a2372bfd25d945bdf5b338"}} +{"task_id": "main/bookkeeping_accounting_and_auditing_clerks/task2", "responses_create_params": {"input": [{"role": "user", "content": "=== TASK FOLDER ===\n/workspace/task_folder\n\n=== INSTRUCTIONS ===\n1. Read the TASK_INSTRUCTIONS.txt file in the task folder above\n2. Based on the Reference Files section in TASK_INSTRUCTIONS.txt, read the corresponding files from the same task folder using appropriate tools.\n3. Complete the task as specified in TASK_INSTRUCTIONS.txt\n4. Only save the final deliverables to the output directory specified below. Do not save any intermediate or temporary files.\n\n=== OUTPUT DIRECTORY ===\n/workspace/output\n\nIMPORTANT:\n- All reference files are in the task folder: /workspace/task_folder\n- Only save the final deliverables to the output directory /workspace/output. Do not save any intermediate or temporary files.\n- You MUST only access files within /workspace or search online for new reference files if you find needed. Do NOT access any files or directories in this system outside of this path.\n- If you encounter ambiguous or conflicting information, analyze the conflict, explain your reasoning, and justify the approach you choose.\n- If a file cannot be read directly (e.g., .xlsx, .docx, .db, .pptx), use appropriate tools, MCP servers, or code to extract and process its contents."}]}, "verifier_metadata": {"task_id": "main/bookkeeping_accounting_and_auditing_clerks/task2", "split": "main", "profession": "bookkeeping_accounting_and_auditing_clerks", "task_name": "task2", "num_rubrics": 8, "max_score": 52, "rubrics_sha256": "282ca1e5de459517cbd9e1b4e2746ddd9b11932354ed71f00937263e7da20291"}} +{"task_id": "main/civil_engineers/task1", "responses_create_params": {"input": [{"role": "user", "content": "=== TASK FOLDER ===\n/workspace/task_folder\n\n=== INSTRUCTIONS ===\n1. Read the TASK_INSTRUCTIONS.txt file in the task folder above\n2. Based on the Reference Files section in TASK_INSTRUCTIONS.txt, read the corresponding files from the same task folder using appropriate tools.\n3. Complete the task as specified in TASK_INSTRUCTIONS.txt\n4. Only save the final deliverables to the output directory specified below. Do not save any intermediate or temporary files.\n\n=== OUTPUT DIRECTORY ===\n/workspace/output\n\nIMPORTANT:\n- All reference files are in the task folder: /workspace/task_folder\n- Only save the final deliverables to the output directory /workspace/output. Do not save any intermediate or temporary files.\n- You MUST only access files within /workspace or search online for new reference files if you find needed. Do NOT access any files or directories in this system outside of this path.\n- If you encounter ambiguous or conflicting information, analyze the conflict, explain your reasoning, and justify the approach you choose.\n- If a file cannot be read directly (e.g., .xlsx, .docx, .db, .pptx), use appropriate tools, MCP servers, or code to extract and process its contents."}]}, "verifier_metadata": {"task_id": "main/civil_engineers/task1", "split": "main", "profession": "civil_engineers", "task_name": "task1", "num_rubrics": 7, "max_score": 50, "rubrics_sha256": "344b0e0a72d1eb692b78509467a9dd912beb46ff3580aa4088c32038fe49521c"}} diff --git a/resources_servers/job_bench/judge.py b/resources_servers/job_bench/judge.py new file mode 100644 index 00000000000..b92d1d235d6 --- /dev/null +++ b/resources_servers/job_bench/judge.py @@ -0,0 +1,517 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Deliverable extraction and rubric scoring for JobBench. + +A port of upstream ``eval/judge.py`` (Job-Bench/job-bench-eval). The extraction +rules, judge prompt, JSON-recovery ladder and weighted scorecard are kept +byte-compatible with upstream so Gym scores stay comparable to the leaderboard; +the transport is Gym's model server instead of a direct OpenAI client. +""" + +from __future__ import annotations + +import base64 +import binascii +import hashlib +import json +import re +import sqlite3 +from pathlib import Path +from typing import Any +from zipfile import BadZipFile, ZipFile + + +MAX_CHARS_PER_FILE = 200_000 +SQLITE_EXTS = {"db", "sqlite", "sqlite3"} +SQLITE_ROWS_PER_TABLE = 500 + +VISION_IMAGE_EXTS = {"png", "jpg", "jpeg", "gif", "webp"} +MAX_VISION_IMAGES = 8 +VISUAL_RUBRIC_PATTERN = re.compile( + r"\b(plot|figure|visualization|visualisation|visualize|visualise|" + r"heatmap|histogram|scatter ?plot|biplot|diagram|q[- ]?q)\b", + re.IGNORECASE, +) +VISION_MIME = { + "png": "image/png", + "jpg": "image/jpeg", + "jpeg": "image/jpeg", + "gif": "image/gif", + "webp": "image/webp", +} + +PLAINTEXT_EXTS = { + "txt", + "md", + "csv", + "py", + "json", + "sh", + "log", + "xml", + "html", + "css", + "js", + "ts", + "yaml", + "yml", + "ini", + "cfg", + "conf", + "sql", + "rules", + "geojson", +} + +JUDGE_SYSTEM_PROMPT = ( + "You are an evaluation judge. You must return valid JSON only, with no markdown formatting or extra text." +) + + +def _read_text(path: Path) -> str: + try: + return path.read_text(encoding="utf-8", errors="replace") + except Exception as exc: + return f"[ERROR: Failed to read text file: {path.name}: {exc}]" + + +def _excel_to_text(path: Path) -> str: + try: + import pandas as pd + + excel = pd.ExcelFile(str(path)) + parts = [] + for sheet in excel.sheet_names: + frame = pd.read_excel(excel, sheet_name=sheet) + parts.append(f"=== Sheet: {sheet} ===\n{frame.to_csv(index=False)}") + return "\n".join(parts) + except ImportError: + return f"[ERROR: pandas/openpyxl not available for {path.name}]" + except Exception as exc: + return f"[ERROR: Failed to read Excel {path.name}: {exc}]" + + +def _docx_to_text(path: Path) -> str: + try: + import mammoth + + def embedded_image_placeholder(image): + return {"src": "embedded-image", "alt": f"Embedded image: {image.content_type}"} + + with open(str(path), "rb") as handle: + result = mammoth.convert_to_markdown( + handle, + convert_image=mammoth.images.img_element(embedded_image_placeholder), + ) + return result.value + except ImportError: + return f"[ERROR: mammoth not available for {path.name}]" + except Exception as exc: + return f"[ERROR: Failed to read DOCX {path.name}: {exc}]" + + +def _pdf_to_text(path: Path) -> str: + try: + import pdfplumber + + with pdfplumber.open(str(path)) as pdf: + parts = [] + for index, page in enumerate(pdf.pages): + parts.append(f"=== Page {index + 1} ===\n{page.extract_text(layout=True) or ''}") + return "\n".join(parts) + except ImportError: + return f"[ERROR: pdfplumber not available for {path.name}]" + except Exception as exc: + return f"[ERROR: Failed to read PDF {path.name}: {exc}]" + + +def _sqlite_to_text(path: Path) -> str: + try: + connection = sqlite3.connect(str(path)) + except Exception as exc: + return f"[ERROR: Failed to read SQLite {path.name}: {exc}]" + try: + cursor = connection.cursor() + schema = connection.execute("SELECT sql FROM sqlite_master WHERE sql IS NOT NULL").fetchall() + parts = ["=== Schema ==="] + parts.extend(row[0] for row in schema if row[0]) + tables = [row[0] for row in connection.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()] + for table in tables: + parts.append(f"\n=== Table: {table} ===") + try: + total_rows = connection.execute(f'SELECT COUNT(*) FROM "{table}"').fetchone()[0] + rows = cursor.execute(f'SELECT * FROM "{table}" LIMIT {SQLITE_ROWS_PER_TABLE}').fetchall() + columns = [description[0] for description in cursor.description] + parts.append(f"-- total_rows: {total_rows}; shown: {len(rows)} (LIMIT {SQLITE_ROWS_PER_TABLE})") + parts.append(",".join(columns)) + for row in rows: + parts.append(",".join("" if value is None else str(value) for value in row)) + except Exception as exc: + parts.append(f"[ERROR reading table {table}: {exc}]") + return "\n".join(parts) + except Exception as exc: + return f"[ERROR: Failed to read SQLite {path.name}: {exc}]" + finally: + connection.close() + + +def _pptx_to_text(path: Path) -> str: + try: + from pptx import Presentation + + presentation = Presentation(str(path)) + parts = [] + for index, slide in enumerate(presentation.slides): + parts.append(f"=== Slide {index + 1} ===") + for shape in slide.shapes: + if hasattr(shape, "text") and shape.text: + parts.append(shape.text) + return "\n".join(parts) + except ImportError: + return f"[ERROR: python-pptx not available for {path.name}]" + except Exception as exc: + return f"[ERROR: Failed to read PowerPoint {path.name}: {exc}]" + + +def _notebook_to_text(path: Path) -> str: + try: + notebook = json.loads(path.read_text(encoding="utf-8")) + parts = [] + for cell in notebook.get("cells", []): + parts.append(f"=== {cell['cell_type']} ===") + parts.append("".join(cell.get("source", []))) + for output in cell.get("outputs", []): + if "text" in output: + parts.append("".join(output["text"])) + return "\n".join(parts) + except Exception as exc: + return f"[ERROR: Failed to read notebook {path.name}: {exc}]" + + +def convert_file_to_text(path: Path) -> str: + """Render one deliverable as judge-readable text.""" + ext = path.suffix.lower().lstrip(".") + + if ext in PLAINTEXT_EXTS: + return _read_text(path) + if ext in ("xlsx", "xls"): + return _excel_to_text(path) + if ext == "docx": + return _docx_to_text(path) + if ext == "pdf": + return _pdf_to_text(path) + if ext in SQLITE_EXTS: + return _sqlite_to_text(path) + if ext == "pptx": + return _pptx_to_text(path) + if ext == "ipynb": + return _notebook_to_text(path) + if ext in ("png", "jpg", "jpeg", "gif", "svg", "bmp"): + return f"[Image file: {path.name} — cannot extract text content]" + return f"[Binary or unsupported file type: {ext} — {path.name}]" + + +def extract_all_file_contents(output_dir: Path, *, max_chars_per_file: int = MAX_CHARS_PER_FILE) -> str: + """Concatenate every deliverable under ``output_dir`` as text.""" + if not output_dir.is_dir(): + return "" + parts = [] + for file_path in sorted(output_dir.rglob("*")): + if not file_path.is_file(): + continue + content = convert_file_to_text(file_path) + ext = file_path.suffix.lower().lstrip(".") + # The cap guards against a model copying a multi-MB input into its output; + # SQLite renderings are already row-limited, so they are exempt upstream. + if ext not in SQLITE_EXTS and len(content) > max_chars_per_file: + content = content[:max_chars_per_file] + f"\n... [Content truncated at {max_chars_per_file} characters]" + parts.append(f"=== FILE: {file_path.name} ===\n{content}\n") + return "\n".join(parts) + + +def rubric_needs_vision(rubric: dict) -> bool: + """True when a rubric mentions a visual artifact and so warrants image attachments.""" + text = rubric.get("rubric", "") or "" + criterion = rubric.get("criterion", []) + if isinstance(criterion, list): + text = text + " " + " ".join(str(item) for item in criterion) + elif isinstance(criterion, str): + text = text + " " + criterion + return bool(VISUAL_RUBRIC_PATTERN.search(text)) + + +def collect_image_paths(output_dir: Path, cap: int | None = MAX_VISION_IMAGES) -> list[Path]: + if not output_dir.exists(): + return [] + images = [ + path + for path in sorted(output_dir.rglob("*")) + if path.is_file() and path.suffix.lower().lstrip(".") in VISION_IMAGE_EXTS + ] + return images if cap is None else images[:cap] + + +def collect_image_attachments(output_dir: Path, cap: int = MAX_VISION_IMAGES) -> list[tuple[str, str]]: + """Collect standalone, docx-embedded and notebook-embedded images as deduplicated data URLs.""" + if not output_dir.exists() or cap <= 0: + return [] + + attachments: list[tuple[str, str]] = [] + seen_hashes: set[str] = set() + + def add_attachment(name: str, mime: str, image_bytes: bytes) -> bool: + """Append unless a duplicate; return True once the cap is reached.""" + digest = hashlib.sha256(image_bytes).hexdigest() + if digest in seen_hashes: + return False + seen_hashes.add(digest) + encoded = base64.b64encode(image_bytes).decode("ascii") + attachments.append((name, f"data:{mime};base64,{encoded}")) + return len(attachments) >= cap + + for path in collect_image_paths(output_dir, cap=None): + mime = VISION_MIME.get(path.suffix.lower().lstrip(".")) + if mime is None: + continue + try: + image_bytes = path.read_bytes() + except OSError: + continue + if add_attachment(path.relative_to(output_dir).as_posix(), mime, image_bytes): + return attachments + + for docx_path in sorted(output_dir.rglob("*.docx")): + try: + with ZipFile(docx_path) as archive: + media_names = [ + name + for name in sorted(archive.namelist()) + if name.startswith("word/media/") and Path(name).suffix.lower().lstrip(".") in VISION_IMAGE_EXTS + ] + for media_name in media_names: + mime = VISION_MIME.get(Path(media_name).suffix.lower().lstrip(".")) + if mime is None: + continue + try: + image_bytes = archive.read(media_name) + except (KeyError, OSError): + continue + display_name = f"{docx_path.relative_to(output_dir).as_posix()}:{media_name}" + if add_attachment(display_name, mime, image_bytes): + return attachments + except (BadZipFile, OSError): + continue + + for notebook_path in sorted(output_dir.rglob("*.ipynb")): + try: + notebook = json.loads(notebook_path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError): + continue + for cell_index, cell in enumerate(notebook.get("cells", [])): + for output_index, output in enumerate(cell.get("outputs", [])): + data = output.get("data", {}) + if not isinstance(data, dict): + continue + for mime in ("image/png", "image/jpeg", "image/gif", "image/webp"): + encoded = data.get(mime) + if isinstance(encoded, list): + encoded = "".join(str(part) for part in encoded) + if not isinstance(encoded, str): + continue + try: + image_bytes = base64.b64decode("".join(encoded.split()), validate=True) + except (ValueError, binascii.Error): + continue + display_name = ( + f"{notebook_path.relative_to(output_dir).as_posix()}:" + f"cell-{cell_index}-output-{output_index}:{mime}" + ) + if add_attachment(display_name, mime, image_bytes): + return attachments + + return attachments + + +def normalize_criteria(rubric: dict) -> list[str]: + criterion_raw = rubric.get("criterion", []) + if isinstance(criterion_raw, str): + return [criterion_raw] + return list(criterion_raw) + + +def build_rubric_prompt(rubric: dict, file_contents: str, *, vision_used: bool) -> str: + """Render upstream's rubric-level judge prompt verbatim.""" + rubric_text = rubric.get("rubric", "") + criteria = normalize_criteria(rubric) + criterion_count = len(criteria) + criteria_list_text = "\n".join(f"Criterion {index}: {criterion}" for index, criterion in enumerate(criteria)) + + return f"""You are an evaluation judge. Your task is to evaluate ALL criteria for a single rubric. + +## Rubric Description +{rubric_text} + +## Criteria to Evaluate (Judge ALL of them) +{criteria_list_text} + +## Output Files Content +The following are the contents of all output files to evaluate: + +{file_contents} + +## Evaluation Rules +- Evaluate EACH criterion listed above independently +- For each criterion: determine if it PASSES or FAILS +- Semantic matching is acceptable (you don't need exact wording match) +- Binary judgment for each criterion: PASS or FAIL only +- The rubric passes ONLY if ALL criteria pass + +## Output Format +Return your judgment as a JSON object with EXACTLY this structure (no markdown, no extra text): +{{ + "criteria_results": [ + {{"index": 0, "passed": true/false, "reasoning": "...", "evidence": "..."}}, + {{"index": 1, "passed": true/false, "reasoning": "...", "evidence": "..."}} + ], + "rubric_passed": true/false, + "overall_reasoning": "Summary of why the rubric passed or failed" +}} + +IMPORTANT: +- criteria_results array must have exactly {criterion_count} items (one for each criterion) +- rubric_passed should be true ONLY if ALL criteria passed +- Include specific evidence from the output files{" and the attached images" if vision_used else ""} +""" + + +def build_user_content(prompt: str, attachments: list[tuple[str, str]]) -> str | list[dict[str, Any]]: + """Return a plain string, or multimodal content parts when images are attached.""" + if not attachments: + return prompt + plural = "s" if len(attachments) != 1 else "" + content: list[dict[str, Any]] = [ + {"type": "text", "text": prompt}, + {"type": "text", "text": f"\n## Attached Images ({len(attachments)} file{plural})"}, + ] + for index, (filename, url) in enumerate(attachments, start=1): + content.append({"type": "text", "text": f"Image {index}: {filename}"}) + content.append({"type": "image_url", "image_url": {"url": url}}) + return content + + +def parse_judge_json(content: str) -> tuple[dict, str]: + """Recover the judge's JSON object, widening the search on each failure.""" + try: + return json.loads(content), "direct_json" + except json.JSONDecodeError: + pass + + fence = re.search(r"```(?:json)?\s*\n(.*?)\n\s*```", content, re.DOTALL) + if fence: + try: + return json.loads(fence.group(1).strip()), "markdown_fence" + except json.JSONDecodeError: + pass + + first = content.find("{") + last = content.rfind("}") + if first != -1 and last > first: + try: + return json.loads(content[first : last + 1]), "first_last_brace" + except json.JSONDecodeError: + pass + + for candidate in reversed(re.findall(r"\{.*?\"criteria_results\"\s*:\s*\[.*?\].*?\}", content, re.DOTALL)): + try: + return json.loads(candidate), "regex_extract" + except json.JSONDecodeError: + continue + + raise ValueError(f"Could not extract JSON from response: {content[:500]}") + + +def build_rubric_result(rubric_index: int, rubric: dict, parsed: dict) -> dict: + """Score one rubric from the judge's parsed verdict; all criteria must pass.""" + criteria = normalize_criteria(rubric) + weight = rubric.get("weight", 0) + model_criteria = parsed.get("criteria_results", []) + rubric_passed = bool(parsed.get("rubric_passed", False)) + + enriched = [] + for index, criterion in enumerate(criteria): + item = model_criteria[index] if index < len(model_criteria) else {} + if not isinstance(item, dict): + item = {} + enriched.append( + { + "index": index, + "criterion": criterion, + "passed": bool(item.get("passed", False)), + "reasoning": item.get("reasoning", ""), + "evidence": item.get("evidence", ""), + } + ) + + return { + "index": rubric_index, + "rubric": rubric.get("rubric", ""), + "weight": weight, + "result": { + "passed": rubric_passed, + "score": weight if rubric_passed else 0, + "criteria_count": len(criteria), + "criteria_passed": sum(1 for item in enriched if item["passed"]), + "criteria_results": enriched, + "overall_reasoning": parsed.get("overall_reasoning", ""), + }, + } + + +def build_failed_rubric_result(rubric_index: int, rubric: dict, overall_reasoning: str) -> dict: + """A zero-score result for a rubric the judge could not decide.""" + criteria = normalize_criteria(rubric) + return { + "index": rubric_index, + "rubric": rubric.get("rubric", ""), + "weight": rubric.get("weight", 0), + "result": { + "passed": False, + "score": 0, + "criteria_count": len(criteria), + "criteria_passed": 0, + "criteria_results": [ + { + "index": index, + "criterion": criterion, + "passed": False, + "reasoning": overall_reasoning, + "evidence": "", + } + for index, criterion in enumerate(criteria) + ], + "overall_reasoning": overall_reasoning, + }, + } + + +def build_scorecard(results: list[dict]) -> dict[str, float | int]: + """Aggregate rubric results into JobBench's weighted scorecard. + + ``normalized_score`` (weighted score / max weight) is the JobBench headline + metric and becomes the Gym reward; ``pass_rate`` is the fraction of rubrics + that passed every criterion. + """ + total_score = sum(result["result"]["score"] for result in results) + max_score = sum(result["weight"] for result in results) + passed_count = sum(1 for result in results if result["result"]["passed"]) + total_count = len(results) + + return { + "total_score": total_score, + "max_score": max_score, + "normalized_score": round(total_score / max_score, 4) if max_score > 0 else 0.0, + "pass_rate": round(passed_count / total_count, 4) if total_count > 0 else 0.0, + "passed_count": passed_count, + "total_count": total_count, + } diff --git a/resources_servers/job_bench/prepare.py b/resources_servers/job_bench/prepare.py new file mode 100644 index 00000000000..94e24c794dd --- /dev/null +++ b/resources_servers/job_bench/prepare.py @@ -0,0 +1,205 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Materialize the JobBench dataset into a control-plane cache and a Gym JSONL. + +Upstream ``setup.sh`` pulls ``JobBench/job-bench`` from Hugging Face and lays the +two splits out as ``dataset/main`` and ``dataset/easy``. This does the same into a +gitignored cache under the resources server, then writes the model-visible JSONL. + +Rubrics, task cards and ``files_required_to_search/`` stay in the cache: the JSONL +carries only the task instructions the agent is allowed to see plus the task ID +the resources server uses to look the answer key back up. +""" + +from __future__ import annotations + +import argparse +import json +import shutil +from pathlib import Path + +from resources_servers.job_bench.task_store import ( + EXPECTED_TASK_COUNTS, + OUTPUT_DIR, + SEARCH_FILES_DIR, + SPLITS, + TASK_FOLDER_DIR, + WORKSPACE_DIR, + JobBenchTask, + discover_tasks, +) + + +PACKAGE_DIR = Path(__file__).resolve().parent +NEMO_GYM_ROOT = PACKAGE_DIR.parents[1] + +DATASET_REPO_ID = "JobBench/job-bench" +DEFAULT_CACHE_DIR = PACKAGE_DIR / "data" / "cache" / "tasks" +DEFAULT_BENCHMARK_DIR = NEMO_GYM_ROOT / "benchmarks" / "job_bench" / "data" + +# Upstream ships the main split under `dataset/` and the easy split under +# `dataset_easy/`; setup.sh renames them to main/ and easy/. +UPSTREAM_SPLIT_DIRS = {"main": "dataset", "easy": "dataset_easy"} + +EXAMPLE_TASK_COUNT = 5 + + +def build_prompt(task: JobBenchTask, *, include_search_files: bool) -> str: + """Reproduce the upstream OpenCode runner prompt against sandbox paths. + + Mirrors ``eval/run_benchmark_opencode.sh``, with the runner's ``/tmp`` + workspace replaced by the sandbox workspace the resources server seeds. + """ + search_files_line = ( + f"\n- Reference files that must be searched for are available in: {SEARCH_FILES_DIR}" + if include_search_files + else "" + ) + return f"""=== TASK FOLDER === +{TASK_FOLDER_DIR} + +=== INSTRUCTIONS === +1. Read the TASK_INSTRUCTIONS.txt file in the task folder above +2. Based on the Reference Files section in TASK_INSTRUCTIONS.txt, read the corresponding files from the same task folder using appropriate tools. +3. Complete the task as specified in TASK_INSTRUCTIONS.txt +4. Only save the final deliverables to the output directory specified below. Do not save any intermediate or temporary files. + +=== OUTPUT DIRECTORY === +{OUTPUT_DIR} + +IMPORTANT: +- All reference files are in the task folder: {TASK_FOLDER_DIR}{search_files_line} +- Only save the final deliverables to the output directory {OUTPUT_DIR}. Do not save any intermediate or temporary files. +- You MUST only access files within {WORKSPACE_DIR} or search online for new reference files if you find needed. Do NOT access any files or directories in this system outside of this path. +- If you encounter ambiguous or conflicting information, analyze the conflict, explain your reasoning, and justify the approach you choose. +- If a file cannot be read directly (e.g., .xlsx, .docx, .db, .pptx), use appropriate tools, MCP servers, or code to extract and process its contents.""" + + +def build_row(task: JobBenchTask, *, include_search_files: bool) -> dict: + """Build one Gym JSONL row for a prepared task.""" + return { + "task_id": task.task_id, + "responses_create_params": { + "input": [{"role": "user", "content": build_prompt(task, include_search_files=include_search_files)}] + }, + "verifier_metadata": { + "task_id": task.task_id, + "split": task.split, + "profession": task.profession, + "task_name": task.task_name, + # Carried for analysis and to detect a cache that drifted from the + # JSONL; the rubric text itself never leaves the control plane. + "num_rubrics": len(task.rubrics), + "max_score": task.max_score, + "rubrics_sha256": task.rubrics_sha256, + }, + } + + +def download_dataset(cache_dir: Path, *, splits: tuple[str, ...], force: bool) -> None: + """Fetch the requested splits from Hugging Face into ``cache_dir``.""" + missing = [split for split in splits if not (cache_dir / split).is_dir()] + if not missing and not force: + print(f"JobBench cache already populated at {cache_dir}; pass --force to re-download.") + return + if force: + for split in splits: + shutil.rmtree(cache_dir / split, ignore_errors=True) + missing = list(splits) + + from huggingface_hub import snapshot_download + + staging = cache_dir.parent / "_hf_snapshot" + staging.mkdir(parents=True, exist_ok=True) + patterns = [f"{UPSTREAM_SPLIT_DIRS[split]}/**" for split in missing] + print(f"Downloading {DATASET_REPO_ID} splits {missing} into {staging} ...") + snapshot_download( + DATASET_REPO_ID, + repo_type="dataset", + allow_patterns=patterns, + local_dir=str(staging), + ) + + cache_dir.mkdir(parents=True, exist_ok=True) + for split in missing: + source = staging / UPSTREAM_SPLIT_DIRS[split] + if not source.is_dir(): + raise RuntimeError(f"Expected {source} in the Hugging Face snapshot for split {split!r}") + destination = cache_dir / split + shutil.rmtree(destination, ignore_errors=True) + shutil.move(str(source), str(destination)) + print(f" {split}: {destination}") + + +def write_jsonl(rows: list[dict], path: Path) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("w", encoding="utf-8") as handle: + for row in rows: + handle.write(json.dumps(row) + "\n") + + +def prepare( + *, + split: str = "main", + cache_dir: Path = DEFAULT_CACHE_DIR, + benchmark_dir: Path = DEFAULT_BENCHMARK_DIR, + include_search_files: bool = False, + download: bool = True, + force: bool = False, + write_example: bool = True, +) -> tuple[Path, Path]: + """Populate the cache and write the benchmark JSONL; return (cache_dir, jsonl_path).""" + if split not in SPLITS: + raise ValueError(f"Unknown JobBench split {split!r}; expected one of {SPLITS}") + + if download: + download_dataset(cache_dir, splits=(split,), force=force) + + tasks = discover_tasks(cache_dir, split) + expected = EXPECTED_TASK_COUNTS[split] + if len(tasks) != expected: + raise RuntimeError(f"Prepared {len(tasks)} tasks for split {split!r}, expected {expected}") + + rows = [build_row(task, include_search_files=include_search_files) for task in tasks.values()] + jsonl_path = benchmark_dir / f"job_bench_{split}_benchmark.jsonl" + write_jsonl(rows, jsonl_path) + print(f"Wrote {len(rows)} tasks to {jsonl_path}") + + if write_example: + example_path = PACKAGE_DIR / "data" / "example.jsonl" + write_jsonl(rows[:EXAMPLE_TASK_COUNT], example_path) + print(f"Wrote {min(EXAMPLE_TASK_COUNT, len(rows))} tasks to {example_path}") + + return cache_dir, jsonl_path + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--split", choices=SPLITS, default="main") + parser.add_argument("--cache-dir", type=Path, default=DEFAULT_CACHE_DIR) + parser.add_argument("--benchmark-dir", type=Path, default=DEFAULT_BENCHMARK_DIR) + parser.add_argument( + "--include-search-files", + action="store_true", + help="Tell the agent that files_required_to_search/ is mounted in the sandbox. " + "Off by default to match the upstream runner, which withholds those files.", + ) + parser.add_argument("--no-download", dest="download", action="store_false", help="Use the existing cache as-is.") + parser.add_argument("--force", action="store_true", help="Wipe and re-download the split.") + parser.add_argument("--no-example", dest="write_example", action="store_false") + args = parser.parse_args() + + prepare( + split=args.split, + cache_dir=args.cache_dir, + benchmark_dir=args.benchmark_dir, + include_search_files=args.include_search_files, + download=args.download, + force=args.force, + write_example=args.write_example, + ) + + +if __name__ == "__main__": + main() diff --git a/resources_servers/job_bench/requirements.txt b/resources_servers/job_bench/requirements.txt new file mode 100644 index 00000000000..90cf2a9d919 --- /dev/null +++ b/resources_servers/job_bench/requirements.txt @@ -0,0 +1,7 @@ +-e nemo-gym[dev,sandbox] @ ../.. +huggingface-hub>=0.24.0 +pandas>=2.0.0 +openpyxl>=3.1.0 +python-pptx>=0.6.0 +pdfplumber>=0.11.0 +mammoth>=1.8.0 diff --git a/resources_servers/job_bench/task_data.py b/resources_servers/job_bench/task_data.py new file mode 100644 index 00000000000..c9629fb2ed7 --- /dev/null +++ b/resources_servers/job_bench/task_data.py @@ -0,0 +1,84 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +"""Task-data schema for the job_bench server. + +Pointer rows. A row names a JobBench task and nothing else that matters to grading: the rubrics, +the task materials and the ``files_required_to_search/`` corpus all live OUT of the row, in the +gitignored control-plane cache that ``prepare.py`` materializes under ``config.cache_dir`` +(``///``), keyed by ``task_id``. Keeping the rubrics out of the row is +the point: they are the answer key, and the agent is handed the row. + +Required-ness mirrors ``JobBenchInstanceRequest`` (app.py, ``extra="allow"``): ``task_id`` is +wire-Optional even though ``_resolve_task_id`` errors when it is absent from both the top level +and ``verifier_metadata``. Committed rows duplicate it in both places with equal values, and +``_resolve_task_id`` accepts either placement (erroring only on conflict), so ``task_id`` carries +no ``legacy_location`` marker. The remaining fields are written by ``prepare.py`` into +``verifier_metadata`` for analysis and drift detection; ``verify()`` reads none of them. + +``sandbox_handle`` (``JobBenchVerifyRequest``) is injected by seed_session at verify time and is +not a task field. +""" + +from typing import Optional + +from pydantic import BaseModel, ConfigDict, Field + + +class TaskData(BaseModel): + model_config = ConfigDict(extra="allow") + + task_id: Optional[str] = Field( + default=None, + description=( + "Key into the on-disk JobBench cache, '//' (e.g. " + "'main/biostatisticians/task1'). Selects the task materials seeded into the sandbox and the " + "rubrics used to grade it. Wire-Optional because rows also duplicate it inside verifier_metadata " + "(_resolve_task_id accepts either placement and errors on conflict or on both missing)." + ), + json_schema_extra={"consumed_by": ["verify"]}, + ) + split: Optional[str] = Field( + default=None, + description=( + "JobBench split the task came from, 'main' (the leaderboard split) or 'easy'. Provenance only: " + "the server resolves the split from its own config, not from the row." + ), + json_schema_extra={"consumed_by": ["provenance"], "legacy_location": "verifier_metadata"}, + ) + profession: Optional[str] = Field( + default=None, + description=( + "Occupation the task is drawn from (e.g. 'biostatisticians'), the first path component of " + "task_id. Useful for per-profession breakdowns of the aggregate score." + ), + json_schema_extra={"consumed_by": ["provenance"], "legacy_location": "verifier_metadata"}, + ) + task_name: Optional[str] = Field( + default=None, + description="Per-profession task directory name (e.g. 'task1'), the last component of task_id.", + json_schema_extra={"consumed_by": ["provenance"], "legacy_location": "verifier_metadata"}, + ) + num_rubrics: Optional[int] = Field( + default=None, + description=( + "Number of rubrics in the task's RUBRICS.json at prepare time. Provenance only; verify() counts " + "the rubrics it actually loads from the cache." + ), + json_schema_extra={"consumed_by": ["provenance"], "legacy_location": "verifier_metadata"}, + ) + max_score: Optional[int] = Field( + default=None, + description=( + "Sum of the rubric weights at prepare time, i.e. the denominator of the reward. Provenance only; " + "verify() recomputes it from the cache and reports it on the response." + ), + json_schema_extra={"consumed_by": ["provenance"], "legacy_location": "verifier_metadata"}, + ) + rubrics_sha256: Optional[str] = Field( + default=None, + description=( + "SHA-256 of the task's RUBRICS.json at prepare time. Lets a run detect that the cache's rubrics " + "drifted from the ones this JSONL was built against, which would make scores incomparable." + ), + json_schema_extra={"consumed_by": ["provenance"], "legacy_location": "verifier_metadata"}, + ) diff --git a/resources_servers/job_bench/task_store.py b/resources_servers/job_bench/task_store.py new file mode 100644 index 00000000000..5047ec4a66a --- /dev/null +++ b/resources_servers/job_bench/task_store.py @@ -0,0 +1,189 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Local task store for the prepared JobBench control-plane cache. + +``prepare.py`` materializes the upstream Hugging Face dataset into + + //// + task_folder/ # the agent's working materials + files_required_to_search/ # main split only; withheld from the agent by default + RUBRICS.json # grading rubrics (never given to the agent) + task_card.md # human-readable brief (never given to the agent) + +Rubrics and search files are the answer key, so they stay in the gitignored cache +on the resources server and never travel in the model-visible JSONL. +""" + +from __future__ import annotations + +import hashlib +import json +import re +from dataclasses import dataclass +from functools import cached_property +from pathlib import Path + + +SPLITS = ("main", "easy") + +# Task counts published by JobBench; a short count means a partial cache. +EXPECTED_TASK_COUNTS = {"main": 65, "easy": 63} + +# Sandbox layout. These are baked into the agent prompt at prepare time and +# recreated by the resources server at seed time, so both must agree. +WORKSPACE_DIR = "/workspace" +TASK_FOLDER_DIR = f"{WORKSPACE_DIR}/task_folder" +OUTPUT_DIR = f"{WORKSPACE_DIR}/output" +SEARCH_FILES_DIR = f"{WORKSPACE_DIR}/files_required_to_search" + +INSTRUCTIONS_FILENAME = "TASK_INSTRUCTIONS.txt" +RUBRICS_FILENAME = "RUBRICS.json" +TASK_CARD_FILENAME = "task_card.md" +TASK_FOLDER_NAME = "task_folder" +SEARCH_FILES_NAME = "files_required_to_search" + +_TASK_DIR_PATTERN = re.compile(r"^task\d+$") +_LABEL_SAFE_PATTERN = re.compile(r"[^A-Za-z0-9._-]+") + + +class JobBenchTaskError(RuntimeError): + """The prepared cache is missing or malformed for a requested task.""" + + +@dataclass(frozen=True) +class JobBenchTask: + """One prepared JobBench task rooted at ``task_dir``.""" + + task_id: str + split: str + profession: str + task_name: str + task_dir: Path + + @property + def task_folder(self) -> Path: + return self.task_dir / TASK_FOLDER_NAME + + @property + def search_files_dir(self) -> Path: + return self.task_dir / SEARCH_FILES_NAME + + @property + def rubrics_path(self) -> Path: + return self.task_dir / RUBRICS_FILENAME + + @property + def instructions_path(self) -> Path: + return self.task_folder / INSTRUCTIONS_FILENAME + + @cached_property + def rubrics(self) -> list[dict]: + return load_rubrics(self.rubrics_path) + + @cached_property + def rubrics_sha256(self) -> str: + return hashlib.sha256(self.rubrics_path.read_bytes()).hexdigest() + + @property + def max_score(self) -> int: + return sum(int(rubric.get("weight", 0)) for rubric in self.rubrics) + + @property + def instructions(self) -> str: + return self.instructions_path.read_text(encoding="utf-8", errors="replace") + + @property + def label(self) -> str: + """A value safe to use as a sandbox metadata label.""" + return _LABEL_SAFE_PATTERN.sub("-", self.task_id)[:63] + + +def load_rubrics(rubrics_path: Path) -> list[dict]: + """Read a ``RUBRICS.json`` file, accepting both upstream key spellings.""" + try: + payload = json.loads(rubrics_path.read_text(encoding="utf-8")) + except OSError as error: + raise JobBenchTaskError(f"Cannot read rubrics at {rubrics_path}: {error}") from error + except json.JSONDecodeError as error: + raise JobBenchTaskError(f"Malformed rubrics JSON at {rubrics_path}: {error}") from error + + # run_judge.sh accepts either `.rubrics` or `.evaluation_rubrics`. + rubrics = payload.get("rubrics") + if rubrics is None: + rubrics = payload.get("evaluation_rubrics") + if not isinstance(rubrics, list) or not rubrics: + raise JobBenchTaskError(f"No non-empty 'rubrics' array in {rubrics_path}") + + for index, rubric in enumerate(rubrics): + if not isinstance(rubric, dict): + raise JobBenchTaskError(f"Rubric {index} in {rubrics_path} is not an object") + if not isinstance(rubric.get("weight", 0), (int, float)): + raise JobBenchTaskError(f"Rubric {index} in {rubrics_path} has a non-numeric weight") + return rubrics + + +def build_task_id(split: str, profession: str, task_name: str) -> str: + return f"{split}/{profession}/{task_name}" + + +def discover_tasks(cache_dir: Path, split: str) -> dict[str, JobBenchTask]: + """Index every ``/`` directory under ``/``.""" + split_root = cache_dir / split + if not split_root.is_dir(): + raise JobBenchTaskError( + f"JobBench cache for split {split!r} not found at {split_root}. " + "Run `python -m resources_servers.job_bench.prepare` first." + ) + + tasks: dict[str, JobBenchTask] = {} + for profession_dir in sorted(p for p in split_root.iterdir() if p.is_dir()): + for task_dir in sorted(t for t in profession_dir.iterdir() if t.is_dir()): + if not _TASK_DIR_PATTERN.match(task_dir.name): + continue + task = JobBenchTask( + task_id=build_task_id(split, profession_dir.name, task_dir.name), + split=split, + profession=profession_dir.name, + task_name=task_dir.name, + task_dir=task_dir, + ) + if not task.rubrics_path.is_file(): + raise JobBenchTaskError(f"Task {task.task_id} is missing {RUBRICS_FILENAME}") + if not task.instructions_path.is_file(): + raise JobBenchTaskError(f"Task {task.task_id} is missing {TASK_FOLDER_NAME}/{INSTRUCTIONS_FILENAME}") + tasks[task.task_id] = task + return tasks + + +class JobBenchTaskStore: + """Read-only index over a prepared JobBench cache for a single split.""" + + def __init__(self, cache_dir: Path, split: str, *, expected_task_count: int | None = None) -> None: + if split not in SPLITS: + raise JobBenchTaskError(f"Unknown JobBench split {split!r}; expected one of {SPLITS}") + self.cache_dir = cache_dir + self.split = split + self._tasks = discover_tasks(cache_dir, split) + + expected = expected_task_count if expected_task_count is not None else EXPECTED_TASK_COUNTS[split] + if len(self._tasks) != expected: + raise JobBenchTaskError( + f"JobBench split {split!r} has {len(self._tasks)} tasks in {cache_dir}, expected {expected}. " + "Re-run prepare.py (use FORCE to re-download a partial cache)." + ) + + def __len__(self) -> int: + return len(self._tasks) + + def __contains__(self, task_id: object) -> bool: + return task_id in self._tasks + + def get(self, task_id: str) -> JobBenchTask: + try: + return self._tasks[task_id] + except KeyError: + raise JobBenchTaskError(f"Unknown JobBench task {task_id!r} in split {self.split!r}") from None + + def values(self) -> list[JobBenchTask]: + return list(self._tasks.values()) diff --git a/resources_servers/job_bench/tests/__init__.py b/resources_servers/job_bench/tests/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/job_bench/tests/conftest.py b/resources_servers/job_bench/tests/conftest.py new file mode 100644 index 00000000000..fd41d31c821 --- /dev/null +++ b/resources_servers/job_bench/tests/conftest.py @@ -0,0 +1,49 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +import json +from pathlib import Path + +import pytest + + +RUBRICS = { + "rubrics": [ + { + "rubric": "Does the report state the eligible population count?", + "weight": 10, + "criterion": [ + "The report gives a population count", + "The count is 1,108", + ], + }, + { + "rubric": "Does the deliverable include a plot of the age distribution?", + "weight": 5, + "criterion": ["An age distribution figure is present"], + }, + ] +} + + +@pytest.fixture +def cache_dir(tmp_path: Path) -> Path: + """A minimal prepared cache with one main-split task.""" + task_dir = tmp_path / "tasks" / "main" / "biostatisticians" / "task1" + task_folder = task_dir / "task_folder" + search_files = task_dir / "files_required_to_search" + task_folder.mkdir(parents=True) + search_files.mkdir(parents=True) + + (task_folder / "TASK_INSTRUCTIONS.txt").write_text("Analyze the cohort.\n", encoding="utf-8") + (task_folder / "cohort.csv").write_text("id,age\n1,39\n", encoding="utf-8") + (search_files / "guidance.txt").write_text("FDA E9 guidance.\n", encoding="utf-8") + (task_dir / "RUBRICS.json").write_text(json.dumps(RUBRICS), encoding="utf-8") + (task_dir / "task_card.md").write_text("# Brief\n", encoding="utf-8") + + return tmp_path / "tasks" + + +@pytest.fixture +def task_id() -> str: + return "main/biostatisticians/task1" diff --git a/resources_servers/job_bench/tests/test_app.py b/resources_servers/job_bench/tests/test_app.py new file mode 100644 index 00000000000..83f9fe6a8a1 --- /dev/null +++ b/resources_servers/job_bench/tests/test_app.py @@ -0,0 +1,632 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +import json +import tarfile +from pathlib import Path +from types import SimpleNamespace +from unittest.mock import AsyncMock, MagicMock + +import pytest +from pytest import MonkeyPatch + +from nemo_gym.config_types import ModelServerRef +from nemo_gym.judge import JudgeError +from nemo_gym.server_utils import SESSION_ID_KEY, ServerClient +from resources_servers.job_bench.app import ( + AgentSandboxSession, + JobBenchResourcesServer, + JobBenchResourcesServerConfig, + JobBenchSeedSessionRequest, + JobBenchVerifyRequest, + _build_archive, + _extract_archive, + _resolve_task_id, +) + + +SESSION = "session-1" + + +def _config(cache_dir: Path, tmp_path: Path, **overrides) -> JobBenchResourcesServerConfig: + return JobBenchResourcesServerConfig( + host="0.0.0.0", + port=8080, + entrypoint="", + name="job_bench_resources_server", + cache_dir=cache_dir, + archives_dir=tmp_path / "archives", + split="main", + expected_task_count=1, + sandbox_provider="test", + sandbox_image="job-bench-sandbox:latest", + judge_model_server=ModelServerRef(type="responses_api_models", name="judge_model"), + **overrides, + ) + + +def _server(cache_dir: Path, tmp_path: Path, **overrides) -> JobBenchResourcesServer: + return JobBenchResourcesServer( + config=_config(cache_dir, tmp_path, **overrides), + server_client=MagicMock(spec=ServerClient), + ) + + +def _request(session_id: str = SESSION) -> SimpleNamespace: + # Deliberately not a MagicMock: judge_failsafe finds the verify body by duck + # typing, and a MagicMock answers hasattr() for everything, so it would be + # mistaken for the body. + return SimpleNamespace(session={SESSION_ID_KEY: session_id}) + + +def _body(task_id: str) -> dict: + return { + "task_id": task_id, + "verifier_metadata": {"task_id": task_id}, + "responses_create_params": {"input": [{"role": "user", "content": "do the task"}]}, + "response": { + "output": [], + "id": "response", + "created_at": 0, + "model": "test", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], + }, + } + + +def _sandbox(sandbox_id: str = "sandbox-1") -> MagicMock: + sandbox = MagicMock() + sandbox.serialize = AsyncMock(return_value={"sandbox_id": sandbox_id}) + sandbox.upload = AsyncMock() + sandbox.download = AsyncMock() + sandbox.stop = AsyncMock() + sandbox.exec = AsyncMock(return_value=SimpleNamespace(return_code=0, stdout="", stderr="")) + return sandbox + + +def _judge_reply(content: str) -> MagicMock: + reply = MagicMock() + reply.choices = [SimpleNamespace(message=SimpleNamespace(content=content))] + return reply + + +def _passing_verdict(num_criteria: int) -> str: + return json.dumps( + { + "criteria_results": [ + {"index": i, "passed": True, "reasoning": "ok", "evidence": "e"} for i in range(num_criteria) + ], + "rubric_passed": True, + "overall_reasoning": "all criteria met", + } + ) + + +# --------------------------------------------------------------- task routing + + +def test_resolve_task_id_prefers_an_explicit_id() -> None: + body = SimpleNamespace(task_id="main/a/task1", verifier_metadata={"task_id": "main/a/task1"}) + + assert _resolve_task_id(body) == "main/a/task1" + + +def test_resolve_task_id_falls_back_to_verifier_metadata() -> None: + body = SimpleNamespace(task_id=None, verifier_metadata={"task_id": "main/a/task1"}) + + assert _resolve_task_id(body) == "main/a/task1" + + +def test_resolve_task_id_rejects_conflicting_ids() -> None: + body = SimpleNamespace(task_id="main/a/task1", verifier_metadata={"task_id": "main/b/task2"}) + + with pytest.raises(ValueError, match="Conflicting JobBench task IDs"): + _resolve_task_id(body) + + +def test_resolve_task_id_requires_an_id() -> None: + with pytest.raises(ValueError, match="must provide"): + _resolve_task_id(SimpleNamespace(task_id=None, verifier_metadata={})) + + +# ------------------------------------------------------------ network posture + + +def test_open_network_is_the_default_and_adds_no_egress_policy(cache_dir: Path, tmp_path: Path) -> None: + server = _server(cache_dir, tmp_path) + + # JobBench expects the open internet, so nothing should be injected. + assert server._provider_options() == {} + + +def test_hermetic_mode_denies_all_egress_but_allows_the_model_server( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path +) -> None: + server = _server( + cache_dir, + tmp_path, + enforce_agent_no_network=True, + sandbox_model_server=ModelServerRef(type="responses_api_models", name="policy_model"), + ) + monkeypatch.setattr( + "resources_servers.job_bench.app.get_global_config_dict", + lambda: {"policy_model": {"responses_api_models": {"model": {"host": "model.internal", "port": 8000}}}}, + ) + + options = server._provider_options() + assert options["network_policy"]["defaultAction"] == "deny" + assert options["network_policy"]["egress"] == [{"action": "allow", "target": "model.internal"}] + + +def test_hermetic_mode_rejects_a_loopback_model_host( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path +) -> None: + server = _server( + cache_dir, + tmp_path, + enforce_agent_no_network=True, + sandbox_model_server=ModelServerRef(type="responses_api_models", name="policy_model"), + ) + monkeypatch.setattr( + "resources_servers.job_bench.app.get_global_config_dict", + lambda: {"policy_model": {"responses_api_models": {"model": {"host": "127.0.0.1", "port": 8000}}}}, + ) + + with pytest.raises(ValueError, match="cannot reach loopback model host"): + server._provider_options() + + +def test_hermetic_mode_without_a_model_server_still_denies_all(cache_dir: Path, tmp_path: Path) -> None: + server = _server(cache_dir, tmp_path, enforce_agent_no_network=True) + + assert server._provider_options()["network_policy"] == {"defaultAction": "deny", "egress": []} + + +# ----------------------------------------------------------------- archiving + + +def test_task_archive_contains_only_the_task_folder_by_default(cache_dir: Path, tmp_path: Path) -> None: + server = _server(cache_dir, tmp_path) + task = server._task_store.get("main/biostatisticians/task1") + + archive_path = _run(server._task_archive(task)) + with tarfile.open(archive_path) as archive: + names = archive.getnames() + + assert "task_folder/TASK_INSTRUCTIONS.txt" in names + # The search files are the answer key's discovery half; they stay behind. + assert not any(name.startswith("files_required_to_search") for name in names) + + +def test_task_archive_includes_search_files_when_enabled(cache_dir: Path, tmp_path: Path) -> None: + server = _server(cache_dir, tmp_path, include_search_files=True) + task = server._task_store.get("main/biostatisticians/task1") + + archive_path = _run(server._task_archive(task)) + with tarfile.open(archive_path) as archive: + names = archive.getnames() + + assert "files_required_to_search/guidance.txt" in names + + +def test_task_archive_is_built_once_and_reused(cache_dir: Path, tmp_path: Path) -> None: + server = _server(cache_dir, tmp_path) + task = server._task_store.get("main/biostatisticians/task1") + + first = _run(server._task_archive(task)) + mtime = first.stat().st_mtime_ns + second = _run(server._task_archive(task)) + + assert first == second + assert second.stat().st_mtime_ns == mtime + + +def test_archive_roundtrip_preserves_content(tmp_path: Path) -> None: + source = tmp_path / "output" + source.mkdir() + (source / "report.txt").write_text("done", encoding="utf-8") + archive_path = tmp_path / "out.tgz" + + _build_archive({"output": source}, archive_path) + destination = tmp_path / "restored" + _extract_archive(archive_path, destination) + + assert (destination / "output" / "report.txt").read_text() == "done" + + +# --------------------------------------------------------------- seed_session + + +def test_seed_session_starts_a_sandbox_and_lays_out_the_workspace( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + monkeypatch.setattr(server, "_create_sandbox", AsyncMock(return_value=sandbox)) + + response = _run(server.seed_session(_request(), JobBenchSeedSessionRequest(**_body(task_id)))) + + assert response.sandbox_handle == "sandbox-1" + assert server._agent_sessions[SESSION].task_id == task_id + sandbox.upload.assert_awaited_once() + setup_command = sandbox.exec.await_args.args[0] + assert "/workspace/output" in setup_command + assert "tar -xzf" in setup_command + + +def test_seed_session_stops_the_sandbox_when_seeding_fails( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + sandbox.exec = AsyncMock(return_value=SimpleNamespace(return_code=1, stdout="", stderr="no such file")) + monkeypatch.setattr(server, "_create_sandbox", AsyncMock(return_value=sandbox)) + + with pytest.raises(RuntimeError, match="Failed to seed JobBench workspace"): + _run(server.seed_session(_request(), JobBenchSeedSessionRequest(**_body(task_id)))) + + sandbox.stop.assert_awaited_once() + assert SESSION not in server._agent_sessions + + +def test_seed_session_requires_a_sandbox_id( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + sandbox.serialize = AsyncMock(return_value={}) + monkeypatch.setattr(server, "_create_sandbox", AsyncMock(return_value=sandbox)) + + with pytest.raises(RuntimeError, match="did not return a sandbox_id"): + _run(server.seed_session(_request(), JobBenchSeedSessionRequest(**_body(task_id)))) + + +def test_seed_session_replaces_a_stale_sandbox_for_the_same_session( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + stale = _sandbox("stale") + server._agent_sessions[SESSION] = AgentSandboxSession(task_id=task_id, sandbox=stale, sandbox_handle="stale") + monkeypatch.setattr(server, "_create_sandbox", AsyncMock(return_value=_sandbox())) + + _run(server.seed_session(_request(), JobBenchSeedSessionRequest(**_body(task_id)))) + + stale.stop.assert_awaited_once() + assert server._agent_sessions[SESSION].sandbox_handle == "sandbox-1" + + +# ---------------------------------------------------------------- collection + + +def test_collect_output_refuses_an_oversized_output_directory(cache_dir: Path, tmp_path: Path, task_id: str) -> None: + server = _server(cache_dir, tmp_path, max_output_mib=1) + task = server._task_store.get(task_id) + sandbox = _sandbox() + sandbox.exec = AsyncMock(return_value=SimpleNamespace(return_code=0, stdout="9999\n", stderr="")) + + with pytest.raises(RuntimeError, match="above the 1 MiB cap"): + _run(server._collect_output(sandbox, task, tmp_path / "dest")) + + +def test_collect_output_reports_a_missing_output_directory(cache_dir: Path, tmp_path: Path, task_id: str) -> None: + server = _server(cache_dir, tmp_path) + task = server._task_store.get(task_id) + sandbox = _sandbox() + sandbox.exec = AsyncMock(return_value=SimpleNamespace(return_code=1, stdout="", stderr="")) + + with pytest.raises(RuntimeError, match="is missing in the agent sandbox"): + _run(server._collect_output(sandbox, task, tmp_path / "dest")) + + +# -------------------------------------------------------------------- verify + + +def test_verify_without_a_seeded_session_scores_zero_and_explains_why( + cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + assert response.reward == 0.0 + assert response.evaluation_completed is False + assert "No JobBench agent sandbox exists" in response.failure_reason + # The rubric denominator is still reported so the row aggregates correctly. + assert response.max_score == 15.0 + assert response.total_count == 2 + + +def test_verify_scores_the_weighted_normalized_score( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + server._agent_sessions[SESSION] = AgentSandboxSession(task_id=task_id, sandbox=sandbox, sandbox_handle="sandbox-1") + + async def fake_collect(_sandbox, _task, destination: Path) -> None: + output = destination / "output" + output.mkdir(parents=True) + (output / "report.txt").write_text("Eligible population: 1,108", encoding="utf-8") + + monkeypatch.setattr(server, "_collect_output", fake_collect) + # The first rubric passes both criteria; the second (the plot) fails. + replies = iter([_judge_reply(_passing_verdict(2)), _judge_reply(json.dumps({"rubric_passed": False}))]) + monkeypatch.setattr( + "resources_servers.job_bench.app.call_judge", AsyncMock(side_effect=lambda *a, **k: next(replies)) + ) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + assert response.evaluation_completed is True + # 10 of 15 weight, not 1 of 2 rubrics. + assert response.reward == pytest.approx(10 / 15, abs=1e-4) + assert response.total_score == 10.0 + assert response.max_score == 15.0 + assert response.pass_rate == 0.5 + assert response.num_output_files == 1 + assert len(response.rubrics) == 2 + sandbox.stop.assert_awaited_once() + + +def test_verify_rejects_a_session_seeded_for_a_different_task( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + server._agent_sessions[SESSION] = AgentSandboxSession( + task_id="main/lawyers/task4", sandbox=sandbox, sandbox_handle="sandbox-1" + ) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + assert response.reward == 0.0 + assert "does not match verify task" in response.failure_reason + sandbox.stop.assert_awaited_once() + + +def test_verify_can_omit_rubric_details( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path, include_rubric_details_in_response=False) + server._agent_sessions[SESSION] = AgentSandboxSession( + task_id=task_id, sandbox=_sandbox(), sandbox_handle="sandbox-1" + ) + + async def fake_collect(_sandbox, _task, destination: Path) -> None: + (destination / "output").mkdir(parents=True) + + monkeypatch.setattr(server, "_collect_output", fake_collect) + monkeypatch.setattr( + "resources_servers.job_bench.app.call_judge", + AsyncMock(return_value=_judge_reply(json.dumps({"rubric_passed": False}))), + ) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + assert response.rubrics is None + assert response.reward == 0.0 + + +def test_verify_propagates_a_judge_transport_failure( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + server._agent_sessions[SESSION] = AgentSandboxSession( + task_id=task_id, sandbox=_sandbox(), sandbox_handle="sandbox-1" + ) + + async def fake_collect(_sandbox, _task, destination: Path) -> None: + (destination / "output").mkdir(parents=True) + + monkeypatch.setattr(server, "_collect_output", fake_collect) + monkeypatch.setattr( + "resources_servers.job_bench.app.call_judge", AsyncMock(side_effect=JudgeError("judge unreachable")) + ) + + # A failed judge *call* is not a zero score: it must reach the /verify route's + # judge_failsafe wrapper, which routes the row to the failures sidecar. + with pytest.raises(JudgeError, match="judge unreachable"): + _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + +@pytest.mark.parametrize("content", ["", "sorry, I cannot comply"]) +def test_verify_scores_an_unusable_judge_reply_as_a_failed_rubric( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str, content: str +) -> None: + server = _server(cache_dir, tmp_path) + server._agent_sessions[SESSION] = AgentSandboxSession( + task_id=task_id, sandbox=_sandbox(), sandbox_handle="sandbox-1" + ) + + async def fake_collect(_sandbox, _task, destination: Path) -> None: + (destination / "output").mkdir(parents=True) + + monkeypatch.setattr(server, "_collect_output", fake_collect) + monkeypatch.setattr("resources_servers.job_bench.app.call_judge", AsyncMock(return_value=_judge_reply(content))) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + # A reply that arrived but says nothing usable is a zero, not a sidecar row. + assert response.evaluation_completed is True + assert response.reward == 0.0 + assert response.rubrics[0]["result"]["passed"] is False + + +def test_verify_attaches_images_only_to_the_visual_rubric( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + from resources_servers.job_bench.tests.test_judge import PNG_BYTES + + server = _server(cache_dir, tmp_path) + server._agent_sessions[SESSION] = AgentSandboxSession( + task_id=task_id, sandbox=_sandbox(), sandbox_handle="sandbox-1" + ) + + async def fake_collect(_sandbox, _task, destination: Path) -> None: + output = destination / "output" + output.mkdir(parents=True) + (output / "ages.png").write_bytes(PNG_BYTES) + + monkeypatch.setattr(server, "_collect_output", fake_collect) + call_judge = AsyncMock(return_value=_judge_reply(json.dumps({"rubric_passed": False}))) + monkeypatch.setattr("resources_servers.job_bench.app.call_judge", call_judge) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + assert response.num_vision_images == 1 + contents = [call.kwargs["json"].messages[1]["content"] for call in call_judge.await_args_list] + # Rubric 0 is textual; rubric 1 mentions a plot and gets the multimodal payload. + text_only = [content for content in contents if isinstance(content, str)] + multimodal = [content for content in contents if isinstance(content, list)] + assert len(text_only) == 1 + assert len(multimodal) == 1 + assert any(part.get("type") == "image_url" for part in multimodal[0]) + + +def _run(awaitable): + import asyncio + + return asyncio.run(awaitable) + + +# ------------------------------------------------------------ sandbox startup + + +def test_create_sandbox_pins_the_image_workdir_and_task_labels( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server( + cache_dir, + tmp_path, + sandbox_config={ + "ttl_s": 100, + "ready_timeout_s": 60, + "env": {"MPLBACKEND": "Agg"}, + "resources": {"cpu": 2.0, "memory_mib": 4096}, + "metadata": {"team": "gym"}, + }, + ) + task = server._task_store.get(task_id) + + monkeypatch.setattr("resources_servers.job_bench.app.get_global_config_dict", dict) + monkeypatch.setattr("resources_servers.job_bench.app.resolve_provider_config", lambda *a: "provider") + monkeypatch.setattr("resources_servers.job_bench.app.resolve_provider_metadata", lambda *a: {"origin": "test"}) + started = {} + + class FakeSandbox: + def __init__(self, provider): + started["provider"] = provider + + async def start(self, spec): + started["spec"] = spec + + monkeypatch.setattr("resources_servers.job_bench.app.AsyncSandbox", FakeSandbox) + + _run(server._create_sandbox(task)) + + spec = started["spec"] + assert started["provider"] == "provider" + assert spec.image == "job-bench-sandbox:latest" + # The agent's prompt hard-codes /workspace, so the sandbox must start there. + assert spec.workdir == "/workspace" + assert spec.ttl_s == 100 + assert spec.env == {"MPLBACKEND": "Agg"} + assert spec.metadata["origin"] == "test" + assert spec.metadata["team"] == "gym" + assert spec.metadata["benchmark"] == "job-bench" + assert spec.metadata["job-bench-task"] == "main-biostatisticians-task1" + + +def test_stop_sandbox_swallows_provider_errors(cache_dir: Path, tmp_path: Path, task_id: str) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + sandbox.stop = AsyncMock(side_effect=RuntimeError("provider gone")) + + # A teardown failure must not mask the rollout's real result. + _run(server._stop_sandbox(sandbox, task_id=task_id)) + + +# ------------------------------------------------------- output collection + + +def test_collect_output_downloads_and_unpacks_the_archive(cache_dir: Path, tmp_path: Path, task_id: str) -> None: + server = _server(cache_dir, tmp_path) + task = server._task_store.get(task_id) + + source = tmp_path / "sandbox_output" + source.mkdir() + (source / "report.txt").write_text("1,108 subjects", encoding="utf-8") + remote_archive = tmp_path / "remote.tgz" + _build_archive({"output": source}, remote_archive) + + sandbox = _sandbox() + sandbox.exec = AsyncMock(return_value=SimpleNamespace(return_code=0, stdout="3\n", stderr="")) + + async def download(_remote: str, local: Path) -> None: + Path(local).write_bytes(remote_archive.read_bytes()) + + sandbox.download = AsyncMock(side_effect=download) + + destination = tmp_path / "collected" + _run(server._collect_output(sandbox, task, destination)) + + assert (destination / "output" / "report.txt").read_text() == "1,108 subjects" + + +def test_collect_output_reports_a_failed_archive_step(cache_dir: Path, tmp_path: Path, task_id: str) -> None: + server = _server(cache_dir, tmp_path) + task = server._task_store.get(task_id) + sandbox = _sandbox() + sandbox.exec = AsyncMock( + side_effect=[ + SimpleNamespace(return_code=0, stdout="1\n", stderr=""), + SimpleNamespace(return_code=2, stdout="", stderr="tar: disk full"), + ] + ) + + with pytest.raises(RuntimeError, match="Failed to archive JobBench output"): + _run(server._collect_output(sandbox, task, tmp_path / "dest")) + + +def test_collect_output_tolerates_an_unparseable_size_probe(cache_dir: Path, tmp_path: Path, task_id: str) -> None: + server = _server(cache_dir, tmp_path) + task = server._task_store.get(task_id) + + source = tmp_path / "sandbox_output" + source.mkdir() + remote_archive = tmp_path / "remote.tgz" + _build_archive({"output": source}, remote_archive) + + sandbox = _sandbox() + # `du` printed something unexpected; treat the size as unknown rather than failing. + sandbox.exec = AsyncMock(return_value=SimpleNamespace(return_code=0, stdout="", stderr="")) + + async def download(_remote: str, local: Path) -> None: + Path(local).write_bytes(remote_archive.read_bytes()) + + sandbox.download = AsyncMock(side_effect=download) + + _run(server._collect_output(sandbox, task, tmp_path / "collected")) + + +def test_verify_scores_zero_when_output_collection_fails( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + server = _server(cache_dir, tmp_path) + sandbox = _sandbox() + server._agent_sessions[SESSION] = AgentSandboxSession(task_id=task_id, sandbox=sandbox, sandbox_handle="sandbox-1") + + async def failing_collect(*_args): + raise RuntimeError("sandbox vanished") + + monkeypatch.setattr(server, "_collect_output", failing_collect) + + response = _run(server.verify(_request(), JobBenchVerifyRequest(**_body(task_id)))) + + assert response.reward == 0.0 + assert response.evaluation_completed is False + assert "sandbox vanished" in response.collection_error + sandbox.stop.assert_awaited_once() diff --git a/resources_servers/job_bench/tests/test_judge.py b/resources_servers/job_bench/tests/test_judge.py new file mode 100644 index 00000000000..706ba0df5eb --- /dev/null +++ b/resources_servers/job_bench/tests/test_judge.py @@ -0,0 +1,621 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +import base64 +import json +import sqlite3 +import zipfile +from pathlib import Path + +import pytest + +from resources_servers.job_bench.judge import ( + build_failed_rubric_result, + build_rubric_prompt, + build_rubric_result, + build_scorecard, + build_user_content, + collect_image_attachments, + convert_file_to_text, + extract_all_file_contents, + normalize_criteria, + parse_judge_json, + rubric_needs_vision, +) + + +# A 1x1 PNG; the smallest input that exercises the real image code paths. +PNG_BYTES = base64.b64decode( + "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==" +) +OTHER_PNG_BYTES = base64.b64decode( + "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADElEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==" +) + +RUBRIC = { + "rubric": "Does the report state the population count?", + "weight": 10, + "criterion": ["A count is given", "The count is 1,108"], +} + + +def test_convert_reads_plain_text_formats(tmp_path: Path) -> None: + path = tmp_path / "summary.csv" + path.write_text("id,age\n1,39\n", encoding="utf-8") + + assert convert_file_to_text(path) == "id,age\n1,39\n" + + +def test_convert_reports_unreadable_text_without_raising(tmp_path: Path) -> None: + assert "ERROR: Failed to read text file" in convert_file_to_text(tmp_path / "absent.csv") + + +def test_convert_renders_a_notebook_source_and_stream_output(tmp_path: Path) -> None: + path = tmp_path / "analysis.ipynb" + path.write_text( + json.dumps( + { + "cells": [ + {"cell_type": "code", "source": ["print(1108)\n"], "outputs": [{"text": ["1108\n"]}]}, + ] + } + ), + encoding="utf-8", + ) + + rendered = convert_file_to_text(path) + assert "=== code ===" in rendered + assert "print(1108)" in rendered + assert "1108" in rendered + + +def test_convert_reports_a_malformed_notebook(tmp_path: Path) -> None: + path = tmp_path / "broken.ipynb" + path.write_text("{not json", encoding="utf-8") + + assert "ERROR: Failed to read notebook" in convert_file_to_text(path) + + +def test_convert_renders_sqlite_schema_and_rows(tmp_path: Path) -> None: + path = tmp_path / "records.db" + connection = sqlite3.connect(path) + connection.execute("CREATE TABLE subjects (id INTEGER, name TEXT)") + connection.execute("INSERT INTO subjects VALUES (1, 'a'), (2, NULL)") + connection.commit() + connection.close() + + rendered = convert_file_to_text(path) + assert "=== Schema ===" in rendered + assert "=== Table: subjects ===" in rendered + assert "total_rows: 2" in rendered + assert "id,name" in rendered + # NULLs render as empty cells rather than the string "None". + assert "2," in rendered + + +def test_convert_reports_a_corrupt_sqlite_file(tmp_path: Path) -> None: + path = tmp_path / "records.db" + path.write_bytes(b"not a database") + + assert "ERROR" in convert_file_to_text(path) + + +def test_convert_labels_images_and_unknown_binaries(tmp_path: Path) -> None: + image = tmp_path / "chart.png" + image.write_bytes(PNG_BYTES) + binary = tmp_path / "archive.bin" + binary.write_bytes(b"\x00\x01") + + assert "cannot extract text content" in convert_file_to_text(image) + assert "Binary or unsupported file type" in convert_file_to_text(binary) + + +def test_extract_all_concatenates_files_with_headers(tmp_path: Path) -> None: + (tmp_path / "a.txt").write_text("alpha", encoding="utf-8") + (tmp_path / "nested").mkdir() + (tmp_path / "nested" / "b.txt").write_text("beta", encoding="utf-8") + + contents = extract_all_file_contents(tmp_path) + assert "=== FILE: a.txt ===" in contents + assert "=== FILE: b.txt ===" in contents + assert "alpha" in contents and "beta" in contents + + +def test_extract_all_truncates_an_oversized_file(tmp_path: Path) -> None: + (tmp_path / "big.txt").write_text("x" * 100, encoding="utf-8") + + contents = extract_all_file_contents(tmp_path, max_chars_per_file=10) + assert "Content truncated at 10 characters" in contents + assert "x" * 11 not in contents + + +def test_extract_all_exempts_sqlite_from_the_char_cap(tmp_path: Path) -> None: + path = tmp_path / "records.db" + connection = sqlite3.connect(path) + connection.execute("CREATE TABLE t (value TEXT)") + connection.execute("INSERT INTO t VALUES (?)", ("y" * 200,)) + connection.commit() + connection.close() + + contents = extract_all_file_contents(tmp_path, max_chars_per_file=10) + assert "truncated" not in contents + assert "y" * 200 in contents + + +def test_extract_all_returns_empty_for_a_missing_directory(tmp_path: Path) -> None: + assert extract_all_file_contents(tmp_path / "absent") == "" + + +@pytest.mark.parametrize( + "text, expected", + [ + ("Is there a plot of ages?", True), + ("Does it include a Q-Q diagram?", True), + ("Is the total correct?", False), + ], +) +def test_rubric_needs_vision_detects_visual_language(text: str, expected: bool) -> None: + assert rubric_needs_vision({"rubric": text, "criterion": []}) is expected + + +def test_rubric_needs_vision_reads_criteria_in_both_shapes() -> None: + assert rubric_needs_vision({"rubric": "", "criterion": ["a histogram is shown"]}) is True + assert rubric_needs_vision({"rubric": "", "criterion": "a heatmap is shown"}) is True + assert rubric_needs_vision({"rubric": "", "criterion": "a table is shown"}) is False + + +def test_collect_attachments_deduplicates_identical_images(tmp_path: Path) -> None: + (tmp_path / "a.png").write_bytes(PNG_BYTES) + (tmp_path / "b.png").write_bytes(PNG_BYTES) + (tmp_path / "c.png").write_bytes(OTHER_PNG_BYTES) + + attachments = collect_image_attachments(tmp_path) + assert len(attachments) == 2 + assert all(url.startswith("data:image/png;base64,") for _, url in attachments) + + +def test_collect_attachments_honours_the_cap(tmp_path: Path) -> None: + (tmp_path / "a.png").write_bytes(PNG_BYTES) + (tmp_path / "b.png").write_bytes(OTHER_PNG_BYTES) + + assert len(collect_image_attachments(tmp_path, cap=1)) == 1 + assert collect_image_attachments(tmp_path, cap=0) == [] + assert collect_image_attachments(tmp_path / "absent") == [] + + +def test_collect_attachments_reads_images_embedded_in_a_docx(tmp_path: Path) -> None: + docx_path = tmp_path / "report.docx" + with zipfile.ZipFile(docx_path, "w") as archive: + archive.writestr("word/media/image1.png", PNG_BYTES) + + attachments = collect_image_attachments(tmp_path) + assert len(attachments) == 1 + assert attachments[0][0] == "report.docx:word/media/image1.png" + + +def test_collect_attachments_skips_a_corrupt_docx(tmp_path: Path) -> None: + (tmp_path / "report.docx").write_bytes(b"not a zip") + + assert collect_image_attachments(tmp_path) == [] + + +def test_collect_attachments_reads_images_embedded_in_a_notebook(tmp_path: Path) -> None: + notebook = { + "cells": [ + { + "cell_type": "code", + "source": [], + "outputs": [{"data": {"image/png": base64.b64encode(PNG_BYTES).decode("ascii")}}], + } + ] + } + (tmp_path / "plots.ipynb").write_text(json.dumps(notebook), encoding="utf-8") + + attachments = collect_image_attachments(tmp_path) + assert len(attachments) == 1 + assert "cell-0-output-0:image/png" in attachments[0][0] + + +def test_collect_attachments_ignores_undecodable_notebook_images(tmp_path: Path) -> None: + notebook = {"cells": [{"cell_type": "code", "source": [], "outputs": [{"data": {"image/png": "!!!not base64"}}]}]} + (tmp_path / "plots.ipynb").write_text(json.dumps(notebook), encoding="utf-8") + + assert collect_image_attachments(tmp_path) == [] + + +def test_normalize_criteria_accepts_a_bare_string() -> None: + assert normalize_criteria({"criterion": "only one"}) == ["only one"] + assert normalize_criteria({}) == [] + + +def test_prompt_lists_every_criterion_and_the_expected_count() -> None: + prompt = build_rubric_prompt(RUBRIC, "=== FILE: r.txt ===\n1,108", vision_used=False) + + assert "Criterion 0: A count is given" in prompt + assert "Criterion 1: The count is 1,108" in prompt + assert "must have exactly 2 items" in prompt + assert "1,108" in prompt + assert "and the attached images" not in prompt + + +def test_prompt_mentions_images_only_when_they_are_attached() -> None: + assert "and the attached images" in build_rubric_prompt(RUBRIC, "", vision_used=True) + + +def test_user_content_is_a_plain_string_without_attachments() -> None: + assert build_user_content("prompt", []) == "prompt" + + +def test_user_content_interleaves_image_parts_with_their_names() -> None: + content = build_user_content("prompt", [("chart.png", "data:image/png;base64,AAA")]) + + assert content[0] == {"type": "text", "text": "prompt"} + assert content[1]["text"] == "\n## Attached Images (1 file)" + assert content[2] == {"type": "text", "text": "Image 1: chart.png"} + assert content[3] == {"type": "image_url", "image_url": {"url": "data:image/png;base64,AAA"}} + + +def test_user_content_pluralizes_multiple_images() -> None: + content = build_user_content("p", [("a.png", "data:1"), ("b.png", "data:2")]) + + assert content[1]["text"] == "\n## Attached Images (2 files)" + + +@pytest.mark.parametrize( + "content, expected_status", + [ + ('{"rubric_passed": true}', "direct_json"), + ('```json\n{"rubric_passed": true}\n```', "markdown_fence"), + ('Sure! {"rubric_passed": true} Hope that helps.', "first_last_brace"), + ], +) +def test_parse_judge_json_recovers_common_wrappings(content: str, expected_status: str) -> None: + parsed, status = parse_judge_json(content) + + assert parsed["rubric_passed"] is True + assert status == expected_status + + +def test_parse_judge_json_falls_back_to_a_regex_scan() -> None: + content = 'prelude { "criteria_results": [{"index": 0}], "rubric_passed": false } trailing }' + + parsed, status = parse_judge_json(content) + assert status == "regex_extract" + assert parsed["rubric_passed"] is False + + +def test_parse_judge_json_raises_when_nothing_is_recoverable() -> None: + with pytest.raises(ValueError, match="Could not extract JSON"): + parse_judge_json("no json here at all") + + +def test_rubric_scores_its_full_weight_only_when_it_passes() -> None: + parsed = { + "criteria_results": [ + {"index": 0, "passed": True, "reasoning": "r0", "evidence": "e0"}, + {"index": 1, "passed": True, "reasoning": "r1", "evidence": "e1"}, + ], + "rubric_passed": True, + "overall_reasoning": "all good", + } + + result = build_rubric_result(0, RUBRIC, parsed) + assert result["result"]["passed"] is True + assert result["result"]["score"] == 10 + assert result["result"]["criteria_passed"] == 2 + assert result["result"]["criteria_results"][1]["evidence"] == "e1" + + +def test_rubric_scores_zero_when_the_judge_fails_it() -> None: + parsed = { + "criteria_results": [{"index": 0, "passed": True}], + "rubric_passed": False, + "overall_reasoning": "second criterion missing", + } + + result = build_rubric_result(0, RUBRIC, parsed) + assert result["result"]["score"] == 0 + assert result["result"]["criteria_passed"] == 1 + # A criterion the judge omitted defaults to failed rather than raising. + assert result["result"]["criteria_results"][1]["passed"] is False + + +def test_rubric_result_survives_malformed_criteria_entries() -> None: + parsed = {"criteria_results": ["nonsense", {"passed": True}], "rubric_passed": True} + + result = build_rubric_result(0, RUBRIC, parsed) + assert result["result"]["criteria_results"][0]["passed"] is False + assert result["result"]["criteria_results"][1]["passed"] is True + + +def test_failed_rubric_result_zeroes_every_criterion() -> None: + result = build_failed_rubric_result(1, RUBRIC, "judge unavailable") + + assert result["index"] == 1 + assert result["result"]["passed"] is False + assert result["result"]["score"] == 0 + assert result["result"]["criteria_count"] == 2 + assert all(item["reasoning"] == "judge unavailable" for item in result["result"]["criteria_results"]) + + +def test_scorecard_normalizes_by_total_weight_not_rubric_count() -> None: + results = [ + {"index": 0, "weight": 10, "result": {"passed": True, "score": 10}}, + {"index": 1, "weight": 5, "result": {"passed": False, "score": 0}}, + {"index": 2, "weight": 5, "result": {"passed": False, "score": 0}}, + ] + + scorecard = build_scorecard(results) + assert scorecard["total_score"] == 10 + assert scorecard["max_score"] == 20 + assert scorecard["normalized_score"] == 0.5 + # pass_rate counts rubrics, so it differs from the weighted score. + assert scorecard["pass_rate"] == pytest.approx(1 / 3, abs=1e-4) + assert scorecard["passed_count"] == 1 + assert scorecard["total_count"] == 3 + + +def test_scorecard_of_no_rubrics_is_zero_not_a_division_error() -> None: + scorecard = build_scorecard([]) + + assert scorecard["normalized_score"] == 0.0 + assert scorecard["pass_rate"] == 0.0 + + +# --------------------------------------------------- office-format converters +# +# The optional readers (openpyxl, mammoth, pdfplumber, python-pptx) are declared +# in requirements.txt but are not guaranteed in every environment, so these +# exercise our adapter logic against stub modules: what we own is the call shape +# and the rendered layout, not the third-party parsing itself. + + +class SimpleNamespaceLike: + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + + +def _install_stub(monkeypatch: pytest.MonkeyPatch, name: str, module: object) -> None: + import sys + + monkeypatch.setitem(sys.modules, name, module) + + +def _hide_module(monkeypatch: pytest.MonkeyPatch, name: str) -> None: + """Make ``import name`` raise ImportError inside the converter.""" + import builtins + + real_import = builtins.__import__ + + def fake_import(module_name, *args, **kwargs): + if module_name == name or module_name.startswith(f"{name}."): + raise ImportError(f"No module named {module_name!r}") + return real_import(module_name, *args, **kwargs) + + monkeypatch.setattr(builtins, "__import__", fake_import) + + +def test_convert_renders_every_excel_sheet_as_csv(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + pandas = pytest.importorskip("pandas") + path = tmp_path / "book.xlsx" + path.write_bytes(b"") + + frames = { + "Summary": pandas.DataFrame({"count": [1108]}), + "Detail": pandas.DataFrame({"age": [39, 46]}), + } + monkeypatch.setattr(pandas, "ExcelFile", lambda _p: SimpleNamespaceLike(sheet_names=list(frames))) + monkeypatch.setattr(pandas, "read_excel", lambda _xl, sheet_name: frames[sheet_name]) + + rendered = convert_file_to_text(path) + assert "=== Sheet: Summary ===" in rendered + assert "1108" in rendered + assert "=== Sheet: Detail ===" in rendered + # to_csv(index=False): no unnamed index column. + assert "count\n1108" in rendered.replace("\r\n", "\n") + + +def test_convert_reports_an_unreadable_workbook(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + pandas = pytest.importorskip("pandas") + path = tmp_path / "book.xlsx" + path.write_bytes(b"") + + def boom(_p): + raise ValueError("not a zip file") + + monkeypatch.setattr(pandas, "ExcelFile", boom) + + assert "ERROR: Failed to read Excel" in convert_file_to_text(path) + + +def test_convert_reports_a_missing_excel_reader(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "book.xlsx" + path.write_bytes(b"") + _hide_module(monkeypatch, "pandas") + + assert "pandas/openpyxl not available" in convert_file_to_text(path) + + +def test_convert_renders_docx_as_markdown(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "report.docx" + path.write_bytes(b"") + + captured = {} + + def convert_to_markdown(handle, convert_image=None): + captured["convert_image"] = convert_image + return SimpleNamespaceLike(value="# Findings\n\n1,108 subjects") + + stub = SimpleNamespaceLike( + convert_to_markdown=convert_to_markdown, + images=SimpleNamespaceLike(img_element=lambda fn: ("img_element", fn)), + ) + _install_stub(monkeypatch, "mammoth", stub) + + rendered = convert_file_to_text(path) + assert rendered == "# Findings\n\n1,108 subjects" + # Embedded images are replaced by a placeholder rather than inlined. + placeholder = captured["convert_image"][1](SimpleNamespaceLike(content_type="image/png")) + assert placeholder == {"src": "embedded-image", "alt": "Embedded image: image/png"} + + +def test_convert_reports_a_missing_docx_reader(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "report.docx" + path.write_bytes(b"") + _hide_module(monkeypatch, "mammoth") + + assert "mammoth not available" in convert_file_to_text(path) + + +def test_convert_reports_an_unreadable_docx(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "report.docx" + path.write_bytes(b"") + + def boom(*_args, **_kwargs): + raise ValueError("corrupt") + + _install_stub( + monkeypatch, + "mammoth", + SimpleNamespaceLike(convert_to_markdown=boom, images=SimpleNamespaceLike(img_element=lambda fn: fn)), + ) + + assert "ERROR: Failed to read DOCX" in convert_file_to_text(path) + + +def test_convert_renders_pdf_pages_in_order(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "guidance.pdf" + path.write_bytes(b"") + + class Pdf: + pages = [ + SimpleNamespaceLike(extract_text=lambda layout=True: "Section 5.7"), + # A page with no extractable text must still produce a header. + SimpleNamespaceLike(extract_text=lambda layout=True: None), + ] + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + _install_stub(monkeypatch, "pdfplumber", SimpleNamespaceLike(open=lambda _p: Pdf())) + + rendered = convert_file_to_text(path) + assert "=== Page 1 ===\nSection 5.7" in rendered + assert "=== Page 2 ===\n" in rendered + + +def test_convert_reports_a_missing_pdf_reader(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "guidance.pdf" + path.write_bytes(b"") + _hide_module(monkeypatch, "pdfplumber") + + assert "pdfplumber not available" in convert_file_to_text(path) + + +def test_convert_reports_an_unreadable_pdf(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "guidance.pdf" + path.write_bytes(b"") + + def boom(_p): + raise ValueError("damaged") + + _install_stub(monkeypatch, "pdfplumber", SimpleNamespaceLike(open=boom)) + + assert "ERROR: Failed to read PDF" in convert_file_to_text(path) + + +def test_convert_renders_pptx_slide_text(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "deck.pptx" + path.write_bytes(b"") + + slide = SimpleNamespaceLike( + shapes=[SimpleNamespaceLike(text="Title"), SimpleNamespaceLike(text=""), SimpleNamespaceLike()] + ) + _install_stub( + monkeypatch, "pptx", SimpleNamespaceLike(Presentation=lambda _p: SimpleNamespaceLike(slides=[slide])) + ) + + rendered = convert_file_to_text(path) + assert "=== Slide 1 ===" in rendered + assert "Title" in rendered + + +def test_convert_reports_a_missing_pptx_reader(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "deck.pptx" + path.write_bytes(b"") + _hide_module(monkeypatch, "pptx") + + assert "python-pptx not available" in convert_file_to_text(path) + + +def test_convert_reports_an_unreadable_pptx(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + path = tmp_path / "deck.pptx" + path.write_bytes(b"") + + def boom(_p): + raise ValueError("corrupt") + + _install_stub(monkeypatch, "pptx", SimpleNamespaceLike(Presentation=boom)) + + assert "ERROR: Failed to read PowerPoint" in convert_file_to_text(path) + + +def test_sqlite_render_reports_a_table_it_cannot_query(tmp_path: Path) -> None: + path = tmp_path / "records.db" + connection = sqlite3.connect(path) + connection.execute("CREATE TABLE ok (id INTEGER)") + # A embedded double quote defeats the renderer's simple quoting, so this + # table fails to read. It must be reported inline, not abort the whole file. + connection.execute('CREATE TABLE "od""d" (id INTEGER)') + connection.commit() + connection.close() + + rendered = convert_file_to_text(path) + assert "=== Table: ok ===" in rendered + assert "[ERROR reading table" in rendered + + +def test_collect_attachments_skips_files_it_cannot_read(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + (tmp_path / "chart.png").write_bytes(PNG_BYTES) + real_read_bytes = Path.read_bytes + + def failing_read_bytes(self): + if self.suffix == ".png": + raise OSError("permission denied") + return real_read_bytes(self) + + monkeypatch.setattr(Path, "read_bytes", failing_read_bytes) + + assert collect_image_attachments(tmp_path) == [] + + +def test_collect_attachments_ignores_unsupported_image_extensions(tmp_path: Path) -> None: + (tmp_path / "diagram.svg").write_bytes(b"") + + assert collect_image_attachments(tmp_path) == [] + + +def test_collect_attachments_skips_an_unreadable_notebook(tmp_path: Path) -> None: + (tmp_path / "plots.ipynb").write_text("{not json", encoding="utf-8") + + assert collect_image_attachments(tmp_path) == [] + + +def test_collect_attachments_accepts_a_chunked_notebook_image(tmp_path: Path) -> None: + encoded = base64.b64encode(PNG_BYTES).decode("ascii") + notebook = { + "cells": [ + { + "cell_type": "code", + "source": [], + # nbformat splits long base64 payloads across a list of lines. + "outputs": [{"data": {"image/png": [encoded[:10], encoded[10:]]}}, {"data": "not-a-dict"}], + } + ] + } + (tmp_path / "plots.ipynb").write_text(json.dumps(notebook), encoding="utf-8") + + assert len(collect_image_attachments(tmp_path)) == 1 diff --git a/resources_servers/job_bench/tests/test_prepare.py b/resources_servers/job_bench/tests/test_prepare.py new file mode 100644 index 00000000000..3ed36c58bd7 --- /dev/null +++ b/resources_servers/job_bench/tests/test_prepare.py @@ -0,0 +1,195 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +import json +from pathlib import Path + +import pytest +from pytest import MonkeyPatch + +from resources_servers.job_bench import prepare as prepare_module +from resources_servers.job_bench.prepare import build_prompt, build_row, prepare, write_jsonl +from resources_servers.job_bench.task_store import discover_tasks + + +def _task(cache_dir: Path, task_id: str): + return discover_tasks(cache_dir, "main")[task_id] + + +def test_prompt_points_the_agent_at_the_sandbox_workspace(cache_dir: Path, task_id: str) -> None: + prompt = build_prompt(_task(cache_dir, task_id), include_search_files=False) + + assert "/workspace/task_folder" in prompt + assert "/workspace/output" in prompt + assert "TASK_INSTRUCTIONS.txt" in prompt + # Upstream withholds the search corpus, so it must not be advertised. + assert "files_required_to_search" not in prompt + + +def test_prompt_advertises_search_files_only_when_they_are_mounted(cache_dir: Path, task_id: str) -> None: + prompt = build_prompt(_task(cache_dir, task_id), include_search_files=True) + + assert "/workspace/files_required_to_search" in prompt + + +def test_row_carries_the_task_id_but_never_the_rubrics(cache_dir: Path, task_id: str) -> None: + row = build_row(_task(cache_dir, task_id), include_search_files=False) + + assert row["task_id"] == task_id + assert row["responses_create_params"]["input"][0]["role"] == "user" + metadata = row["verifier_metadata"] + assert metadata["task_id"] == task_id + assert metadata["profession"] == "biostatisticians" + assert metadata["num_rubrics"] == 2 + assert metadata["max_score"] == 15 + assert len(metadata["rubrics_sha256"]) == 64 + # The answer key stays on the control plane. + assert "rubric" not in json.dumps(row).lower().replace("num_rubrics", "").replace("rubrics_sha256", "") + + +def test_write_jsonl_emits_one_object_per_line(tmp_path: Path) -> None: + path = tmp_path / "nested" / "out.jsonl" + + write_jsonl([{"a": 1}, {"a": 2}], path) + + lines = path.read_text(encoding="utf-8").splitlines() + assert [json.loads(line)["a"] for line in lines] == [1, 2] + + +def test_prepare_writes_the_benchmark_and_example_files( + monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path, task_id: str +) -> None: + monkeypatch.setitem(prepare_module.EXPECTED_TASK_COUNTS, "main", 1) + benchmark_dir = tmp_path / "benchmarks" + example_path = tmp_path / "example.jsonl" + monkeypatch.setattr(prepare_module, "PACKAGE_DIR", tmp_path) + (tmp_path / "data").mkdir(exist_ok=True) + + returned_cache, jsonl_path = prepare( + split="main", cache_dir=cache_dir, benchmark_dir=benchmark_dir, download=False + ) + + assert returned_cache == cache_dir + assert jsonl_path == benchmark_dir / "job_bench_main_benchmark.jsonl" + assert json.loads(jsonl_path.read_text().splitlines()[0])["task_id"] == task_id + assert (tmp_path / "data" / "example.jsonl").is_file() + assert not example_path.exists() + + +def test_prepare_can_skip_the_example_file(monkeypatch: MonkeyPatch, cache_dir: Path, tmp_path: Path) -> None: + monkeypatch.setitem(prepare_module.EXPECTED_TASK_COUNTS, "main", 1) + monkeypatch.setattr(prepare_module, "PACKAGE_DIR", tmp_path) + + prepare(split="main", cache_dir=cache_dir, benchmark_dir=tmp_path / "b", download=False, write_example=False) + + assert not (tmp_path / "data" / "example.jsonl").exists() + + +def test_prepare_rejects_an_unknown_split(cache_dir: Path, tmp_path: Path) -> None: + with pytest.raises(ValueError, match="Unknown JobBench split"): + prepare(split="hard", cache_dir=cache_dir, benchmark_dir=tmp_path, download=False) + + +def test_prepare_fails_loudly_on_a_short_cache(cache_dir: Path, tmp_path: Path) -> None: + # The fixture holds one task; the real main split holds 65. + with pytest.raises(RuntimeError, match="expected 65"): + prepare(split="main", cache_dir=cache_dir, benchmark_dir=tmp_path, download=False) + + +def test_download_is_skipped_when_the_split_is_already_present(monkeypatch: MonkeyPatch, cache_dir: Path) -> None: + def fail(*args, **kwargs): + raise AssertionError("snapshot_download should not run for a populated cache") + + monkeypatch.setattr("huggingface_hub.snapshot_download", fail) + + prepare_module.download_dataset(cache_dir, splits=("main",), force=False) + + +def test_download_moves_each_upstream_split_into_its_cache_directory(monkeypatch: MonkeyPatch, tmp_path: Path) -> None: + cache_dir = tmp_path / "tasks" + staging = cache_dir.parent / "_hf_snapshot" + captured = {} + + def fake_snapshot_download(repo_id, *, repo_type, allow_patterns, local_dir): + captured.update(repo_id=repo_id, repo_type=repo_type, allow_patterns=allow_patterns) + # Upstream names the main split "dataset"; setup.sh renames it to "main". + (Path(local_dir) / "dataset" / "lawyers" / "task1").mkdir(parents=True) + (Path(local_dir) / "dataset" / "lawyers" / "task1" / "RUBRICS.json").write_text("{}") + + monkeypatch.setattr("huggingface_hub.snapshot_download", fake_snapshot_download) + + prepare_module.download_dataset(cache_dir, splits=("main",), force=False) + + assert captured["repo_id"] == "JobBench/job-bench" + assert captured["repo_type"] == "dataset" + assert captured["allow_patterns"] == ["dataset/**"] + assert (cache_dir / "main" / "lawyers" / "task1" / "RUBRICS.json").is_file() + assert not staging.joinpath("dataset").exists() + + +def test_download_uses_the_easy_split_upstream_directory(monkeypatch: MonkeyPatch, tmp_path: Path) -> None: + cache_dir = tmp_path / "tasks" + captured = {} + + def fake_snapshot_download(repo_id, *, repo_type, allow_patterns, local_dir): + captured["allow_patterns"] = allow_patterns + (Path(local_dir) / "dataset_easy" / "lawyers").mkdir(parents=True) + + monkeypatch.setattr("huggingface_hub.snapshot_download", fake_snapshot_download) + + prepare_module.download_dataset(cache_dir, splits=("easy",), force=False) + + assert captured["allow_patterns"] == ["dataset_easy/**"] + assert (cache_dir / "easy" / "lawyers").is_dir() + + +def test_download_force_replaces_an_existing_split(monkeypatch: MonkeyPatch, cache_dir: Path) -> None: + stale_marker = cache_dir / "main" / "biostatisticians" / "task1" / "RUBRICS.json" + assert stale_marker.is_file() + + def fake_snapshot_download(repo_id, *, repo_type, allow_patterns, local_dir): + (Path(local_dir) / "dataset" / "lawyers").mkdir(parents=True) + + monkeypatch.setattr("huggingface_hub.snapshot_download", fake_snapshot_download) + + prepare_module.download_dataset(cache_dir, splits=("main",), force=True) + + assert not stale_marker.exists() + assert (cache_dir / "main" / "lawyers").is_dir() + + +def test_download_fails_when_the_snapshot_lacks_the_split(monkeypatch: MonkeyPatch, tmp_path: Path) -> None: + monkeypatch.setattr("huggingface_hub.snapshot_download", lambda *a, **k: None) + + with pytest.raises(RuntimeError, match="Expected .* in the Hugging Face snapshot"): + prepare_module.download_dataset(tmp_path / "tasks", splits=("main",), force=False) + + +def test_cli_forwards_its_arguments_to_prepare(monkeypatch: MonkeyPatch, tmp_path: Path) -> None: + captured = {} + monkeypatch.setattr(prepare_module, "prepare", lambda **kwargs: captured.update(kwargs) or (tmp_path, tmp_path)) + monkeypatch.setattr( + "sys.argv", + [ + "prepare.py", + "--split", + "easy", + "--cache-dir", + str(tmp_path / "c"), + "--benchmark-dir", + str(tmp_path / "b"), + "--include-search-files", + "--no-download", + "--force", + "--no-example", + ], + ) + + prepare_module.main() + + assert captured["split"] == "easy" + assert captured["cache_dir"] == tmp_path / "c" + assert captured["include_search_files"] is True + assert captured["download"] is False + assert captured["force"] is True + assert captured["write_example"] is False diff --git a/resources_servers/job_bench/tests/test_task_store.py b/resources_servers/job_bench/tests/test_task_store.py new file mode 100644 index 00000000000..1f959603805 --- /dev/null +++ b/resources_servers/job_bench/tests/test_task_store.py @@ -0,0 +1,129 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +import json +from pathlib import Path + +import pytest + +from resources_servers.job_bench.task_store import ( + JobBenchTaskError, + JobBenchTaskStore, + build_task_id, + discover_tasks, + load_rubrics, +) + + +def test_discover_indexes_task_by_split_profession_and_task(cache_dir: Path, task_id: str) -> None: + tasks = discover_tasks(cache_dir, "main") + + assert list(tasks) == [task_id] + task = tasks[task_id] + assert task.split == "main" + assert task.profession == "biostatisticians" + assert task.task_name == "task1" + assert task.instructions == "Analyze the cohort.\n" + + +def test_task_exposes_rubric_weights_and_a_stable_digest(cache_dir: Path, task_id: str) -> None: + task = discover_tasks(cache_dir, "main")[task_id] + + assert len(task.rubrics) == 2 + assert task.max_score == 15 + assert task.rubrics_sha256 == task.rubrics_sha256 + assert len(task.rubrics_sha256) == 64 + + +def test_label_is_sandbox_metadata_safe(cache_dir: Path, task_id: str) -> None: + task = discover_tasks(cache_dir, "main")[task_id] + + # Slashes are not valid in a provider label; they must be replaced, not dropped. + assert task.label == "main-biostatisticians-task1" + assert len(task.label) <= 63 + + +def test_store_rejects_a_short_cache(cache_dir: Path) -> None: + with pytest.raises(JobBenchTaskError, match="expected 2"): + JobBenchTaskStore(cache_dir, "main", expected_task_count=2) + + +def test_store_rejects_an_unknown_split(cache_dir: Path) -> None: + with pytest.raises(JobBenchTaskError, match="Unknown JobBench split"): + JobBenchTaskStore(cache_dir, "hard", expected_task_count=1) + + +def test_store_reports_a_missing_split_directory(tmp_path: Path) -> None: + with pytest.raises(JobBenchTaskError, match="not found"): + JobBenchTaskStore(tmp_path, "main", expected_task_count=1) + + +def test_store_get_reports_unknown_task(cache_dir: Path, task_id: str) -> None: + store = JobBenchTaskStore(cache_dir, "main", expected_task_count=1) + + assert task_id in store + assert len(store) == 1 + assert [task.task_id for task in store.values()] == [task_id] + with pytest.raises(JobBenchTaskError, match="Unknown JobBench task"): + store.get("main/lawyers/task9") + + +def test_discover_rejects_a_task_missing_rubrics(cache_dir: Path, task_id: str) -> None: + (cache_dir / "main" / "biostatisticians" / "task1" / "RUBRICS.json").unlink() + + with pytest.raises(JobBenchTaskError, match="missing RUBRICS.json"): + discover_tasks(cache_dir, "main") + + +def test_discover_rejects_a_task_missing_instructions(cache_dir: Path) -> None: + (cache_dir / "main" / "biostatisticians" / "task1" / "task_folder" / "TASK_INSTRUCTIONS.txt").unlink() + + with pytest.raises(JobBenchTaskError, match="TASK_INSTRUCTIONS.txt"): + discover_tasks(cache_dir, "main") + + +def test_discover_ignores_directories_that_are_not_tasks(cache_dir: Path, task_id: str) -> None: + (cache_dir / "main" / "biostatisticians" / "notes").mkdir() + + assert list(discover_tasks(cache_dir, "main")) == [task_id] + + +def test_load_rubrics_accepts_the_alternate_upstream_key(tmp_path: Path) -> None: + path = tmp_path / "RUBRICS.json" + path.write_text(json.dumps({"evaluation_rubrics": [{"rubric": "r", "weight": 3, "criterion": ["c"]}]})) + + assert load_rubrics(path)[0]["weight"] == 3 + + +@pytest.mark.parametrize( + "payload, message", + [ + ({"rubrics": []}, "non-empty"), + ({"other": [1]}, "non-empty"), + ({"rubrics": ["not-an-object"]}, "not an object"), + ({"rubrics": [{"rubric": "r", "weight": "ten"}]}, "non-numeric weight"), + ], +) +def test_load_rubrics_rejects_malformed_payloads(tmp_path: Path, payload: dict, message: str) -> None: + path = tmp_path / "RUBRICS.json" + path.write_text(json.dumps(payload)) + + with pytest.raises(JobBenchTaskError, match=message): + load_rubrics(path) + + +def test_load_rubrics_reports_invalid_json(tmp_path: Path) -> None: + path = tmp_path / "RUBRICS.json" + path.write_text("{not json") + + with pytest.raises(JobBenchTaskError, match="Malformed rubrics JSON"): + load_rubrics(path) + + +def test_load_rubrics_reports_an_unreadable_file(tmp_path: Path) -> None: + with pytest.raises(JobBenchTaskError, match="Cannot read rubrics"): + load_rubrics(tmp_path / "absent.json") + + +def test_build_task_id_joins_the_three_components() -> None: + assert build_task_id("easy", "lawyers", "task2") == "easy/lawyers/task2" From aa47491dd0f7e2cee72ee9d7a849ea76da1840d4 Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Thu, 10 Sep 2026 17:00:34 -0700 Subject: [PATCH 02/29] init: rebenchv2, scale-swe Signed-off-by: Sugam Devare --- resources_servers/scale_swe/.gitignore | 2 + resources_servers/scale_swe/README.md | 86 + resources_servers/scale_swe/__init__.py | 0 .../scale_swe/aggregate_golden_patch.py | 136 + resources_servers/scale_swe/app.py | 275 + .../scale_swe/apply_golden_patch.py | 165 + resources_servers/scale_swe/client.py | 52 + .../scale_swe/configs/scale_swe.yaml | 74 + .../scale_swe/data/supported_instance_ids.txt | 17696 ++++++++++++ .../scale_swe/diagnose_failures.py | 234 + resources_servers/scale_swe/requirements.txt | 1 + resources_servers/scale_swe/tests/__init__.py | 0 resources_servers/scale_swe/tests/test_app.py | 386 + resources_servers/scale_swe/verification.py | 275 + resources_servers/swe_rebench/.gitignore | 2 + resources_servers/swe_rebench/README.md | 81 + resources_servers/swe_rebench/__init__.py | 0 .../swe_rebench/aggregate_golden_patch.py | 136 + resources_servers/swe_rebench/app.py | 325 + .../swe_rebench/apply_golden_patch.py | 165 + resources_servers/swe_rebench/client.py | 52 + .../swe_rebench/configs/swe_rebench.yaml | 79 + .../data/supported_instance_ids.txt | 22684 ++++++++++++++++ .../swe_rebench/diagnose_failures.py | 234 + resources_servers/swe_rebench/log_parsers.py | 142 + .../swe_rebench/requirements.txt | 3 + .../swe_rebench/tests/__init__.py | 0 .../swe_rebench/tests/test_app.py | 559 + resources_servers/swe_rebench/verification.py | 276 + 29 files changed, 44120 insertions(+) create mode 100644 resources_servers/scale_swe/.gitignore create mode 100644 resources_servers/scale_swe/README.md create mode 100644 resources_servers/scale_swe/__init__.py create mode 100644 resources_servers/scale_swe/aggregate_golden_patch.py create mode 100644 resources_servers/scale_swe/app.py create mode 100644 resources_servers/scale_swe/apply_golden_patch.py create mode 100644 resources_servers/scale_swe/client.py create mode 100644 resources_servers/scale_swe/configs/scale_swe.yaml create mode 100644 resources_servers/scale_swe/data/supported_instance_ids.txt create mode 100644 resources_servers/scale_swe/diagnose_failures.py create mode 100644 resources_servers/scale_swe/requirements.txt create mode 100644 resources_servers/scale_swe/tests/__init__.py create mode 100644 resources_servers/scale_swe/tests/test_app.py create mode 100644 resources_servers/scale_swe/verification.py create mode 100644 resources_servers/swe_rebench/.gitignore create mode 100644 resources_servers/swe_rebench/README.md create mode 100644 resources_servers/swe_rebench/__init__.py create mode 100644 resources_servers/swe_rebench/aggregate_golden_patch.py create mode 100644 resources_servers/swe_rebench/app.py create mode 100644 resources_servers/swe_rebench/apply_golden_patch.py create mode 100644 resources_servers/swe_rebench/client.py create mode 100644 resources_servers/swe_rebench/configs/swe_rebench.yaml create mode 100644 resources_servers/swe_rebench/data/supported_instance_ids.txt create mode 100644 resources_servers/swe_rebench/diagnose_failures.py create mode 100644 resources_servers/swe_rebench/log_parsers.py create mode 100644 resources_servers/swe_rebench/requirements.txt create mode 100644 resources_servers/swe_rebench/tests/__init__.py create mode 100644 resources_servers/swe_rebench/tests/test_app.py create mode 100644 resources_servers/swe_rebench/verification.py diff --git a/resources_servers/scale_swe/.gitignore b/resources_servers/scale_swe/.gitignore new file mode 100644 index 00000000000..c39f6d3d27c --- /dev/null +++ b/resources_servers/scale_swe/.gitignore @@ -0,0 +1,2 @@ +# This is where verification logs are stored locally +logs diff --git a/resources_servers/scale_swe/README.md b/resources_servers/scale_swe/README.md new file mode 100644 index 00000000000..602cfe9abff --- /dev/null +++ b/resources_servers/scale_swe/README.md @@ -0,0 +1,86 @@ +# Scale-SWE resources server + +Verification for [AweAI-Team/Scale-SWE](https://huggingface.co/datasets/AweAI-Team/Scale-SWE): +20,181 software-engineering tasks, entirely Python. + +Unlike the SWE-rebench server, there is exactly one test runner here (pytest), so there is no +per-row log-parser dispatch. Each row ships its own prebuilt image (`aweaiteam/scaleswe:...`), +an explicit `workdir`, and a `pre_commands` string that performs the checkout of +`parent_commit` and scrubs the repo's git history so the fix commit is unreachable. + +Sandboxes come from `nemo_gym.sandbox`, so the same server runs on OpenSandbox or any other +configured provider. + +## The failing tests + +A row supplies the tests that must go from failing to passing one of two ways, and 61% of rows +carry both: + +- `f2p_script` (92% of rows): a literal pytest file, uploaded to `/tmp` and copied into the + checkout as `test_fail_to_pass.py` (the name the dataset's own `FAIL_TO_PASS` ids expect). It + cannot be written into the repo before `pre_commands` runs, because `pre_commands` includes + `git clean -fd`, which would delete it. +- `f2p_patch` (69% of rows): a diff that adds the tests directly into the existing test tree. + +pytest is pointed at the **unique test files** named by `FAIL_TO_PASS ∪ PASS_TO_PASS`, not at +every individual node id — a row can carry hundreds of ids across up to ~69 files, and grading +by id afterwards from the collected output gives the same verdict without risking a pathological +command line. + +## Grading + +An instance resolves only when **every** `FAIL_TO_PASS` and `PASS_TO_PASS` node id is observed +as `PASSED` in the pytest output. A node id absent from the output counts as not passing — +treating absent as success is the standard way a broken test command (or a collection error) +scores as a resolved instance. + +`FAIL_TO_PASS` / `PASS_TO_PASS` arrive as JSON-encoded strings in this dataset, not lists; see +`as_id_list`. + +The graded region of the log is delimited by markers, so setup-time noise (pip installs, +`pre_commands` output) never reaches the pytest-output parser. + +## Prepare the data + +```bash +# The whole set, or a bounded trial: +SCALE_SWE_LIMIT=200 python benchmarks/scale_swe/prepare.py +``` + +`prepare.py` writes the full 20,181-row set, unfiltered. `data/supported_instance_ids.txt` is a +separate artifact for training use: the 17,696 instances (of 20,181) whose golden patch resolved +in all three passes of a full-set 3x sweep (see Golden-patch validation below). The other 2,485 +are excluded from that list because none can be scored either way: 1,671 never resolve, 709 never +produced a verdict (image pull / setup failures, not row failures), and 105 resolve +inconsistently across passes. + +## Golden-patch validation + +Grades each task with the dataset's own patch, which measures the dataset rather than a model. +A row whose golden patch does not resolve cannot be used for evaluation or training. + +```bash +gym env start \ + --config resources_servers/scale_swe/configs/scale_swe.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml + +python resources_servers/scale_swe/apply_golden_patch.py \ + +benchmark_jsonl=benchmarks/scale_swe/data/scale_swe_benchmark.jsonl \ + +limit=40 +concurrency=8 +``` + +It prints a resolved rate overall and per language (this set is 100% Python, so that breakdown +is a single row), and writes one row per task. `diagnose_failures.py` separates environment +failures (OOM, disk, network, timeout, no-verdict, zero-tests-collected) from genuine row +failures — see `resources_servers/swe_rebench/diagnose_failures.py` for the shape of evidence +this looks for and why each cause is only reported on direct signal in the captured output, not +inferred from the fact that a task failed. + +`aggregate_golden_patch.py` joins repeated golden-patch passes (e.g. a 3x sweep) into +supported / flaky / broken / inconclusive buckets, keeping an infra fault (no verdict) separate +from a genuinely nondeterministic test so neither silently corrupts the other's label. + +## Running an agent + +`benchmarks/scale_swe/opencode.yaml` wires this server to the opencode sandboxed agent, in the +same shape as the swebench verified/pro/multilingual and swe_rebench benchmarks. diff --git a/resources_servers/scale_swe/__init__.py b/resources_servers/scale_swe/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/scale_swe/aggregate_golden_patch.py b/resources_servers/scale_swe/aggregate_golden_patch.py new file mode 100644 index 00000000000..444e44266d3 --- /dev/null +++ b/resources_servers/scale_swe/aggregate_golden_patch.py @@ -0,0 +1,136 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Join repeated golden-patch passes into the set of rows that are actually usable. + +A row is SUPPORTED when its golden patch resolved in every pass. That is the point of +repeating: a row that resolves only sometimes has a nondeterministic test, and its reward is +noise whether it is used for evaluation or for training. + +The one distinction that matters, and the reason this is not a single boolean: a pass can fail +to produce a verdict at all (image pull, timeout, provider fault). That is evidence about the +infrastructure, not about the row. Collapsing the two would discard good tasks for an unrelated +hiccup, so incomplete passes are counted separately and those rows are reported as needing more +evidence rather than as broken. + + python resources_servers/scale_swe/aggregate_golden_patch.py \ + +runs=results/scale_swe_golden_patch_full \ + +output_jsonl=results/scale_swe_supported.jsonl +""" + +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + +from nemo_gym.global_config import get_global_config_dict + + +def _rows(path: Path): + with path.open(encoding="utf-8") as handle: + for line in handle: + line = line.strip() + if line: + try: + yield json.loads(line) + except json.JSONDecodeError: + continue + + +def classify(observations: list[dict[str, Any]], expected_passes: int) -> str: + """Bucket one row from its per-pass observations.""" + completed = [o for o in observations if o.get("evaluation_completed")] + resolved = sum(1 for o in completed if o.get("resolved")) + + if len(completed) < expected_passes: + # Not enough verdicts to judge the row. Distinguished from a genuine failure so an + # image-pull fault does not quietly delete a usable task. + return "inconclusive" + if resolved == len(completed): + return "supported" + if resolved == 0: + return "broken" + return "flaky" + + +def main() -> None: + config = get_global_config_dict() + runs_dir = Path(config["runs"]) + output_fpath = Path(config.get("output_jsonl") or "results/scale_swe_supported.jsonl") + + pass_files = sorted(p for p in runs_dir.glob("*.jsonl") if p.is_file()) + if not pass_files: + raise SystemExit(f"no pass jsonl files under {runs_dir}") + + by_instance: dict[str, list[dict[str, Any]]] = defaultdict(list) + language: dict[str, str] = {} + for pass_file in pass_files: + for row in _rows(pass_file): + instance_id = row.get("instance_id") + if not instance_id or instance_id == "?": + continue + by_instance[instance_id].append(row) + if row.get("language"): + language[instance_id] = row["language"] + + expected = len(pass_files) + buckets: Counter[str] = Counter() + per_language: dict[str, Counter[str]] = defaultdict(Counter) + + output_fpath.parent.mkdir(parents=True, exist_ok=True) + with output_fpath.open("w", encoding="utf-8") as out: + for instance_id, observations in sorted(by_instance.items()): + verdict = classify(observations, expected) + buckets[verdict] += 1 + per_language[language.get(instance_id, "unknown")][verdict] += 1 + out.write( + json.dumps( + { + "instance_id": instance_id, + "language": language.get(instance_id, ""), + "verdict": verdict, + "passes_observed": len(observations), + "passes_completed": sum(1 for o in observations if o.get("evaluation_completed")), + "passes_resolved": sum(1 for o in observations if o.get("resolved")), + "expected_passes": expected, + } + ) + + "\n" + ) + + total = sum(buckets.values()) + print(f"golden-patch aggregation over {total} row(s) from {expected} pass(es)\n") + for verdict, description in ( + ("supported", "resolved in every pass - usable"), + ("flaky", "resolved in some passes only - nondeterministic test"), + ("broken", "never resolved - golden patch does not work"), + ("inconclusive", "too few verdicts - re-run before judging"), + ): + count = buckets.get(verdict, 0) + print(f" {verdict:<13} {count:>6} ({100 * count / max(total, 1):5.1f}%) {description}") + + print("\n by language (supported / total):") + for lang, counts in sorted(per_language.items(), key=lambda kv: -sum(kv[1].values())): + rows_total = sum(counts.values()) + supported = counts.get("supported", 0) + print( + f" {lang:<10} {supported:>5} / {rows_total:<6} ({100 * supported / rows_total:5.1f}%)" + f" flaky={counts.get('flaky', 0)} broken={counts.get('broken', 0)}" + f" inconclusive={counts.get('inconclusive', 0)}" + ) + print(f"\nper-row verdicts: {output_fpath}") + + +if __name__ == "__main__": + main() diff --git a/resources_servers/scale_swe/app.py b/resources_servers/scale_swe/app.py new file mode 100644 index 00000000000..b10242f064e --- /dev/null +++ b/resources_servers/scale_swe/app.py @@ -0,0 +1,275 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Resources server for AweAI-Team/Scale-SWE. + +Scale-SWE is 20,181 rows, entirely Python. Each row ships its own prebuilt image +(``image_url``), an explicit ``workdir``, and a ``pre_commands`` string that checks out +``parent_commit`` and scrubs git history so the fix commit is unreachable. Unlike SWE-rebench, +there is a single test runner (pytest) for the whole set, so no parser dispatch is needed. + +The failing tests arrive as a literal test file (``f2p_script``, 92% of rows), a patch that adds +them (``f2p_patch``, 69%), or both. Verification: run ``pre_commands``, apply the candidate +patch and whichever of f2p_patch/f2p_script the row carries, run pytest against the named test +files, grade FAIL_TO_PASS/PASS_TO_PASS from the output. + +Set ``is_verifying_golden_patch: true`` to grade the dataset's own patch instead of an agent's, +the dataset-health check: a row whose golden patch does not resolve is a broken row. +""" + +import sys +from pathlib import Path +from time import time +from traceback import format_exc +from typing import Any + +from fastapi import Request +from pydantic import BaseModel, ConfigDict + +from nemo_gym.base_resources_server import ( + BaseResourcesServerConfig, + BaseSeedSessionRequest, + BaseSeedSessionResponse, + BaseVerifyRequest, + BaseVerifyResponse, + SimpleResourcesServer, +) +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.sandbox import AsyncSandbox, SandboxResources, SandboxSpec +from nemo_gym.sandbox.config import resolve_provider_config, resolve_provider_metadata +from nemo_gym.sandbox.utils import cpu_cap_env +from nemo_gym.server_utils import SESSION_ID_KEY, is_nemo_gym_fastapi_entrypoint +from resources_servers.scale_swe.verification import ( + VerificationInputs, + VerificationResult, + as_id_list, + run_verification, + verification_files, +) + + +class ScaleSWEResourcesServerConfig(BaseResourcesServerConfig): + is_verifying_golden_patch: bool = False + evaluation_timeout: int | None = 1200 + # A verdict-less run is retried on a fresh sandbox: an image pull or a flaky provider start + # is not evidence about the patch. + inconclusive_verification_retries: int = 1 + sandbox_provider: str + sandbox_config: dict[str, Any] + + +class ScaleSWEInstanceRequest(BaseModel): + """One row of AweAI-Team/Scale-SWE.""" + + model_config = ConfigDict(extra="allow") + + instance_id: str + repo: str = "" + language: str = "python" + workdir: str + image_url: str + patch: str = "" + pre_commands: str = "" + problem_statement: str = "" + f2p_patch: str = "" + f2p_script: str = "" + # Upstream spells these in caps and JSON-encodes the list; keep both as-received so a row + # round-trips unchanged. + FAIL_TO_PASS: str | list[str] = [] + PASS_TO_PASS: str | list[str] = [] + + +class ScaleSWESeedSessionRequest(ScaleSWEInstanceRequest, BaseSeedSessionRequest): + sandbox_spec: dict[str, Any] | None = None + + +class ScaleSWESeedSessionResponse(BaseSeedSessionResponse): + sandbox_handle: str + + +class ScaleSWEVerifyRequest(ScaleSWEInstanceRequest, BaseVerifyRequest): + pass + + +class ScaleSWEVerifyResponse(BaseVerifyResponse): + evaluation_completed: bool + resolved: bool + patch_applied: bool + instance_id: str + language: str + test_results: dict[str, Any] | None + test_output: str + error: str | None + eval_sandbox_start_time_taken: float + patch_verification_time_taken: float + + +class ScaleSWEResourcesServer(SimpleResourcesServer): + config: ScaleSWEResourcesServerConfig + + def model_post_init(self, context: Any, /) -> None: + super().model_post_init(context) + self._session_id_to_sandbox: dict[str, AsyncSandbox] = {} + + def _inputs(self, body: ScaleSWEInstanceRequest, patch: str) -> VerificationInputs: + return VerificationInputs( + instance_id=body.instance_id, + workdir=body.workdir, + patch=patch, + pre_commands=body.pre_commands, + f2p_patch=body.f2p_patch, + f2p_script=body.f2p_script, + fail_to_pass=as_id_list(body.FAIL_TO_PASS), + pass_to_pass=as_id_list(body.PASS_TO_PASS), + ) + + async def _create_sandbox( + self, body: ScaleSWEInstanceRequest, files: dict[str, str] | None = None + ) -> AsyncSandbox: + global_config_dict = get_global_config_dict() + provider_config = resolve_provider_config(self.config.sandbox_provider, global_config_dict) + provider_metadata = resolve_provider_metadata(self.config.sandbox_provider, global_config_dict) + + # Cap pytest's own parallelism (xdist, if a row's suite uses it) to the CPU limit. A + # container sees the HOST core count, not the cgroup quota, so an unconstrained worker + # count fans out against a small quota and CFS-throttles. Lower stakes here than the + # compiled-language sets, since plain pytest is single-process by default, but cheap + # insurance for the rows that do use xdist or multiprocessing test runners. + sandbox_resources = SandboxResources.from_mapping(self.config.sandbox_config.get("resources", {})) + env = dict(self.config.sandbox_config.get("env", {})) + if self.config.sandbox_config.get("derive_cpu_env", True): + env = cpu_cap_env(sandbox_resources.cpu) | env + + spec = SandboxSpec( + # The row names its own image; there is no repository template to apply. + image=body.image_url, + ttl_s=self.config.sandbox_config.get("ttl_s"), + ready_timeout_s=self.config.sandbox_config.get("ready_timeout_s"), + workdir=body.workdir, + env=env, + files=files or {}, + metadata=provider_metadata + | self.config.sandbox_config.get("metadata", {}) + | { + "nemo_gym_agent": self.config.name, + "instance_id": body.instance_id[:63], + }, + resources=sandbox_resources, + provider_options=self.config.sandbox_config.get("provider_options", {}), + ) + sandbox = AsyncSandbox(provider_config) + await sandbox.start(spec) + return sandbox + + async def _stop_sandbox(self, sandbox: AsyncSandbox | None) -> None: + if sandbox is None: + return + try: + await sandbox.stop() + except Exception: + print("Failed to stop Scale-SWE sandbox", format_exc(), file=sys.stderr) + + async def seed_session(self, request: Request, body: ScaleSWESeedSessionRequest) -> ScaleSWESeedSessionResponse: + """Start the instance's image so an agent can work in it.""" + session_id = request.session[SESSION_ID_KEY] + await self._stop_sandbox(self._session_id_to_sandbox.pop(session_id, None)) + sandbox = await self._create_sandbox(body) + self._session_id_to_sandbox[session_id] = sandbox + return ScaleSWESeedSessionResponse(sandbox_handle=str(sandbox.sandbox_id)) + + async def verify(self, request: Request, body: ScaleSWEVerifyRequest) -> ScaleSWEVerifyResponse: + if self.config.is_verifying_golden_patch: + patch = body.patch + else: + patch = str(getattr(body, "model_patch", "") or "") + + inputs = self._inputs(body, patch) + log_dir = Path(__file__).parent / "logs" / body.instance_id + + files = verification_files(inputs) + attempts = 1 + max(self.config.inconclusive_verification_retries, 0) + start_time_taken = 0.0 + verification_time_taken = 0.0 + result = VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output="", + error="unattempted", + ) + for attempt in range(1, attempts + 1): + sandbox: AsyncSandbox | None = None + started = time() + try: + sandbox = await self._create_sandbox(body, files=files) + start_time_taken = time() - started + verification_started = time() + result = await run_verification( + sandbox=sandbox, + inputs=inputs, + timeout_s=self.config.evaluation_timeout, + log_dir=log_dir, + ) + verification_time_taken = time() - verification_started + except Exception as exc: + start_time_taken = time() - started + verification_time_taken = 0.0 + result = VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output="", + error=f"Verification failed: {exc}", + ) + finally: + await self._stop_sandbox(sandbox) + if result.completed: + break + if attempt < attempts: + print( + f"[scale_swe] {body.instance_id}: inconclusive ({result.error}); " + f"retrying on a fresh sandbox ({attempt}/{attempts - 1})", + flush=True, + ) + + return ScaleSWEVerifyResponse.model_validate( + body.model_dump() + | { + # An unresolved-but-completed run is a real 0. An incomplete run is also 0, but + # evaluation_completed distinguishes them so a broken row is not read as a hard task. + "reward": 1.0 if result.resolved else 0.0, + "evaluation_completed": result.completed, + "resolved": result.resolved, + "patch_applied": result.patch_applied, + "instance_id": body.instance_id, + "language": body.language, + "test_results": result.test_results, + "test_output": result.test_output[-100_000:], + "error": result.error, + "eval_sandbox_start_time_taken": start_time_taken, + "patch_verification_time_taken": verification_time_taken, + } + ) + + +if __name__ == "__main__": + ScaleSWEResourcesServer.run_webserver() +elif is_nemo_gym_fastapi_entrypoint(__file__): + # Required whenever num_workers > 1. Multi-worker uvicorn re-imports this entrypoint BY PATH + # in each forked child and expects a module-level `app`; without it every child exits, and + # uvicorn responds by stopping the parent. The server then never binds, so the symptom is not + # an import error but a flood of connection failures from clients talking to a dead port. + app = ScaleSWEResourcesServer.run_webserver() # noqa: F401 diff --git a/resources_servers/scale_swe/apply_golden_patch.py b/resources_servers/scale_swe/apply_golden_patch.py new file mode 100644 index 00000000000..347baf1b5a0 --- /dev/null +++ b/resources_servers/scale_swe/apply_golden_patch.py @@ -0,0 +1,165 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Grade every task with the dataset's own golden patch. + +This measures the dataset, not a model. A row whose golden patch does not make FAIL_TO_PASS +pass is unusable for evaluation or training, so this is the check to run before trusting any +score from Scale-SWE. + + gym env start --config resources_servers/scale_swe/configs/scale_swe.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml + + python resources_servers/scale_swe/apply_golden_patch.py \ + +benchmark_jsonl=benchmarks/scale_swe/data/scale_swe_benchmark.jsonl \ + +output_jsonl=results/scale_swe_golden_patch.jsonl \ + +concurrency=32 +limit=100 +""" + +import asyncio +import json +from collections import Counter +from pathlib import Path + +from tqdm.auto import tqdm + +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.server_utils import ServerClient + + +EMPTY_RESPONSE = { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], +} + +SERVER_NAME = "scale_swe_golden_patch_resources_server" + + +def _stream_examples(path: Path, limit: int): + """Yield rows lazily rather than materialising the whole benchmark file. + + Smaller than SWE-rebench (20,181 rows vs 32,079), but the same shape of problem: loading + every row into memory just to feed a bounded worker pool wastes that memory for the whole + run, and the peak lands hours in once results have also accumulated. + """ + with open(path, encoding="utf-8") as benchmark: + for index, line in enumerate(benchmark): + if limit and index >= limit: + return + line = line.strip() + if line: + yield json.loads(line) + + +async def main() -> None: + config = get_global_config_dict() + limit = int(config.get("limit") or 0) + concurrency = int(config.get("concurrency") or 16) + benchmark_fpath = Path(config["benchmark_jsonl"]) + output_fpath = Path(config.get("output_jsonl") or "results/scale_swe_golden_patch.jsonl") + + total = sum(1 for _ in _stream_examples(benchmark_fpath, limit)) + client = ServerClient.load_from_global_config() + + # Bounded: the queue holds at most one row per worker, so resident rows track concurrency + # rather than dataset size. + queue: asyncio.Queue = asyncio.Queue(maxsize=concurrency) + resolved = 0 + incomplete = 0 + by_language: Counter[str] = Counter() + resolved_by_language: Counter[str] = Counter() + finished = 0 + + output_fpath.parent.mkdir(parents=True, exist_ok=True) + progress = tqdm(total=total, desc="golden patch") + + with output_fpath.open("w", encoding="utf-8") as output: + + async def worker() -> None: + nonlocal resolved, incomplete, finished + while True: + example = await queue.get() + if example is None: + queue.task_done() + return + try: + payload = example | {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} + try: + response = await client.post(server_name=SERVER_NAME, url_path="/verify", json=payload) + result = await response.json() + except Exception as exc: + # One unreachable task must not abandon the sweep; record it and carry on. + result = { + "instance_id": example.get("instance_id", "?"), + "language": example.get("language", ""), + "resolved": False, + "evaluation_completed": False, + "error": f"request failed: {exc}", + } + if not isinstance(result, dict): + # Gym middleware returns repr(exc) as a bare JSON string when a handler + # raises, so a server-side fault arrives as a str. + result = { + "instance_id": example.get("instance_id", "?"), + "language": example.get("language", ""), + "resolved": False, + "evaluation_completed": False, + "error": f"server returned a non-object response: {str(result)[:300]}", + } + + language = str(result.get("language") or example.get("language") or "unknown") + by_language[language] += 1 + if result.get("resolved"): + resolved += 1 + resolved_by_language[language] += 1 + if not result.get("evaluation_completed", False): + incomplete += 1 + output.write(json.dumps(result) + "\n") + finished += 1 + if finished % 50 == 0: + output.flush() # a multi-hour run must leave usable rows if it is cut short + progress.update(1) + progress.set_description( + f"resolved {resolved}/{finished} ({100 * resolved / max(finished, 1):.1f}%) " + f"incomplete={incomplete}" + ) + finally: + queue.task_done() + + workers = [asyncio.create_task(worker()) for _ in range(concurrency)] + for example in _stream_examples(benchmark_fpath, limit): + await queue.put(example) + for _ in workers: + await queue.put(None) + await asyncio.gather(*workers) + + progress.close() + print(f"\ngolden-patch validation over {total} task(s)") + print(f" resolved: {resolved}/{total} ({100 * resolved / max(total, 1):.1f}%)") + print(f" incomplete: {incomplete}/{total} (no verdict: image pull, timeout, or setup failure)") + print("\n by language (resolved / total):") + for language, count in by_language.most_common(): + got = resolved_by_language[language] + print(f" {language:<10} {got:>5} / {count:<6} ({100 * got / count:5.1f}%)") + print(f"\nper-task rows: {output_fpath}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/resources_servers/scale_swe/client.py b/resources_servers/scale_swe/client.py new file mode 100644 index 00000000000..44df8d51cfd --- /dev/null +++ b/resources_servers/scale_swe/client.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Verify a single Scale-SWE row, for a quick smoke test of the server.""" + +import asyncio +import json + +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.server_utils import ServerClient + + +EMPTY_RESPONSE = { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], +} + + +async def main() -> None: + config = get_global_config_dict() + with open(config["benchmark_jsonl"], encoding="utf-8") as benchmark: + example = json.loads(next(benchmark)) + example |= {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} + + client = ServerClient.load_from_global_config() + result = await client.post( + server_name=config.get("resources_server_name", "scale_swe_golden_patch_resources_server"), + url_path="/verify", + json=example, + ) + print(json.dumps(await result.json(), indent=4)) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/resources_servers/scale_swe/configs/scale_swe.yaml b/resources_servers/scale_swe/configs/scale_swe.yaml new file mode 100644 index 00000000000..d36cb461ef8 --- /dev/null +++ b/resources_servers/scale_swe/configs/scale_swe.yaml @@ -0,0 +1,74 @@ +# Resources server for AweAI-Team/Scale-SWE. +# +# Every row carries its own prebuilt image (aweaiteam/scaleswe:...) and a pre_commands string +# that performs its own checkout and git-history scrub -- so there is no image repository or +# per-language configuration here. 20,181 rows, entirely Python, one test runner (pytest). +scale_swe_resources_server: + resources_servers: + scale_swe: + allowed_agents: [opencode_sandboxed_agent] + entrypoint: app.py + domain: coding + verified: false + + # Pure Python, no compilation: pytest runs against a handful of named files, not a full + # suite build. Sized well under the SWE-rebench compiled-language shape. + evaluation_timeout: 1200 + is_verifying_golden_patch: false + + sandbox_provider: sandbox + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + # Limits are the BURST ceiling; requests are the guaranteed floor -- see + # resources_servers/swe_rebench/configs/swe_rebench.yaml for the measurement behind this + # split (2.8x faster than requests==limits at no cost in resolved rate or incompletes). + # + # memory_mib raised 8192 -> 16384 on direct evidence, not a guess: a full-set 20,181-row + # run at the 8Gi limit had 695 rows (3.4% of the whole set) die at pod CREATION with + # `OOMKilled (exit code 137)`, concentrated in a handful of repos (durandtibo's + # coola/feu/grizz/iden -- torch-adjacent tensor tooling -- alone were 335 of the 695). + # These never reach the test phase, so no per-task CPU/timeout signal catches them; the + # only way to see it was reading the actual sandbox-creation error. + resources: + cpu: 4 + memory_mib: 16384 + disk_gib: 20 + provider_options: + resource_requests: + cpu: 1 + memory_mib: 4096 + disk_gib: 20 + metadata: + benchmark: scale-swe + +# Golden-patch validation: grade the dataset's own patch instead of an agent's. A row whose +# golden patch does not resolve is a broken row, and scoring an agent against it measures noise. +# Run it with resources_servers/scale_swe/apply_golden_patch.py. +scale_swe_golden_patch_resources_server: + resources_servers: + scale_swe: + entrypoint: app.py + domain: coding + verified: false + + evaluation_timeout: 1200 + is_verifying_golden_patch: true + + sandbox_provider: sandbox + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + # See scale_swe_resources_server above: raised on direct OOMKilled evidence from a + # full-set run at the previous 8Gi limit. + resources: + cpu: 4 + memory_mib: 16384 + disk_gib: 20 + provider_options: + resource_requests: + cpu: 1 + memory_mib: 4096 + disk_gib: 20 + metadata: + benchmark: scale-swe-golden-patch diff --git a/resources_servers/scale_swe/data/supported_instance_ids.txt b/resources_servers/scale_swe/data/supported_instance_ids.txt new file mode 100644 index 00000000000..11de7ee3f34 --- /dev/null +++ b/resources_servers/scale_swe/data/supported_instance_ids.txt @@ -0,0 +1,17696 @@ +adamchainz_apig-wsgi_pr46 +adamchainz_apig-wsgi_pr80 +adamchainz_apig-wsgi_pr93 +adamchainz_django-cors-headers_pr380 +adamchainz_django-cors-headers_pr388 +adamchainz_django-cors-headers_pr396 +adamchainz_django-cors-headers_pr397 +adamchainz_django-cors-headers_pr405 +adamchainz_django-cors-headers_pr418 +adamchainz_django-cors-headers_pr451 +adamchainz_ec2-metadata_pr339 +adamchainz_ec2-metadata_pr40 +adamchainz_flake8-comprehensions_pr202 +adamchainz_flake8-comprehensions_pr205 +adamchainz_flake8-comprehensions_pr491 +adamchainz_flake8-logging_pr4 +adamchainz_flake8-no-pep420_pr103 +adamchainz_pytest-reverse_pr10 +adamchainz_treepoem_pr437 +adamchainz_treepoem_pr499 +adamchainz_treepoem_pr500 +adamchainz_treepoem_pr587 +adamjstewart_fiscalyear_pr24 +adamtheturtle_doccmd_pr158 +adamtheturtle_doccmd_pr168 +adamtheturtle_doccmd_pr192 +adamtheturtle_doccmd_pr193 +adamtheturtle_doccmd_pr195 +adamtheturtle_doccmd_pr201 +adamtheturtle_doccmd_pr208 +adamtheturtle_doccmd_pr209 +adamtheturtle_doccmd_pr211 +adamtheturtle_doccmd_pr282 +adamtheturtle_doccmd_pr286 +adamtheturtle_doccmd_pr316 +adamtheturtle_doccmd_pr317 +adamtheturtle_doccmd_pr330 +adamtheturtle_doccmd_pr345 +adamtheturtle_doccmd_pr361 +adamtheturtle_doccmd_pr363 +adamtheturtle_doccmd_pr383 +adamtheturtle_doccmd_pr408 +adamtheturtle_doccmd_pr42 +adamtheturtle_doccmd_pr420 +adamtheturtle_doccmd_pr426 +adamtheturtle_doccmd_pr44 +adamtheturtle_doccmd_pr45 +adamtheturtle_doccmd_pr50 +adamtheturtle_pip-check-reqs_pr38 +adamtheturtle_pip-check-reqs_pr84 +adamtheturtle_sybil-extras_pr12 +adamtheturtle_sybil-extras_pr150 +adamtheturtle_sybil-extras_pr281 +adamtheturtle_sybil-extras_pr296 +adamtheturtle_sybil-extras_pr297 +adamtheturtle_sybil-extras_pr304 +adamtheturtle_sybil-extras_pr342 +adamtheturtle_sybil-extras_pr344 +adamtheturtle_sybil-extras_pr345 +adamtheturtle_sybil-extras_pr346 +adamtheturtle_sybil-extras_pr347 +adamtheturtle_sybil-extras_pr354 +adamtheturtle_sybil-extras_pr355 +adamtheturtle_sybil-extras_pr391 +aio-libs_aiosmtpd_pr143 +aio-libs_aiosmtpd_pr184 +aio-libs_aiosmtpd_pr192 +aio-libs_aiosmtpd_pr228 +aio-libs_aiosmtpd_pr250 +aio-libs_aiosmtpd_pr258 +aio-libs_aiozipkin_pr16 +aio-libs_aiozipkin_pr40 +aio-libs_frozenlist_pr227 +aiokitchen_aiomisc_pr227 +aiven_aiven-client_pr2 +aiven_aiven-client_pr287 +alex_rply_pr101 +andialbrecht_sqlparse_pr317 +andialbrecht_sqlparse_pr330 +andialbrecht_sqlparse_pr357 +andialbrecht_sqlparse_pr398 +andialbrecht_sqlparse_pr553 +andrewgodwin_urlman_pr6 +anntzer_defopt_pr30 +anntzer_defopt_pr38 +anntzer_defopt_pr56 +anntzer_defopt_pr60 +anntzer_defopt_pr64 +anntzer_defopt_pr66 +anntzer_defopt_pr70 +anntzer_defopt_pr76 +ansys_pyedb-core_pr336 +ansys_pyedb-core_pr347 +ansys_pyedb-core_pr349 +ansys_pyfluent_pr139 +ansys_pyfluent_pr175 +ansys_pyfluent_pr217 +ansys_pyfluent_pr241 +ansys_pyfluent_pr286 +ansys_pyfluent_pr296 +ansys_pyfluent_pr311 +ansys_pyfluent_pr319 +ansys_pyfluent_pr321 +ansys_pyfluent_pr332 +ansys_pyfluent_pr336 +ansys_pyfluent_pr354 +ansys_pyfluent_pr355 +ansys_pyfluent_pr359 +ansys_pyfluent_pr378 +ansys_pyfluent_pr413 +ansys_pyfluent_pr46 +app-sre_qontract-reconcile_pr1 +app-sre_qontract-reconcile_pr10 +app-sre_qontract-reconcile_pr1004 +app-sre_qontract-reconcile_pr1006 +app-sre_qontract-reconcile_pr1008 +app-sre_qontract-reconcile_pr1009 +app-sre_qontract-reconcile_pr1010 +app-sre_qontract-reconcile_pr1011 +app-sre_qontract-reconcile_pr1012 +app-sre_qontract-reconcile_pr1013 +app-sre_qontract-reconcile_pr1016 +app-sre_qontract-reconcile_pr1017 +app-sre_qontract-reconcile_pr1020 +app-sre_qontract-reconcile_pr1021 +app-sre_qontract-reconcile_pr1022 +app-sre_qontract-reconcile_pr1024 +app-sre_qontract-reconcile_pr1030 +app-sre_qontract-reconcile_pr1032 +app-sre_qontract-reconcile_pr1034 +app-sre_qontract-reconcile_pr1040 +app-sre_qontract-reconcile_pr1047 +app-sre_qontract-reconcile_pr1049 +app-sre_qontract-reconcile_pr1051 +app-sre_qontract-reconcile_pr1052 +app-sre_qontract-reconcile_pr1053 +app-sre_qontract-reconcile_pr1058 +app-sre_qontract-reconcile_pr1066 +app-sre_qontract-reconcile_pr1069 +app-sre_qontract-reconcile_pr1071 +app-sre_qontract-reconcile_pr1072 +app-sre_qontract-reconcile_pr1076 +app-sre_qontract-reconcile_pr1082 +app-sre_qontract-reconcile_pr1086 +app-sre_qontract-reconcile_pr1097 +app-sre_qontract-reconcile_pr1099 +app-sre_qontract-reconcile_pr1101 +app-sre_qontract-reconcile_pr1103 +app-sre_qontract-reconcile_pr1105 +app-sre_qontract-reconcile_pr1113 +app-sre_qontract-reconcile_pr1117 +app-sre_qontract-reconcile_pr1119 +app-sre_qontract-reconcile_pr1122 +app-sre_qontract-reconcile_pr1125 +app-sre_qontract-reconcile_pr1128 +app-sre_qontract-reconcile_pr1130 +app-sre_qontract-reconcile_pr1132 +app-sre_qontract-reconcile_pr1137 +app-sre_qontract-reconcile_pr1138 +app-sre_qontract-reconcile_pr1143 +app-sre_qontract-reconcile_pr1147 +app-sre_qontract-reconcile_pr1149 +app-sre_qontract-reconcile_pr1151 +app-sre_qontract-reconcile_pr1152 +app-sre_qontract-reconcile_pr1153 +app-sre_qontract-reconcile_pr1154 +app-sre_qontract-reconcile_pr1157 +app-sre_qontract-reconcile_pr1161 +app-sre_qontract-reconcile_pr1170 +app-sre_qontract-reconcile_pr1171 +app-sre_qontract-reconcile_pr1175 +app-sre_qontract-reconcile_pr1177 +app-sre_qontract-reconcile_pr1179 +app-sre_qontract-reconcile_pr1183 +app-sre_qontract-reconcile_pr1186 +app-sre_qontract-reconcile_pr1189 +app-sre_qontract-reconcile_pr1191 +app-sre_qontract-reconcile_pr1195 +app-sre_qontract-reconcile_pr1196 +app-sre_qontract-reconcile_pr1199 +app-sre_qontract-reconcile_pr12 +app-sre_qontract-reconcile_pr1204 +app-sre_qontract-reconcile_pr1210 +app-sre_qontract-reconcile_pr1214 +app-sre_qontract-reconcile_pr1215 +app-sre_qontract-reconcile_pr1219 +app-sre_qontract-reconcile_pr1220 +app-sre_qontract-reconcile_pr1222 +app-sre_qontract-reconcile_pr1228 +app-sre_qontract-reconcile_pr1229 +app-sre_qontract-reconcile_pr1232 +app-sre_qontract-reconcile_pr1238 +app-sre_qontract-reconcile_pr1248 +app-sre_qontract-reconcile_pr1255 +app-sre_qontract-reconcile_pr1259 +app-sre_qontract-reconcile_pr1263 +app-sre_qontract-reconcile_pr1265 +app-sre_qontract-reconcile_pr1267 +app-sre_qontract-reconcile_pr1270 +app-sre_qontract-reconcile_pr1272 +app-sre_qontract-reconcile_pr1273 +app-sre_qontract-reconcile_pr1274 +app-sre_qontract-reconcile_pr1279 +app-sre_qontract-reconcile_pr1281 +app-sre_qontract-reconcile_pr13 +app-sre_qontract-reconcile_pr15 +app-sre_qontract-reconcile_pr16 +app-sre_qontract-reconcile_pr1780 +app-sre_qontract-reconcile_pr1823 +app-sre_qontract-reconcile_pr1827 +app-sre_qontract-reconcile_pr1843 +app-sre_qontract-reconcile_pr1845 +app-sre_qontract-reconcile_pr1848 +app-sre_qontract-reconcile_pr1851 +app-sre_qontract-reconcile_pr1856 +app-sre_qontract-reconcile_pr1858 +app-sre_qontract-reconcile_pr1862 +app-sre_qontract-reconcile_pr1866 +app-sre_qontract-reconcile_pr1867 +app-sre_qontract-reconcile_pr1869 +app-sre_qontract-reconcile_pr187 +app-sre_qontract-reconcile_pr1874 +app-sre_qontract-reconcile_pr1876 +app-sre_qontract-reconcile_pr1878 +app-sre_qontract-reconcile_pr1879 +app-sre_qontract-reconcile_pr188 +app-sre_qontract-reconcile_pr1880 +app-sre_qontract-reconcile_pr1882 +app-sre_qontract-reconcile_pr1887 +app-sre_qontract-reconcile_pr1889 +app-sre_qontract-reconcile_pr1899 +app-sre_qontract-reconcile_pr19 +app-sre_qontract-reconcile_pr1900 +app-sre_qontract-reconcile_pr1901 +app-sre_qontract-reconcile_pr1902 +app-sre_qontract-reconcile_pr1904 +app-sre_qontract-reconcile_pr1906 +app-sre_qontract-reconcile_pr1911 +app-sre_qontract-reconcile_pr1914 +app-sre_qontract-reconcile_pr192 +app-sre_qontract-reconcile_pr1928 +app-sre_qontract-reconcile_pr1932 +app-sre_qontract-reconcile_pr1933 +app-sre_qontract-reconcile_pr1934 +app-sre_qontract-reconcile_pr1937 +app-sre_qontract-reconcile_pr1938 +app-sre_qontract-reconcile_pr1941 +app-sre_qontract-reconcile_pr1943 +app-sre_qontract-reconcile_pr1944 +app-sre_qontract-reconcile_pr1946 +app-sre_qontract-reconcile_pr1951 +app-sre_qontract-reconcile_pr1952 +app-sre_qontract-reconcile_pr1953 +app-sre_qontract-reconcile_pr1957 +app-sre_qontract-reconcile_pr1959 +app-sre_qontract-reconcile_pr1962 +app-sre_qontract-reconcile_pr1967 +app-sre_qontract-reconcile_pr197 +app-sre_qontract-reconcile_pr1972 +app-sre_qontract-reconcile_pr1977 +app-sre_qontract-reconcile_pr1978 +app-sre_qontract-reconcile_pr1981 +app-sre_qontract-reconcile_pr1986 +app-sre_qontract-reconcile_pr199 +app-sre_qontract-reconcile_pr1991 +app-sre_qontract-reconcile_pr1992 +app-sre_qontract-reconcile_pr1993 +app-sre_qontract-reconcile_pr1997 +app-sre_qontract-reconcile_pr1998 +app-sre_qontract-reconcile_pr2 +app-sre_qontract-reconcile_pr20 +app-sre_qontract-reconcile_pr2000 +app-sre_qontract-reconcile_pr2001 +app-sre_qontract-reconcile_pr2002 +app-sre_qontract-reconcile_pr2005 +app-sre_qontract-reconcile_pr2009 +app-sre_qontract-reconcile_pr2013 +app-sre_qontract-reconcile_pr2016 +app-sre_qontract-reconcile_pr2018 +app-sre_qontract-reconcile_pr2021 +app-sre_qontract-reconcile_pr2023 +app-sre_qontract-reconcile_pr2026 +app-sre_qontract-reconcile_pr2030 +app-sre_qontract-reconcile_pr2031 +app-sre_qontract-reconcile_pr2033 +app-sre_qontract-reconcile_pr2035 +app-sre_qontract-reconcile_pr2042 +app-sre_qontract-reconcile_pr2043 +app-sre_qontract-reconcile_pr2044 +app-sre_qontract-reconcile_pr2048 +app-sre_qontract-reconcile_pr205 +app-sre_qontract-reconcile_pr2050 +app-sre_qontract-reconcile_pr2051 +app-sre_qontract-reconcile_pr2054 +app-sre_qontract-reconcile_pr2057 +app-sre_qontract-reconcile_pr2061 +app-sre_qontract-reconcile_pr2062 +app-sre_qontract-reconcile_pr2063 +app-sre_qontract-reconcile_pr2064 +app-sre_qontract-reconcile_pr207 +app-sre_qontract-reconcile_pr2070 +app-sre_qontract-reconcile_pr2078 +app-sre_qontract-reconcile_pr2080 +app-sre_qontract-reconcile_pr2087 +app-sre_qontract-reconcile_pr2088 +app-sre_qontract-reconcile_pr209 +app-sre_qontract-reconcile_pr2090 +app-sre_qontract-reconcile_pr2097 +app-sre_qontract-reconcile_pr2099 +app-sre_qontract-reconcile_pr2100 +app-sre_qontract-reconcile_pr2103 +app-sre_qontract-reconcile_pr2108 +app-sre_qontract-reconcile_pr2109 +app-sre_qontract-reconcile_pr211 +app-sre_qontract-reconcile_pr2110 +app-sre_qontract-reconcile_pr2112 +app-sre_qontract-reconcile_pr2117 +app-sre_qontract-reconcile_pr2125 +app-sre_qontract-reconcile_pr2130 +app-sre_qontract-reconcile_pr2131 +app-sre_qontract-reconcile_pr2132 +app-sre_qontract-reconcile_pr2133 +app-sre_qontract-reconcile_pr2136 +app-sre_qontract-reconcile_pr2137 +app-sre_qontract-reconcile_pr2141 +app-sre_qontract-reconcile_pr2143 +app-sre_qontract-reconcile_pr2147 +app-sre_qontract-reconcile_pr2151 +app-sre_qontract-reconcile_pr2157 +app-sre_qontract-reconcile_pr2159 +app-sre_qontract-reconcile_pr2160 +app-sre_qontract-reconcile_pr2162 +app-sre_qontract-reconcile_pr2163 +app-sre_qontract-reconcile_pr2165 +app-sre_qontract-reconcile_pr2167 +app-sre_qontract-reconcile_pr2168 +app-sre_qontract-reconcile_pr2172 +app-sre_qontract-reconcile_pr2180 +app-sre_qontract-reconcile_pr2184 +app-sre_qontract-reconcile_pr2185 +app-sre_qontract-reconcile_pr2187 +app-sre_qontract-reconcile_pr2188 +app-sre_qontract-reconcile_pr219 +app-sre_qontract-reconcile_pr2191 +app-sre_qontract-reconcile_pr2197 +app-sre_qontract-reconcile_pr2198 +app-sre_qontract-reconcile_pr22 +app-sre_qontract-reconcile_pr2204 +app-sre_qontract-reconcile_pr2208 +app-sre_qontract-reconcile_pr221 +app-sre_qontract-reconcile_pr2216 +app-sre_qontract-reconcile_pr2224 +app-sre_qontract-reconcile_pr2228 +app-sre_qontract-reconcile_pr223 +app-sre_qontract-reconcile_pr2231 +app-sre_qontract-reconcile_pr2232 +app-sre_qontract-reconcile_pr2236 +app-sre_qontract-reconcile_pr2239 +app-sre_qontract-reconcile_pr224 +app-sre_qontract-reconcile_pr2240 +app-sre_qontract-reconcile_pr2241 +app-sre_qontract-reconcile_pr2242 +app-sre_qontract-reconcile_pr2243 +app-sre_qontract-reconcile_pr2244 +app-sre_qontract-reconcile_pr2245 +app-sre_qontract-reconcile_pr2252 +app-sre_qontract-reconcile_pr2253 +app-sre_qontract-reconcile_pr2254 +app-sre_qontract-reconcile_pr2256 +app-sre_qontract-reconcile_pr2257 +app-sre_qontract-reconcile_pr2260 +app-sre_qontract-reconcile_pr2264 +app-sre_qontract-reconcile_pr2265 +app-sre_qontract-reconcile_pr227 +app-sre_qontract-reconcile_pr2273 +app-sre_qontract-reconcile_pr2275 +app-sre_qontract-reconcile_pr229 +app-sre_qontract-reconcile_pr2295 +app-sre_qontract-reconcile_pr230 +app-sre_qontract-reconcile_pr2303 +app-sre_qontract-reconcile_pr234 +app-sre_qontract-reconcile_pr239 +app-sre_qontract-reconcile_pr242 +app-sre_qontract-reconcile_pr243 +app-sre_qontract-reconcile_pr244 +app-sre_qontract-reconcile_pr245 +app-sre_qontract-reconcile_pr247 +app-sre_qontract-reconcile_pr252 +app-sre_qontract-reconcile_pr254 +app-sre_qontract-reconcile_pr255 +app-sre_qontract-reconcile_pr264 +app-sre_qontract-reconcile_pr29 +app-sre_qontract-reconcile_pr291 +app-sre_qontract-reconcile_pr295 +app-sre_qontract-reconcile_pr3 +app-sre_qontract-reconcile_pr30 +app-sre_qontract-reconcile_pr300 +app-sre_qontract-reconcile_pr301 +app-sre_qontract-reconcile_pr302 +app-sre_qontract-reconcile_pr303 +app-sre_qontract-reconcile_pr304 +app-sre_qontract-reconcile_pr305 +app-sre_qontract-reconcile_pr308 +app-sre_qontract-reconcile_pr309 +app-sre_qontract-reconcile_pr31 +app-sre_qontract-reconcile_pr310 +app-sre_qontract-reconcile_pr313 +app-sre_qontract-reconcile_pr315 +app-sre_qontract-reconcile_pr316 +app-sre_qontract-reconcile_pr317 +app-sre_qontract-reconcile_pr318 +app-sre_qontract-reconcile_pr319 +app-sre_qontract-reconcile_pr32 +app-sre_qontract-reconcile_pr322 +app-sre_qontract-reconcile_pr323 +app-sre_qontract-reconcile_pr324 +app-sre_qontract-reconcile_pr327 +app-sre_qontract-reconcile_pr328 +app-sre_qontract-reconcile_pr331 +app-sre_qontract-reconcile_pr332 +app-sre_qontract-reconcile_pr347 +app-sre_qontract-reconcile_pr349 +app-sre_qontract-reconcile_pr353 +app-sre_qontract-reconcile_pr355 +app-sre_qontract-reconcile_pr356 +app-sre_qontract-reconcile_pr36 +app-sre_qontract-reconcile_pr360 +app-sre_qontract-reconcile_pr364 +app-sre_qontract-reconcile_pr366 +app-sre_qontract-reconcile_pr367 +app-sre_qontract-reconcile_pr368 +app-sre_qontract-reconcile_pr369 +app-sre_qontract-reconcile_pr37 +app-sre_qontract-reconcile_pr372 +app-sre_qontract-reconcile_pr374 +app-sre_qontract-reconcile_pr375 +app-sre_qontract-reconcile_pr378 +app-sre_qontract-reconcile_pr379 +app-sre_qontract-reconcile_pr38 +app-sre_qontract-reconcile_pr382 +app-sre_qontract-reconcile_pr385 +app-sre_qontract-reconcile_pr389 +app-sre_qontract-reconcile_pr39 +app-sre_qontract-reconcile_pr390 +app-sre_qontract-reconcile_pr394 +app-sre_qontract-reconcile_pr396 +app-sre_qontract-reconcile_pr398 +app-sre_qontract-reconcile_pr4 +app-sre_qontract-reconcile_pr400 +app-sre_qontract-reconcile_pr403 +app-sre_qontract-reconcile_pr405 +app-sre_qontract-reconcile_pr406 +app-sre_qontract-reconcile_pr414 +app-sre_qontract-reconcile_pr418 +app-sre_qontract-reconcile_pr420 +app-sre_qontract-reconcile_pr421 +app-sre_qontract-reconcile_pr422 +app-sre_qontract-reconcile_pr423 +app-sre_qontract-reconcile_pr428 +app-sre_qontract-reconcile_pr429 +app-sre_qontract-reconcile_pr433 +app-sre_qontract-reconcile_pr434 +app-sre_qontract-reconcile_pr437 +app-sre_qontract-reconcile_pr439 +app-sre_qontract-reconcile_pr445 +app-sre_qontract-reconcile_pr448 +app-sre_qontract-reconcile_pr449 +app-sre_qontract-reconcile_pr450 +app-sre_qontract-reconcile_pr452 +app-sre_qontract-reconcile_pr455 +app-sre_qontract-reconcile_pr459 +app-sre_qontract-reconcile_pr462 +app-sre_qontract-reconcile_pr468 +app-sre_qontract-reconcile_pr47 +app-sre_qontract-reconcile_pr470 +app-sre_qontract-reconcile_pr471 +app-sre_qontract-reconcile_pr472 +app-sre_qontract-reconcile_pr473 +app-sre_qontract-reconcile_pr478 +app-sre_qontract-reconcile_pr481 +app-sre_qontract-reconcile_pr482 +app-sre_qontract-reconcile_pr483 +app-sre_qontract-reconcile_pr491 +app-sre_qontract-reconcile_pr493 +app-sre_qontract-reconcile_pr504 +app-sre_qontract-reconcile_pr505 +app-sre_qontract-reconcile_pr508 +app-sre_qontract-reconcile_pr509 +app-sre_qontract-reconcile_pr513 +app-sre_qontract-reconcile_pr527 +app-sre_qontract-reconcile_pr529 +app-sre_qontract-reconcile_pr53 +app-sre_qontract-reconcile_pr534 +app-sre_qontract-reconcile_pr535 +app-sre_qontract-reconcile_pr536 +app-sre_qontract-reconcile_pr537 +app-sre_qontract-reconcile_pr538 +app-sre_qontract-reconcile_pr540 +app-sre_qontract-reconcile_pr541 +app-sre_qontract-reconcile_pr542 +app-sre_qontract-reconcile_pr543 +app-sre_qontract-reconcile_pr547 +app-sre_qontract-reconcile_pr548 +app-sre_qontract-reconcile_pr549 +app-sre_qontract-reconcile_pr551 +app-sre_qontract-reconcile_pr553 +app-sre_qontract-reconcile_pr555 +app-sre_qontract-reconcile_pr556 +app-sre_qontract-reconcile_pr56 +app-sre_qontract-reconcile_pr560 +app-sre_qontract-reconcile_pr561 +app-sre_qontract-reconcile_pr562 +app-sre_qontract-reconcile_pr565 +app-sre_qontract-reconcile_pr568 +app-sre_qontract-reconcile_pr569 +app-sre_qontract-reconcile_pr574 +app-sre_qontract-reconcile_pr576 +app-sre_qontract-reconcile_pr578 +app-sre_qontract-reconcile_pr581 +app-sre_qontract-reconcile_pr582 +app-sre_qontract-reconcile_pr584 +app-sre_qontract-reconcile_pr585 +app-sre_qontract-reconcile_pr586 +app-sre_qontract-reconcile_pr588 +app-sre_qontract-reconcile_pr589 +app-sre_qontract-reconcile_pr59 +app-sre_qontract-reconcile_pr590 +app-sre_qontract-reconcile_pr591 +app-sre_qontract-reconcile_pr594 +app-sre_qontract-reconcile_pr601 +app-sre_qontract-reconcile_pr603 +app-sre_qontract-reconcile_pr604 +app-sre_qontract-reconcile_pr605 +app-sre_qontract-reconcile_pr607 +app-sre_qontract-reconcile_pr609 +app-sre_qontract-reconcile_pr615 +app-sre_qontract-reconcile_pr616 +app-sre_qontract-reconcile_pr617 +app-sre_qontract-reconcile_pr618 +app-sre_qontract-reconcile_pr619 +app-sre_qontract-reconcile_pr622 +app-sre_qontract-reconcile_pr624 +app-sre_qontract-reconcile_pr626 +app-sre_qontract-reconcile_pr627 +app-sre_qontract-reconcile_pr632 +app-sre_qontract-reconcile_pr633 +app-sre_qontract-reconcile_pr636 +app-sre_qontract-reconcile_pr637 +app-sre_qontract-reconcile_pr641 +app-sre_qontract-reconcile_pr643 +app-sre_qontract-reconcile_pr645 +app-sre_qontract-reconcile_pr647 +app-sre_qontract-reconcile_pr649 +app-sre_qontract-reconcile_pr654 +app-sre_qontract-reconcile_pr656 +app-sre_qontract-reconcile_pr659 +app-sre_qontract-reconcile_pr660 +app-sre_qontract-reconcile_pr662 +app-sre_qontract-reconcile_pr668 +app-sre_qontract-reconcile_pr670 +app-sre_qontract-reconcile_pr672 +app-sre_qontract-reconcile_pr673 +app-sre_qontract-reconcile_pr674 +app-sre_qontract-reconcile_pr676 +app-sre_qontract-reconcile_pr677 +app-sre_qontract-reconcile_pr679 +app-sre_qontract-reconcile_pr683 +app-sre_qontract-reconcile_pr687 +app-sre_qontract-reconcile_pr688 +app-sre_qontract-reconcile_pr689 +app-sre_qontract-reconcile_pr693 +app-sre_qontract-reconcile_pr694 +app-sre_qontract-reconcile_pr695 +app-sre_qontract-reconcile_pr696 +app-sre_qontract-reconcile_pr697 +app-sre_qontract-reconcile_pr701 +app-sre_qontract-reconcile_pr702 +app-sre_qontract-reconcile_pr704 +app-sre_qontract-reconcile_pr705 +app-sre_qontract-reconcile_pr706 +app-sre_qontract-reconcile_pr709 +app-sre_qontract-reconcile_pr710 +app-sre_qontract-reconcile_pr712 +app-sre_qontract-reconcile_pr713 +app-sre_qontract-reconcile_pr715 +app-sre_qontract-reconcile_pr716 +app-sre_qontract-reconcile_pr717 +app-sre_qontract-reconcile_pr718 +app-sre_qontract-reconcile_pr719 +app-sre_qontract-reconcile_pr721 +app-sre_qontract-reconcile_pr722 +app-sre_qontract-reconcile_pr724 +app-sre_qontract-reconcile_pr729 +app-sre_qontract-reconcile_pr730 +app-sre_qontract-reconcile_pr732 +app-sre_qontract-reconcile_pr733 +app-sre_qontract-reconcile_pr734 +app-sre_qontract-reconcile_pr736 +app-sre_qontract-reconcile_pr741 +app-sre_qontract-reconcile_pr742 +app-sre_qontract-reconcile_pr747 +app-sre_qontract-reconcile_pr749 +app-sre_qontract-reconcile_pr751 +app-sre_qontract-reconcile_pr752 +app-sre_qontract-reconcile_pr753 +app-sre_qontract-reconcile_pr755 +app-sre_qontract-reconcile_pr761 +app-sre_qontract-reconcile_pr762 +app-sre_qontract-reconcile_pr766 +app-sre_qontract-reconcile_pr767 +app-sre_qontract-reconcile_pr768 +app-sre_qontract-reconcile_pr772 +app-sre_qontract-reconcile_pr774 +app-sre_qontract-reconcile_pr776 +app-sre_qontract-reconcile_pr777 +app-sre_qontract-reconcile_pr778 +app-sre_qontract-reconcile_pr781 +app-sre_qontract-reconcile_pr782 +app-sre_qontract-reconcile_pr783 +app-sre_qontract-reconcile_pr787 +app-sre_qontract-reconcile_pr788 +app-sre_qontract-reconcile_pr791 +app-sre_qontract-reconcile_pr792 +app-sre_qontract-reconcile_pr793 +app-sre_qontract-reconcile_pr798 +app-sre_qontract-reconcile_pr8 +app-sre_qontract-reconcile_pr803 +app-sre_qontract-reconcile_pr804 +app-sre_qontract-reconcile_pr808 +app-sre_qontract-reconcile_pr813 +app-sre_qontract-reconcile_pr815 +app-sre_qontract-reconcile_pr816 +app-sre_qontract-reconcile_pr820 +app-sre_qontract-reconcile_pr841 +app-sre_qontract-reconcile_pr842 +app-sre_qontract-reconcile_pr844 +app-sre_qontract-reconcile_pr845 +app-sre_qontract-reconcile_pr846 +app-sre_qontract-reconcile_pr850 +app-sre_qontract-reconcile_pr851 +app-sre_qontract-reconcile_pr852 +app-sre_qontract-reconcile_pr854 +app-sre_qontract-reconcile_pr855 +app-sre_qontract-reconcile_pr857 +app-sre_qontract-reconcile_pr861 +app-sre_qontract-reconcile_pr862 +app-sre_qontract-reconcile_pr864 +app-sre_qontract-reconcile_pr865 +app-sre_qontract-reconcile_pr866 +app-sre_qontract-reconcile_pr868 +app-sre_qontract-reconcile_pr871 +app-sre_qontract-reconcile_pr873 +app-sre_qontract-reconcile_pr874 +app-sre_qontract-reconcile_pr876 +app-sre_qontract-reconcile_pr878 +app-sre_qontract-reconcile_pr883 +app-sre_qontract-reconcile_pr885 +app-sre_qontract-reconcile_pr890 +app-sre_qontract-reconcile_pr895 +app-sre_qontract-reconcile_pr897 +app-sre_qontract-reconcile_pr9 +app-sre_qontract-reconcile_pr900 +app-sre_qontract-reconcile_pr901 +app-sre_qontract-reconcile_pr907 +app-sre_qontract-reconcile_pr910 +app-sre_qontract-reconcile_pr917 +app-sre_qontract-reconcile_pr919 +app-sre_qontract-reconcile_pr924 +app-sre_qontract-reconcile_pr925 +app-sre_qontract-reconcile_pr926 +app-sre_qontract-reconcile_pr927 +app-sre_qontract-reconcile_pr929 +app-sre_qontract-reconcile_pr931 +app-sre_qontract-reconcile_pr932 +app-sre_qontract-reconcile_pr934 +app-sre_qontract-reconcile_pr936 +app-sre_qontract-reconcile_pr949 +app-sre_qontract-reconcile_pr950 +app-sre_qontract-reconcile_pr958 +app-sre_qontract-reconcile_pr961 +app-sre_qontract-reconcile_pr962 +app-sre_qontract-reconcile_pr964 +app-sre_qontract-reconcile_pr965 +app-sre_qontract-reconcile_pr971 +app-sre_qontract-reconcile_pr974 +app-sre_qontract-reconcile_pr975 +app-sre_qontract-reconcile_pr976 +app-sre_qontract-reconcile_pr977 +app-sre_qontract-reconcile_pr981 +app-sre_qontract-reconcile_pr982 +app-sre_qontract-reconcile_pr983 +app-sre_qontract-reconcile_pr984 +app-sre_qontract-reconcile_pr987 +app-sre_qontract-reconcile_pr988 +app-sre_qontract-reconcile_pr990 +app-sre_qontract-reconcile_pr991 +app-sre_qontract-reconcile_pr993 +app-sre_qontract-reconcile_pr994 +app-sre_qontract-reconcile_pr995 +appium_python-client_pr294 +appium_python-client_pr296 +appium_python-client_pr297 +appium_python-client_pr302 +appium_python-client_pr307 +appium_python-client_pr310 +appium_python-client_pr312 +appium_python-client_pr319 +appium_python-client_pr322 +appium_python-client_pr324 +appium_python-client_pr327 +appium_python-client_pr332 +appium_python-client_pr334 +appium_python-client_pr335 +appium_python-client_pr338 +appium_python-client_pr343 +appium_python-client_pr351 +appium_python-client_pr357 +appium_python-client_pr360 +appium_python-client_pr363 +appium_python-client_pr364 +appium_python-client_pr366 +appium_python-client_pr367 +appium_python-client_pr368 +appium_python-client_pr370 +appium_python-client_pr371 +appium_python-client_pr372 +appium_python-client_pr374 +appium_python-client_pr385 +appium_python-client_pr386 +appium_python-client_pr388 +appium_python-client_pr391 +appium_python-client_pr396 +appium_python-client_pr399 +appium_python-client_pr406 +appium_python-client_pr426 +appium_python-client_pr440 +appium_python-client_pr446 +appium_python-client_pr461 +appium_python-client_pr466 +appium_python-client_pr469 +appium_python-client_pr473 +appium_python-client_pr479 +appium_python-client_pr495 +appium_python-client_pr514 +appium_python-client_pr515 +appium_python-client_pr517 +appium_python-client_pr518 +appium_python-client_pr521 +appium_python-client_pr531 +appium_python-client_pr552 +appium_python-client_pr580 +appium_python-client_pr594 +appium_python-client_pr608 +appium_python-client_pr620 +appium_python-client_pr646 +appium_python-client_pr674 +appium_python-client_pr677 +appium_python-client_pr701 +arcinstitute_cell-eval_pr102 +arcinstitute_cell-eval_pr110 +arcinstitute_cell-eval_pr119 +arcinstitute_cell-eval_pr129 +arcinstitute_cell-eval_pr136 +arcinstitute_cell-eval_pr140 +arcinstitute_cell-eval_pr143 +arcinstitute_cell-eval_pr149 +arcinstitute_cell-eval_pr16 +arcinstitute_cell-eval_pr161 +arcinstitute_cell-eval_pr17 +arcinstitute_cell-eval_pr192 +arcinstitute_cell-eval_pr206 +arcinstitute_cell-eval_pr30 +arcinstitute_cell-eval_pr31 +arcinstitute_cell-eval_pr48 +arcinstitute_cell-eval_pr51 +arcinstitute_cell-eval_pr68 +arcinstitute_cell-eval_pr72 +arcinstitute_cell-eval_pr75 +arcinstitute_cell-eval_pr91 +arcinstitute_cell-eval_pr94 +arcinstitute_cell-eval_pr96 +argyle-engineering_pyap_pr11 +argyle-engineering_pyap_pr13 +argyle-engineering_pyap_pr14 +argyle-engineering_pyap_pr15 +argyle-engineering_pyap_pr18 +argyle-engineering_pyap_pr19 +argyle-engineering_pyap_pr2 +argyle-engineering_pyap_pr20 +argyle-engineering_pyap_pr21 +argyle-engineering_pyap_pr22 +argyle-engineering_pyap_pr26 +argyle-engineering_pyap_pr27 +argyle-engineering_pyap_pr28 +argyle-engineering_pyap_pr3 +argyle-engineering_pyap_pr30 +argyle-engineering_pyap_pr32 +argyle-engineering_pyap_pr33 +argyle-engineering_pyap_pr36 +argyle-engineering_pyap_pr40 +argyle-engineering_pyap_pr41 +argyle-engineering_pyap_pr46 +argyle-engineering_pyap_pr50 +argyle-engineering_pyap_pr51 +argyle-engineering_pyap_pr55 +argyle-engineering_pyap_pr59 +argyle-engineering_pyap_pr62 +argyle-engineering_pyap_pr63 +argyle-engineering_pyap_pr64 +argyle-engineering_pyap_pr67 +argyle-engineering_pyap_pr68 +argyle-engineering_pyap_pr69 +ariebovenberg_slotscheck_pr121 +ariebovenberg_slotscheck_pr19 +ariebovenberg_slotscheck_pr194 +ariebovenberg_slotscheck_pr228 +ariebovenberg_slotscheck_pr27 +ariebovenberg_slotscheck_pr34 +ariebovenberg_slotscheck_pr44 +ariebovenberg_slotscheck_pr46 +ariebovenberg_slotscheck_pr93 +arviz-devs_preliz_pr100 +arviz-devs_preliz_pr103 +arviz-devs_preliz_pr105 +arviz-devs_preliz_pr106 +arviz-devs_preliz_pr108 +arviz-devs_preliz_pr113 +arviz-devs_preliz_pr117 +arviz-devs_preliz_pr120 +arviz-devs_preliz_pr122 +arviz-devs_preliz_pr124 +arviz-devs_preliz_pr13 +arviz-devs_preliz_pr137 +arviz-devs_preliz_pr138 +arviz-devs_preliz_pr142 +arviz-devs_preliz_pr143 +arviz-devs_preliz_pr145 +arviz-devs_preliz_pr146 +arviz-devs_preliz_pr147 +arviz-devs_preliz_pr150 +arviz-devs_preliz_pr153 +arviz-devs_preliz_pr154 +arviz-devs_preliz_pr155 +arviz-devs_preliz_pr157 +arviz-devs_preliz_pr158 +arviz-devs_preliz_pr162 +arviz-devs_preliz_pr168 +arviz-devs_preliz_pr181 +arviz-devs_preliz_pr182 +arviz-devs_preliz_pr186 +arviz-devs_preliz_pr187 +arviz-devs_preliz_pr188 +arviz-devs_preliz_pr192 +arviz-devs_preliz_pr196 +arviz-devs_preliz_pr197 +arviz-devs_preliz_pr20 +arviz-devs_preliz_pr203 +arviz-devs_preliz_pr209 +arviz-devs_preliz_pr212 +arviz-devs_preliz_pr216 +arviz-devs_preliz_pr222 +arviz-devs_preliz_pr224 +arviz-devs_preliz_pr232 +arviz-devs_preliz_pr237 +arviz-devs_preliz_pr239 +arviz-devs_preliz_pr24 +arviz-devs_preliz_pr240 +arviz-devs_preliz_pr242 +arviz-devs_preliz_pr243 +arviz-devs_preliz_pr244 +arviz-devs_preliz_pr245 +arviz-devs_preliz_pr249 +arviz-devs_preliz_pr251 +arviz-devs_preliz_pr256 +arviz-devs_preliz_pr272 +arviz-devs_preliz_pr28 +arviz-devs_preliz_pr280 +arviz-devs_preliz_pr282 +arviz-devs_preliz_pr286 +arviz-devs_preliz_pr287 +arviz-devs_preliz_pr288 +arviz-devs_preliz_pr292 +arviz-devs_preliz_pr296 +arviz-devs_preliz_pr302 +arviz-devs_preliz_pr304 +arviz-devs_preliz_pr305 +arviz-devs_preliz_pr306 +arviz-devs_preliz_pr307 +arviz-devs_preliz_pr312 +arviz-devs_preliz_pr314 +arviz-devs_preliz_pr318 +arviz-devs_preliz_pr321 +arviz-devs_preliz_pr327 +arviz-devs_preliz_pr332 +arviz-devs_preliz_pr336 +arviz-devs_preliz_pr337 +arviz-devs_preliz_pr344 +arviz-devs_preliz_pr346 +arviz-devs_preliz_pr347 +arviz-devs_preliz_pr348 +arviz-devs_preliz_pr349 +arviz-devs_preliz_pr35 +arviz-devs_preliz_pr350 +arviz-devs_preliz_pr351 +arviz-devs_preliz_pr352 +arviz-devs_preliz_pr353 +arviz-devs_preliz_pr355 +arviz-devs_preliz_pr356 +arviz-devs_preliz_pr357 +arviz-devs_preliz_pr359 +arviz-devs_preliz_pr360 +arviz-devs_preliz_pr362 +arviz-devs_preliz_pr364 +arviz-devs_preliz_pr368 +arviz-devs_preliz_pr370 +arviz-devs_preliz_pr372 +arviz-devs_preliz_pr373 +arviz-devs_preliz_pr374 +arviz-devs_preliz_pr376 +arviz-devs_preliz_pr382 +arviz-devs_preliz_pr384 +arviz-devs_preliz_pr386 +arviz-devs_preliz_pr387 +arviz-devs_preliz_pr388 +arviz-devs_preliz_pr389 +arviz-devs_preliz_pr391 +arviz-devs_preliz_pr392 +arviz-devs_preliz_pr394 +arviz-devs_preliz_pr395 +arviz-devs_preliz_pr396 +arviz-devs_preliz_pr401 +arviz-devs_preliz_pr403 +arviz-devs_preliz_pr404 +arviz-devs_preliz_pr405 +arviz-devs_preliz_pr407 +arviz-devs_preliz_pr409 +arviz-devs_preliz_pr411 +arviz-devs_preliz_pr414 +arviz-devs_preliz_pr415 +arviz-devs_preliz_pr416 +arviz-devs_preliz_pr419 +arviz-devs_preliz_pr424 +arviz-devs_preliz_pr425 +arviz-devs_preliz_pr434 +arviz-devs_preliz_pr45 +arviz-devs_preliz_pr48 +arviz-devs_preliz_pr50 +arviz-devs_preliz_pr55 +arviz-devs_preliz_pr635 +arviz-devs_preliz_pr636 +arviz-devs_preliz_pr646 +arviz-devs_preliz_pr651 +arviz-devs_preliz_pr658 +arviz-devs_preliz_pr660 +arviz-devs_preliz_pr662 +arviz-devs_preliz_pr663 +arviz-devs_preliz_pr670 +arviz-devs_preliz_pr671 +arviz-devs_preliz_pr94 +arviz-devs_preliz_pr97 +arviz-devs_preliz_pr99 +asottile_add-trailing-comma_pr107 +asottile_add-trailing-comma_pr110 +asottile_add-trailing-comma_pr112 +asottile_add-trailing-comma_pr12 +asottile_add-trailing-comma_pr13 +asottile_add-trailing-comma_pr166 +asottile_add-trailing-comma_pr178 +asottile_add-trailing-comma_pr18 +asottile_add-trailing-comma_pr199 +asottile_add-trailing-comma_pr20 +asottile_add-trailing-comma_pr21 +asottile_add-trailing-comma_pr214 +asottile_add-trailing-comma_pr229 +asottile_add-trailing-comma_pr23 +asottile_add-trailing-comma_pr27 +asottile_add-trailing-comma_pr28 +asottile_add-trailing-comma_pr34 +asottile_add-trailing-comma_pr5 +asottile_add-trailing-comma_pr55 +asottile_add-trailing-comma_pr6 +asottile_add-trailing-comma_pr71 +asottile_add-trailing-comma_pr78 +asottile_add-trailing-comma_pr8 +asottile_add-trailing-comma_pr82 +asottile_add-trailing-comma_pr85 +asottile_add-trailing-comma_pr89 +asottile_astpretty_pr28 +asottile_blacken-docs_pr11 +asottile_blacken-docs_pr12 +asottile_blacken-docs_pr128 +asottile_blacken-docs_pr2 +asottile_blacken-docs_pr202 +asottile_blacken-docs_pr25 +asottile_blacken-docs_pr287 +asottile_blacken-docs_pr333 +asottile_blacken-docs_pr347 +asottile_blacken-docs_pr369 +asottile_blacken-docs_pr375 +asottile_blacken-docs_pr49 +asottile_blacken-docs_pr55 +asottile_blacken-docs_pr71 +asottile_classify-imports_pr106 +asottile_classify-imports_pr112 +asottile_classify-imports_pr139 +asottile_classify-imports_pr15 +asottile_classify-imports_pr19 +asottile_classify-imports_pr3 +asottile_classify-imports_pr53 +asottile_classify-imports_pr65 +asottile_classify-imports_pr8 +asottile_flake8-typing-imports_pr127 +asottile_future-fstrings_pr10 +aspectumapp_osm2geojson_pr55 +assertpy_assertpy_pr152 +assertpy_assertpy_pr96 +astronomer_airflow-provider-fivetran-async_pr101 +astronomer_airflow-provider-fivetran-async_pr6 +astronomer_airflow-provider-great-expectations_pr101 +astronomer_airflow-provider-great-expectations_pr113 +astronomer_airflow-provider-great-expectations_pr116 +astronomer_airflow-provider-great-expectations_pr57 +astronomer_airflow-provider-great-expectations_pr61 +astronomer_airflow-provider-great-expectations_pr75 +astronomer_airflow-provider-great-expectations_pr91 +astropy_astroplan_pr458 +astropy_astroplan_pr507 +astropy_astroplan_pr522 +astropy_astroplan_pr525 +astropy_astroplan_pr528 +astropy_astroplan_pr535 +astropy_astroplan_pr540 +astropy_astroplan_pr551 +astropy_astroplan_pr562 +astropy_astroplan_pr568 +astropy_astroplan_pr581 +astropy_sphinx-automodapi_pr1 +astropy_sphinx-automodapi_pr100 +astropy_sphinx-automodapi_pr127 +astropy_sphinx-automodapi_pr129 +astropy_sphinx-automodapi_pr142 +astropy_sphinx-automodapi_pr24 +astropy_sphinx-automodapi_pr25 +astropy_sphinx-automodapi_pr43 +astropy_sphinx-automodapi_pr44 +astropy_sphinx-automodapi_pr51 +astropy_sphinx-automodapi_pr53 +astropy_sphinx-automodapi_pr75 +astropy_sphinx-automodapi_pr88 +asyncgui_asyncgui_pr1 +asyncgui_asyncgui_pr10 +asyncgui_asyncgui_pr101 +asyncgui_asyncgui_pr124 +asyncgui_asyncgui_pr13 +asyncgui_asyncgui_pr131 +asyncgui_asyncgui_pr3 +asyncgui_asyncgui_pr33 +asyncgui_asyncgui_pr35 +asyncgui_asyncgui_pr37 +asyncgui_asyncgui_pr39 +asyncgui_asyncgui_pr4 +asyncgui_asyncgui_pr41 +asyncgui_asyncgui_pr48 +asyncgui_asyncgui_pr6 +asyncgui_asyncgui_pr61 +asyncgui_asyncgui_pr62 +asyncgui_asyncgui_pr66 +asyncgui_asyncgui_pr69 +asyncgui_asyncgui_pr7 +asyncgui_asyncgui_pr74 +asyncgui_asyncgui_pr78 +asyncgui_asyncgui_pr8 +asyncgui_asyncgui_pr80 +asyncgui_asyncgui_pr86 +asyncgui_asyncgui_pr96 +asyncgui_asyncgui_pr97 +asyncgui_asynckivy_pr101 +asyncgui_asynckivy_pr105 +asyncgui_asynckivy_pr112 +asyncgui_asynckivy_pr121 +asyncgui_asynckivy_pr124 +asyncgui_asynckivy_pr133 +asyncgui_asynckivy_pr138 +asyncgui_asynckivy_pr157 +asyncgui_asynckivy_pr168 +asyncgui_asynckivy_pr17 +asyncgui_asynckivy_pr18 +asyncgui_asynckivy_pr186 +asyncgui_asynckivy_pr191 +asyncgui_asynckivy_pr193 +asyncgui_asynckivy_pr88 +asyncgui_asynckivy_pr90 +asyncgui_asynckivy_pr98 +asyncgui_asynckivy_pr99 +atlanhq_atlan-python_pr37 +atlassian_asap-authentication-python_pr111 +atlassian_asap-authentication-python_pr113 +atlassian_asap-authentication-python_pr114 +atlassian_asap-authentication-python_pr116 +atlassian_asap-authentication-python_pr117 +atlassian_asap-authentication-python_pr118 +atlassian_asap-authentication-python_pr119 +atlassian_asap-authentication-python_pr126 +atlassian_asap-authentication-python_pr130 +atlassian_asap-authentication-python_pr2 +atlassian_asap-authentication-python_pr27 +atlassian_asap-authentication-python_pr3 +atlassian_asap-authentication-python_pr65 +atlassian_asap-authentication-python_pr66 +atlassian_asap-authentication-python_pr69 +atlassian_asap-authentication-python_pr75 +atlassian_asap-authentication-python_pr77 +atlassian_asap-authentication-python_pr78 +atlassian_asap-authentication-python_pr80 +atlassian_asap-authentication-python_pr82 +atlassian_asap-authentication-python_pr83 +atlassian_asap-authentication-python_pr91 +atlassian_asap-authentication-python_pr99 +audreyr_cookiecutter_pr1096 +audreyr_cookiecutter_pr1336 +audreyr_cookiecutter_pr1353 +audreyr_cookiecutter_pr1370 +audreyr_cookiecutter_pr1374 +audreyr_cookiecutter_pr1414 +audreyr_cookiecutter_pr1419 +audreyr_cookiecutter_pr1468 +audreyr_cookiecutter_pr1485 +audreyr_cookiecutter_pr1545 +audreyr_cookiecutter_pr1559 +audreyr_cookiecutter_pr1569 +audreyr_cookiecutter_pr1621 +audreyr_cookiecutter_pr1626 +audreyr_cookiecutter_pr1651 +audreyr_cookiecutter_pr1669 +audreyr_cookiecutter_pr1679 +audreyr_cookiecutter_pr1689 +audreyr_cookiecutter_pr1692 +audreyr_cookiecutter_pr1706 +audreyr_cookiecutter_pr1722 +audreyr_cookiecutter_pr1874 +audreyr_cookiecutter_pr1881 +audreyr_cookiecutter_pr1896 +audreyr_cookiecutter_pr1898 +audreyr_cookiecutter_pr1901 +audreyr_cookiecutter_pr1903 +audreyr_cookiecutter_pr1920 +audreyr_cookiecutter_pr1923 +audreyr_cookiecutter_pr1924 +audreyr_cookiecutter_pr1950 +audreyr_cookiecutter_pr1961 +audreyr_cookiecutter_pr1981 +audreyr_cookiecutter_pr1991 +audreyr_cookiecutter_pr1995 +audreyr_cookiecutter_pr1997 +audreyr_cookiecutter_pr2010 +audreyr_cookiecutter_pr2012 +audreyr_cookiecutter_pr2041 +audreyr_cookiecutter_pr2049 +audreyr_cookiecutter_pr2051 +audreyr_cookiecutter_pr2053 +audreyr_cookiecutter_pr2054 +audreyr_cookiecutter_pr2059 +audreyr_cookiecutter_pr2147 +audreyr_cookiecutter_pr2159 +audreyr_cookiecutter_pr2171 +audreyr_cookiecutter_pr839 +audreyr_cookiecutter_pr906 +audreyr_cookiecutter_pr974 +auth0_auth0-python_pr108 +auth0_auth0-python_pr110 +auth0_auth0-python_pr113 +auth0_auth0-python_pr122 +auth0_auth0-python_pr152 +auth0_auth0-python_pr158 +auth0_auth0-python_pr159 +auth0_auth0-python_pr170 +auth0_auth0-python_pr177 +auth0_auth0-python_pr187 +auth0_auth0-python_pr190 +auth0_auth0-python_pr220 +auth0_auth0-python_pr222 +auth0_auth0-python_pr23 +auth0_auth0-python_pr236 +auth0_auth0-python_pr256 +auth0_auth0-python_pr258 +auth0_auth0-python_pr273 +auth0_auth0-python_pr279 +auth0_auth0-python_pr285 +auth0_auth0-python_pr289 +auth0_auth0-python_pr301 +auth0_auth0-python_pr312 +auth0_auth0-python_pr313 +auth0_auth0-python_pr43 +auth0_auth0-python_pr443 +auth0_auth0-python_pr467 +auth0_auth0-python_pr477 +auth0_auth0-python_pr484 +auth0_auth0-python_pr486 +auth0_auth0-python_pr495 +auth0_auth0-python_pr497 +auth0_auth0-python_pr499 +auth0_auth0-python_pr500 +auth0_auth0-python_pr501 +auth0_auth0-python_pr549 +auth0_auth0-python_pr556 +auth0_auth0-python_pr560 +auth0_auth0-python_pr64 +auth0_auth0-python_pr66 +auth0_auth0-python_pr669 +auth0_auth0-python_pr671 +auth0_auth0-python_pr679 +auth0_auth0-python_pr68 +auth0_auth0-python_pr682 +auth0_auth0-python_pr69 +auth0_auth0-python_pr695 +auth0_auth0-python_pr696 +auth0_auth0-python_pr706 +auth0_auth0-python_pr720 +auth0_auth0-python_pr744 +auth0_auth0-python_pr77 +auth0_auth0-python_pr92 +auth0_auth0-python_pr96 +avian2_jsonmerge_pr19 +avian2_jsonmerge_pr29 +aws-samples_amazon-textract-response-parser_pr134 +aws-samples_amazon-textract-response-parser_pr181 +aws-samples_amazon-textract-response-parser_pr19 +aws-samples_amazon-textract-response-parser_pr24 +aws-samples_amazon-textract-response-parser_pr27 +aws-samples_amazon-textract-response-parser_pr31 +aws-samples_amazon-textract-response-parser_pr42 +aws-samples_amazon-textract-response-parser_pr48 +aws-samples_amazon-textract-response-parser_pr57 +aws_aws-encryption-sdk-cli_pr14 +aws_aws-encryption-sdk-cli_pr47 +aws_aws-encryption-sdk-cli_pr48 +aws_aws-encryption-sdk-cli_pr55 +aws_aws-encryption-sdk-cli_pr60 +aws_aws-encryption-sdk-python_pr47 +awslabs_amazon-sns-python-extended-client-lib_pr21 +awslabs_amazon-sns-python-extended-client-lib_pr9 +awslabs_aws-lambda-builders_pr41 +awslabs_aws-lambda-builders_pr61 +awslabs_aws-serverlessrepo-python_pr16 +awslabs_aws-serverlessrepo-python_pr19 +awslabs_aws-serverlessrepo-python_pr20 +awslabs_aws-serverlessrepo-python_pr25 +awslabs_kinesis-aggregation_pr124 +awslabs_kinesis-aggregation_pr96 +awslabs_mxnet-model-server_pr213 +awslabs_mxnet-model-server_pr303 +awslabs_serverless-application-model_pr1264 +awslabs_serverless-application-model_pr1625 +awslabs_serverless-application-model_pr1756 +awslabs_serverless-application-model_pr1827 +awslabs_serverless-application-model_pr1906 +awslabs_serverless-application-model_pr2050 +awslabs_serverless-application-model_pr2079 +awslabs_serverless-application-model_pr2095 +awslabs_serverless-application-model_pr2165 +awslabs_serverless-application-model_pr2242 +awslabs_serverless-application-model_pr2261 +awslabs_serverless-application-model_pr2362 +backstage_mkdocs-monorepo-plugin_pr120 +backstage_mkdocs-monorepo-plugin_pr86 +backstage_mkdocs-techdocs-core_pr247 +backstage_mkdocs-techdocs-core_pr260 +backstage_mkdocs-techdocs-core_pr279 +bambinos_formulae_pr100 +bambinos_formulae_pr102 +bambinos_formulae_pr33 +bambinos_formulae_pr35 +bambinos_formulae_pr40 +bambinos_formulae_pr41 +bambinos_formulae_pr48 +bambinos_formulae_pr49 +bambinos_formulae_pr52 +bambinos_formulae_pr60 +bambinos_formulae_pr61 +bambinos_formulae_pr71 +bambinos_formulae_pr73 +bambinos_formulae_pr81 +bambinos_formulae_pr85 +bambinos_formulae_pr88 +bambinos_formulae_pr89 +bambinos_formulae_pr90 +banesullivan_scooby_pr118 +banesullivan_scooby_pr119 +banesullivan_scooby_pr41 +banesullivan_scooby_pr61 +banesullivan_scooby_pr64 +banesullivan_scooby_pr76 +banesullivan_scooby_pr86 +banesullivan_scooby_pr87 +barrust_pyprobables_pr116 +barrust_pyprobables_pr14 +barrust_pyprobables_pr17 +barrust_pyprobables_pr24 +barrust_pyprobables_pr34 +barrust_pyprobables_pr45 +barrust_pyprobables_pr5 +barrust_pyprobables_pr64 +barrust_pyprobables_pr66 +barrust_pyprobables_pr68 +barrust_pyprobables_pr69 +barrust_pyprobables_pr70 +barrust_pyprobables_pr77 +barrust_pyprobables_pr80 +barrust_pyprobables_pr81 +barrust_pyprobables_pr84 +barrust_pyprobables_pr85 +barrust_pyprobables_pr86 +barrust_pyprobables_pr90 +barrust_pyprobables_pr95 +barrust_pyprobables_pr96 +bastibe_python-soundfile_pr132 +bastibe_python-soundfile_pr148 +bastibe_python-soundfile_pr152 +bastibe_python-soundfile_pr192 +bastibe_python-soundfile_pr200 +bastibe_python-soundfile_pr36 +bastibe_python-soundfile_pr38 +bastibe_python-soundfile_pr39 +bastibe_python-soundfile_pr46 +bastibe_python-soundfile_pr48 +bastibe_python-soundfile_pr58 +bastikr_boolean.py_pr27 +bastikr_boolean.py_pr32 +bastikr_boolean.py_pr48 +bcwaldon_warlock_pr55 +bdraco_bluetooth-data-tools_pr119 +bdraco_bluetooth-data-tools_pr12 +bdraco_bluetooth-data-tools_pr121 +bdraco_bluetooth-data-tools_pr132 +bdraco_bluetooth-data-tools_pr155 +bdraco_bluetooth-data-tools_pr2 +bdraco_bluetooth-data-tools_pr9 +bdraco_bluetooth-data-tools_pr99 +beetbox_audioread_pr126 +beetbox_beets_pr2554 +beetbox_beets_pr3360 +beetbox_beets_pr3635 +beetbox_beets_pr3637 +beetbox_beets_pr3641 +beetbox_beets_pr3647 +beetbox_beets_pr3658 +beetbox_beets_pr3661 +beetbox_beets_pr3670 +beetbox_beets_pr3671 +beetbox_beets_pr3688 +beetbox_beets_pr3700 +beetbox_beets_pr3702 +beetbox_beets_pr3711 +beetbox_beets_pr3712 +beetbox_beets_pr3721 +beetbox_beets_pr3725 +beetbox_beets_pr3731 +beetbox_beets_pr3746 +beetbox_beets_pr3748 +beetbox_beets_pr3755 +beetbox_beets_pr3761 +beetbox_beets_pr3764 +beetbox_beets_pr3765 +beetbox_beets_pr3766 +beetbox_beets_pr3774 +beetbox_beets_pr3786 +beetbox_beets_pr3805 +beetbox_beets_pr3810 +beetbox_beets_pr3811 +beetbox_beets_pr3814 +beetbox_beets_pr3816 +beetbox_beets_pr3818 +beetbox_beets_pr3824 +beetbox_beets_pr3825 +beetbox_beets_pr3831 +beetbox_beets_pr3832 +beetbox_beets_pr3848 +beetbox_beets_pr3863 +beetbox_beets_pr3868 +beetbox_beets_pr3869 +beetbox_beets_pr3873 +beetbox_beets_pr3877 +beetbox_beets_pr3883 +beetbox_beets_pr3900 +beetbox_beets_pr3901 +beetbox_beets_pr3905 +beetbox_beets_pr3923 +beetbox_beets_pr3927 +beetbox_beets_pr3929 +beetbox_beets_pr3942 +beetbox_beets_pr3980 +beetbox_beets_pr3982 +beetbox_beets_pr3995 +beetbox_beets_pr3996 +beetbox_beets_pr4008 +beetbox_beets_pr4036 +beetbox_beets_pr4045 +beetbox_beets_pr4048 +beetbox_beets_pr4086 +beetbox_beets_pr4095 +beetbox_beets_pr4124 +beetbox_beets_pr4125 +beetbox_beets_pr4129 +beetbox_beets_pr4133 +beetbox_beets_pr4140 +beetbox_beets_pr4146 +beetbox_beets_pr4147 +beetbox_beets_pr4148 +beetbox_beets_pr4153 +beetbox_beets_pr4155 +beetbox_beets_pr4160 +beetbox_beets_pr4177 +beetbox_beets_pr4190 +beetbox_beets_pr4195 +beetbox_beets_pr4196 +beetbox_beets_pr4197 +beetbox_beets_pr4198 +beetbox_beets_pr4199 +beetbox_beets_pr4200 +beetbox_beets_pr4209 +beetbox_beets_pr4226 +beetbox_beets_pr4227 +beetbox_beets_pr4229 +beetbox_beets_pr4251 +beetbox_beets_pr4263 +beetbox_beets_pr4275 +beetbox_beets_pr4303 +beetbox_beets_pr4304 +beetbox_beets_pr4313 +beetbox_beets_pr4319 +beetbox_beets_pr4327 +beetbox_beets_pr4333 +beetbox_beets_pr4348 +beetbox_beets_pr4352 +beetbox_beets_pr4359 +beetbox_beets_pr4370 +beetbox_beets_pr4374 +beetbox_beets_pr4386 +beetbox_beets_pr4387 +beetbox_beets_pr4390 +beetbox_beets_pr4396 +beetbox_beets_pr4399 +beetbox_beets_pr4405 +beetbox_beets_pr4413 +beetbox_beets_pr4431 +beetbox_beets_pr4441 +beetbox_beets_pr4450 +beetbox_beets_pr4496 +beetbox_beets_pr4504 +beetbox_beets_pr4507 +beetbox_beets_pr4515 +beetbox_beets_pr4521 +beetbox_beets_pr4546 +beetbox_beets_pr4547 +beetbox_beets_pr4549 +beetbox_beets_pr4564 +beetbox_beets_pr4579 +beetbox_beets_pr4588 +beetbox_beets_pr4633 +beetbox_beets_pr4634 +beetbox_beets_pr4636 +beetbox_beets_pr4663 +beetbox_beets_pr4677 +beetbox_beets_pr4679 +beetbox_beets_pr4698 +beetbox_beets_pr4708 +beetbox_beets_pr4714 +beetbox_beets_pr4719 +beetbox_beets_pr4735 +beetbox_beets_pr4743 +beetbox_beets_pr4744 +beetbox_beets_pr4771 +beetbox_beets_pr4774 +beetbox_beets_pr4775 +beetbox_beets_pr4778 +beetbox_beets_pr4781 +beetbox_beets_pr4804 +beetbox_beets_pr4805 +beetbox_beets_pr4807 +beetbox_beets_pr4808 +beetbox_beets_pr4809 +beetbox_beets_pr4823 +beetbox_beets_pr4826 +beetbox_beets_pr4827 +beetbox_beets_pr4828 +beetbox_beets_pr4830 +beetbox_beets_pr4834 +beetbox_beets_pr4842 +beetbox_beets_pr4849 +beetbox_beets_pr4850 +beetbox_beets_pr4851 +beetbox_beets_pr4854 +beetbox_beets_pr4858 +beetbox_beets_pr4863 +beetbox_beets_pr4899 +beetbox_beets_pr4900 +beetbox_beets_pr4906 +beetbox_beets_pr4940 +beetbox_beets_pr4952 +beetbox_beets_pr4971 +beetbox_beets_pr4984 +beetbox_beets_pr4996 +beetbox_beets_pr5007 +beetbox_beets_pr5022 +beetbox_beets_pr5044 +beetbox_beets_pr5046 +beetbox_beets_pr5048 +beetbox_beets_pr5052 +beetbox_beets_pr5053 +beetbox_beets_pr5063 +beetbox_beets_pr5068 +beetbox_beets_pr5081 +beetbox_beets_pr5089 +beetbox_beets_pr5121 +beetbox_beets_pr5123 +beetbox_beets_pr5134 +beetbox_beets_pr5149 +beetbox_beets_pr5152 +beetbox_beets_pr5153 +beetbox_beets_pr5160 +beetbox_beets_pr5214 +beetbox_beets_pr5239 +beetbox_beets_pr5244 +beetbox_beets_pr5262 +beetbox_beets_pr5274 +beetbox_beets_pr5282 +beetbox_beets_pr5288 +beetbox_beets_pr5301 +beetbox_beets_pr5308 +beetbox_beets_pr5327 +beetbox_beets_pr5352 +beetbox_beets_pr5356 +beetbox_beets_pr5357 +beetbox_beets_pr5362 +beetbox_beets_pr5385 +beetbox_beets_pr5386 +beetbox_beets_pr5388 +beetbox_beets_pr5393 +beetbox_beets_pr5409 +beetbox_beets_pr5415 +beetbox_beets_pr5421 +beetbox_beets_pr5437 +beetbox_beets_pr5442 +beetbox_beets_pr5447 +beetbox_beets_pr5457 +beetbox_beets_pr5470 +beetbox_beets_pr5480 +beetbox_beets_pr5495 +beetbox_beets_pr5520 +beetbox_beets_pr5536 +beetbox_beets_pr5540 +beetbox_confuse_pr1 +beetbox_confuse_pr104 +beetbox_confuse_pr129 +beetbox_confuse_pr142 +beetbox_confuse_pr149 +beetbox_confuse_pr171 +beetbox_confuse_pr180 +beetbox_confuse_pr50 +beetbox_confuse_pr78 +beetbox_confuse_pr79 +beetbox_confuse_pr92 +beetbox_mediafile_pr16 +beetbox_mediafile_pr58 +beetbox_mediafile_pr86 +belerico_py-asciimath_pr4 +belerico_py-asciimath_pr6 +bellini666_django-choices-field_pr28 +bellockk_alphashape_pr12 +benhoyt_graphyte_pr11 +benhoyt_graphyte_pr18 +bennylope_pydiscourse_pr15 +bennylope_pydiscourse_pr16 +bennylope_pydiscourse_pr3 +bennylope_pydiscourse_pr74 +bennylope_pydiscourse_pr82 +bennylope_pydiscourse_pr9 +bennylope_pydiscourse_pr91 +berkerpeksag_astor_pr133 +berkerpeksag_astor_pr134 +berkerpeksag_astor_pr137 +berkerpeksag_astor_pr139 +berkerpeksag_astor_pr141 +berkerpeksag_astor_pr143 +berkerpeksag_astor_pr155 +berkerpeksag_astor_pr163 +berkerpeksag_astor_pr164 +berkerpeksag_astor_pr219 +berkerpeksag_astor_pr222 +best-doctor_flake8-annotations-complexity_pr23 +best-doctor_flake8-class-attributes-order_pr13 +best-doctor_flake8-class-attributes-order_pr17 +best-doctor_flake8-functions_pr5 +betodealmeida_python-rison_pr7 +betodealmeida_shillelagh_pr507 +betodealmeida_shillelagh_pr514 +betodealmeida_shillelagh_pr518 +betodealmeida_shillelagh_pr525 +betodealmeida_shillelagh_pr527 +betodealmeida_shillelagh_pr531 +betodealmeida_shillelagh_pr532 +bharel_asynciolimiter_pr15 +bids-standard_pybids_pr1016 +bids-standard_pybids_pr1023 +bids-standard_pybids_pr1034 +bids-standard_pybids_pr1059 +bids-standard_pybids_pr1075 +bids-standard_pybids_pr1087 +bids-standard_pybids_pr15 +bids-standard_pybids_pr17 +bids-standard_pybids_pr297 +bids-standard_pybids_pr298 +bids-standard_pybids_pr303 +bids-standard_pybids_pr306 +bids-standard_pybids_pr307 +bids-standard_pybids_pr309 +bids-standard_pybids_pr321 +bids-standard_pybids_pr327 +bids-standard_pybids_pr34 +bids-standard_pybids_pr341 +bids-standard_pybids_pr351 +bids-standard_pybids_pr36 +bids-standard_pybids_pr39 +bids-standard_pybids_pr396 +bids-standard_pybids_pr424 +bids-standard_pybids_pr432 +bids-standard_pybids_pr443 +bids-standard_pybids_pr444 +bids-standard_pybids_pr449 +bids-standard_pybids_pr457 +bids-standard_pybids_pr458 +bids-standard_pybids_pr463 +bids-standard_pybids_pr467 +bids-standard_pybids_pr468 +bids-standard_pybids_pr471 +bids-standard_pybids_pr477 +bids-standard_pybids_pr485 +bids-standard_pybids_pr488 +bids-standard_pybids_pr492 +bids-standard_pybids_pr494 +bids-standard_pybids_pr495 +bids-standard_pybids_pr496 +bids-standard_pybids_pr497 +bids-standard_pybids_pr508 +bids-standard_pybids_pr511 +bids-standard_pybids_pr520 +bids-standard_pybids_pr523 +bids-standard_pybids_pr529 +bids-standard_pybids_pr540 +bids-standard_pybids_pr541 +bids-standard_pybids_pr547 +bids-standard_pybids_pr548 +bids-standard_pybids_pr560 +bids-standard_pybids_pr568 +bids-standard_pybids_pr569 +bids-standard_pybids_pr571 +bids-standard_pybids_pr574 +bids-standard_pybids_pr576 +bids-standard_pybids_pr580 +bids-standard_pybids_pr589 +bids-standard_pybids_pr593 +bids-standard_pybids_pr601 +bids-standard_pybids_pr607 +bids-standard_pybids_pr610 +bids-standard_pybids_pr611 +bids-standard_pybids_pr612 +bids-standard_pybids_pr613 +bids-standard_pybids_pr615 +bids-standard_pybids_pr62 +bids-standard_pybids_pr620 +bids-standard_pybids_pr623 +bids-standard_pybids_pr629 +bids-standard_pybids_pr637 +bids-standard_pybids_pr638 +bids-standard_pybids_pr642 +bids-standard_pybids_pr645 +bids-standard_pybids_pr647 +bids-standard_pybids_pr649 +bids-standard_pybids_pr65 +bids-standard_pybids_pr669 +bids-standard_pybids_pr67 +bids-standard_pybids_pr672 +bids-standard_pybids_pr682 +bids-standard_pybids_pr688 +bids-standard_pybids_pr695 +bids-standard_pybids_pr705 +bids-standard_pybids_pr713 +bids-standard_pybids_pr73 +bids-standard_pybids_pr76 +bids-standard_pybids_pr799 +bids-standard_pybids_pr809 +bids-standard_pybids_pr819 +bids-standard_pybids_pr822 +bids-standard_pybids_pr836 +bids-standard_pybids_pr838 +bids-standard_pybids_pr840 +bids-standard_pybids_pr846 +bids-standard_pybids_pr848 +bids-standard_pybids_pr853 +bids-standard_pybids_pr854 +bids-standard_pybids_pr859 +bids-standard_pybids_pr861 +bids-standard_pybids_pr866 +bids-standard_pybids_pr869 +bids-standard_pybids_pr886 +bids-standard_pybids_pr891 +bids-standard_pybids_pr892 +bids-standard_pybids_pr894 +bids-standard_pybids_pr901 +bids-standard_pybids_pr902 +bids-standard_pybids_pr906 +bids-standard_pybids_pr913 +bids-standard_pybids_pr918 +bids-standard_pybids_pr942 +bids-standard_pybids_pr971 +bigjason_django-choices_pr13 +bigjason_django-choices_pr17 +biocommons_biocommons.seqrepo_pr161 +biocommons_biocommons.seqrepo_pr172 +biocommons_biocommons.seqrepo_pr190 +biopragmatics_bioregistry_pr104 +biopragmatics_bioregistry_pr113 +biopragmatics_bioregistry_pr134 +biopragmatics_bioregistry_pr135 +biopragmatics_bioregistry_pr136 +biopragmatics_bioregistry_pr138 +biopragmatics_bioregistry_pr146 +biopragmatics_bioregistry_pr15 +biopragmatics_bioregistry_pr159 +biopragmatics_bioregistry_pr164 +biopragmatics_bioregistry_pr169 +biopragmatics_bioregistry_pr178 +biopragmatics_bioregistry_pr189 +biopragmatics_bioregistry_pr194 +biopragmatics_bioregistry_pr195 +biopragmatics_bioregistry_pr198 +biopragmatics_bioregistry_pr201 +biopragmatics_bioregistry_pr204 +biopragmatics_bioregistry_pr207 +biopragmatics_bioregistry_pr209 +biopragmatics_bioregistry_pr212 +biopragmatics_bioregistry_pr213 +biopragmatics_bioregistry_pr214 +biopragmatics_bioregistry_pr225 +biopragmatics_bioregistry_pr238 +biopragmatics_bioregistry_pr24 +biopragmatics_bioregistry_pr252 +biopragmatics_bioregistry_pr254 +biopragmatics_bioregistry_pr255 +biopragmatics_bioregistry_pr260 +biopragmatics_bioregistry_pr266 +biopragmatics_bioregistry_pr271 +biopragmatics_bioregistry_pr276 +biopragmatics_bioregistry_pr277 +biopragmatics_bioregistry_pr282 +biopragmatics_bioregistry_pr286 +biopragmatics_bioregistry_pr289 +biopragmatics_bioregistry_pr292 +biopragmatics_bioregistry_pr297 +biopragmatics_bioregistry_pr298 +biopragmatics_bioregistry_pr299 +biopragmatics_bioregistry_pr302 +biopragmatics_bioregistry_pr316 +biopragmatics_bioregistry_pr319 +biopragmatics_bioregistry_pr322 +biopragmatics_bioregistry_pr351 +biopragmatics_bioregistry_pr352 +biopragmatics_bioregistry_pr355 +biopragmatics_bioregistry_pr356 +biopragmatics_bioregistry_pr78 +biopragmatics_bioregistry_pr79 +biopragmatics_bioregistry_pr8 +biopragmatics_bioregistry_pr81 +biopragmatics_bioregistry_pr84 +biopragmatics_bioregistry_pr86 +biopragmatics_bioregistry_pr92 +biopragmatics_bioversions_pr80 +biopragmatics_bioversions_pr84 +biopragmatics_bioversions_pr89 +biopragmatics_curies_pr1 +biopragmatics_curies_pr134 +biopragmatics_curies_pr149 +biopragmatics_curies_pr159 +biopragmatics_curies_pr164 +biopragmatics_curies_pr167 +biopragmatics_curies_pr172 +biopragmatics_curies_pr187 +biopragmatics_curies_pr191 +biopragmatics_curies_pr199 +biopragmatics_curies_pr2 +biopragmatics_curies_pr200 +biopragmatics_curies_pr204 +blackducksoftware_hub-rest-api-python_pr101 +blackducksoftware_hub-rest-api-python_pr107 +blackducksoftware_hub-rest-api-python_pr111 +blackducksoftware_hub-rest-api-python_pr114 +blackducksoftware_hub-rest-api-python_pr120 +blackducksoftware_hub-rest-api-python_pr121 +blackducksoftware_hub-rest-api-python_pr127 +blackducksoftware_hub-rest-api-python_pr140 +blackducksoftware_hub-rest-api-python_pr141 +blackducksoftware_hub-rest-api-python_pr143 +blackducksoftware_hub-rest-api-python_pr145 +blackducksoftware_hub-rest-api-python_pr148 +blackducksoftware_hub-rest-api-python_pr149 +blackducksoftware_hub-rest-api-python_pr152 +blackducksoftware_hub-rest-api-python_pr155 +blackducksoftware_hub-rest-api-python_pr157 +blackducksoftware_hub-rest-api-python_pr158 +blackducksoftware_hub-rest-api-python_pr169 +blackducksoftware_hub-rest-api-python_pr181 +blackducksoftware_hub-rest-api-python_pr182 +blackducksoftware_hub-rest-api-python_pr194 +blackducksoftware_hub-rest-api-python_pr195 +blackducksoftware_hub-rest-api-python_pr205 +blackducksoftware_hub-rest-api-python_pr208 +blackducksoftware_hub-rest-api-python_pr213 +blackducksoftware_hub-rest-api-python_pr222 +blackducksoftware_hub-rest-api-python_pr226 +blackducksoftware_hub-rest-api-python_pr229 +blackducksoftware_hub-rest-api-python_pr232 +blackducksoftware_hub-rest-api-python_pr234 +blackducksoftware_hub-rest-api-python_pr246 +blackducksoftware_hub-rest-api-python_pr261 +blackducksoftware_hub-rest-api-python_pr262 +blackducksoftware_hub-rest-api-python_pr271 +blackducksoftware_hub-rest-api-python_pr282 +blackducksoftware_hub-rest-api-python_pr284 +blackducksoftware_hub-rest-api-python_pr285 +blackducksoftware_hub-rest-api-python_pr286 +blackducksoftware_hub-rest-api-python_pr291 +blackducksoftware_hub-rest-api-python_pr60 +blackducksoftware_hub-rest-api-python_pr62 +blackducksoftware_hub-rest-api-python_pr74 +blackducksoftware_hub-rest-api-python_pr75 +blackducksoftware_hub-rest-api-python_pr77 +blackducksoftware_hub-rest-api-python_pr80 +blackducksoftware_hub-rest-api-python_pr81 +blackducksoftware_hub-rest-api-python_pr95 +blackducksoftware_hub-rest-api-python_pr99 +blake-r_pytest-durations_pr29 +blake-r_pytest-durations_pr34 +blambright_qstylizer_pr5 +bluesky_event-model_pr104 +bluesky_event-model_pr105 +bluesky_event-model_pr113 +bluesky_event-model_pr116 +bluesky_event-model_pr117 +bluesky_event-model_pr118 +bluesky_event-model_pr122 +bluesky_event-model_pr131 +bluesky_event-model_pr133 +bluesky_event-model_pr139 +bluesky_event-model_pr158 +bluesky_event-model_pr159 +bluesky_event-model_pr161 +bluesky_event-model_pr162 +bluesky_event-model_pr166 +bluesky_event-model_pr178 +bluesky_event-model_pr179 +bluesky_event-model_pr184 +bluesky_event-model_pr192 +bluesky_event-model_pr195 +bluesky_event-model_pr210 +bluesky_event-model_pr212 +bluesky_event-model_pr222 +bluesky_event-model_pr24 +bluesky_event-model_pr247 +bluesky_event-model_pr257 +bluesky_event-model_pr258 +bluesky_event-model_pr264 +bluesky_event-model_pr272 +bluesky_event-model_pr273 +bluesky_event-model_pr275 +bluesky_event-model_pr277 +bluesky_event-model_pr28 +bluesky_event-model_pr289 +bluesky_event-model_pr29 +bluesky_event-model_pr316 +bluesky_event-model_pr33 +bluesky_event-model_pr40 +bluesky_event-model_pr41 +bluesky_event-model_pr43 +bluesky_event-model_pr59 +bluesky_event-model_pr65 +bluesky_event-model_pr67 +bluesky_event-model_pr79 +bluesky_event-model_pr90 +bluesky_event-model_pr92 +bluesky_event-model_pr95 +bluetooth-devices_aiooui_pr33 +bluetooth-devices_aiooui_pr5 +bluetooth-devices_bleak-retry-connector_pr57 +bluetooth-devices_bleak-retry-connector_pr58 +bluetooth-devices_bleak-retry-connector_pr61 +bluetooth-devices_bleak-retry-connector_pr67 +bluetooth-devices_bleak-retry-connector_pr68 +bluetooth-devices_bleak-retry-connector_pr72 +bluetooth-devices_bleak-retry-connector_pr74 +bluetooth-devices_bluetooth-adapters_pr102 +bluetooth-devices_bluetooth-adapters_pr105 +bluetooth-devices_bluetooth-adapters_pr19 +bluetooth-devices_bluetooth-adapters_pr21 +bluetooth-devices_bluetooth-adapters_pr34 +bluetooth-devices_bluetooth-adapters_pr57 +bluetooth-devices_bluetooth-adapters_pr71 +bluetooth-devices_bluetooth-adapters_pr89 +bluetooth-devices_bluetooth-auto-recovery_pr13 +bluetooth-devices_bluetooth-auto-recovery_pr15 +bluetooth-devices_bluetooth-auto-recovery_pr18 +bluetooth-devices_bluetooth-auto-recovery_pr2 +bluetooth-devices_bluetooth-auto-recovery_pr24 +bluetooth-devices_bluetooth-auto-recovery_pr25 +bluetooth-devices_bluetooth-auto-recovery_pr26 +bluetooth-devices_bluetooth-auto-recovery_pr27 +bluetooth-devices_bluetooth-auto-recovery_pr31 +bluetooth-devices_bluetooth-auto-recovery_pr33 +bluetooth-devices_bluetooth-auto-recovery_pr34 +bluetooth-devices_bluetooth-auto-recovery_pr5 +bluetooth-devices_bluetooth-auto-recovery_pr89 +bluetooth-devices_bluetooth-auto-recovery_pr9 +bluetooth-devices_cached-ipaddress_pr26 +bluetooth-devices_habluetooth_pr153 +bluetooth-devices_habluetooth_pr155 +bluetooth-devices_ulid-transform_pr18 +bobthemighty_punq_pr10 +bobthemighty_punq_pr191 +bottlepy_bottle_pr1246 +bottlepy_bottle_pr1354 +bottlepy_bottle_pr1459 +bottlepy_bottle_pr550 +bottlepy_bottle_pr673 +bottlepy_bottle_pr716 +bottlepy_bottle_pr778 +bottlepy_bottle_pr787 +box_box-python-sdk_pr705 +box_box-python-sdk_pr710 +box_box-python-sdk_pr716 +bqplot_bqplot_pr1017 +bqplot_bqplot_pr1032 +bqplot_bqplot_pr1047 +bqplot_bqplot_pr1059 +bqplot_bqplot_pr1064 +bqplot_bqplot_pr1084 +bqplot_bqplot_pr1311 +bqplot_bqplot_pr1320 +bqplot_bqplot_pr1335 +bqplot_bqplot_pr1364 +bqplot_bqplot_pr1365 +bqplot_bqplot_pr1366 +bqplot_bqplot_pr1382 +bqplot_bqplot_pr750 +bqplot_bqplot_pr755 +bqplot_bqplot_pr772 +bqplot_bqplot_pr807 +bqplot_bqplot_pr811 +bqplot_bqplot_pr828 +bqplot_bqplot_pr835 +bqplot_bqplot_pr837 +bqplot_bqplot_pr861 +bqplot_bqplot_pr870 +bqplot_bqplot_pr909 +bqplot_bqplot_pr914 +bqplot_bqplot_pr968 +bqplot_bqplot_pr974 +bqplot_bqplot_pr976 +bqplot_bqplot_pr980 +bqplot_bqplot_pr998 +brack3t_django-braces_pr275 +brack3t_django-braces_pr286 +brack3t_django-braces_pr305 +brandon-rhodes_python-skyfield_pr49 +brandon-rhodes_python-skyfield_pr51 +breid48_cacheing_pr16 +breid48_cacheing_pr20 +breid48_cacheing_pr26 +breid48_cacheing_pr5 +breid48_cacheing_pr9 +brentvollebregt_auto-py-to-exe_pr456 +bretello_pdbpp_pr28 +brettcannon_gidgethub_pr122 +brettcannon_gidgethub_pr131 +brettcannon_gidgethub_pr134 +brettcannon_gidgethub_pr14 +brettcannon_gidgethub_pr160 +brettcannon_gidgethub_pr170 +brettcannon_gidgethub_pr174 +brettcannon_gidgethub_pr18 +brettcannon_gidgethub_pr184 +brettcannon_gidgethub_pr215 +brettcannon_gidgethub_pr225 +brettcannon_gidgethub_pr31 +brettcannon_gidgethub_pr32 +brettcannon_gidgethub_pr34 +brettcannon_gidgethub_pr35 +brettcannon_gidgethub_pr37 +brettcannon_gidgethub_pr38 +brettcannon_gidgethub_pr5 +brettcannon_gidgethub_pr50 +brettcannon_gidgethub_pr51 +brettcannon_gidgethub_pr57 +brettcannon_gidgethub_pr62 +brettcannon_gidgethub_pr68 +bridgecrewio_jsonpath-ng_pr2 +bridgecrewio_python-hcl2_pr17 +bridgecrewio_python-hcl2_pr18 +bridgecrewio_python-hcl2_pr27 +bridgecrewio_python-hcl2_pr29 +bridgecrewio_python-hcl2_pr32 +brightway-lca_brightway2-calc_pr128 +brightway-lca_brightway2-data_pr207 +brightway-lca_brightway2-data_pr246 +browserbase_stagehand-python_pr12 +btubbs_sseclient_pr35 +btubbs_sseclient_pr64 +bufbuild_protovalidate-python_pr112 +bufbuild_protovalidate-python_pr174 +bufbuild_protovalidate-python_pr217 +bufbuild_protovalidate-python_pr308 +bufbuild_protovalidate-python_pr317 +bufbuild_protovalidate-python_pr319 +bufbuild_protovalidate-python_pr32 +bufbuild_protovalidate-python_pr321 +bufbuild_protovalidate-python_pr323 +bufbuild_protovalidate-python_pr325 +bufbuild_protovalidate-python_pr338 +bufbuild_protovalidate-python_pr346 +bufbuild_protovalidate-python_pr348 +bufbuild_protovalidate-python_pr358 +bufbuild_protovalidate-python_pr359 +bufbuild_protovalidate-python_pr360 +bufbuild_protovalidate-python_pr363 +bufbuild_protovalidate-python_pr364 +bufbuild_protovalidate-python_pr370 +bufbuild_protovalidate-python_pr64 +buildkite_test-collector-python_pr12 +buildkite_test-collector-python_pr2 +buildkite_test-collector-python_pr32 +buildkite_test-collector-python_pr38 +buildkite_test-collector-python_pr44 +buildkite_test-collector-python_pr58 +buildkite_test-collector-python_pr61 +buildkite_test-collector-python_pr65 +buildkite_test-collector-python_pr67 +buildkite_test-collector-python_pr69 +buildkite_test-collector-python_pr71 +buriy_python-readability_pr190 +burnash_gspread_pr1004 +burnash_gspread_pr1008 +burnash_gspread_pr1010 +burnash_gspread_pr1012 +burnash_gspread_pr1013 +burnash_gspread_pr1021 +burnash_gspread_pr1030 +burnash_gspread_pr1040 +burnash_gspread_pr1042 +burnash_gspread_pr1047 +burnash_gspread_pr1049 +burnash_gspread_pr1063 +burnash_gspread_pr1077 +burnash_gspread_pr1092 +burnash_gspread_pr1095 +burnash_gspread_pr1115 +burnash_gspread_pr1119 +burnash_gspread_pr1138 +burnash_gspread_pr1140 +burnash_gspread_pr1189 +burnash_gspread_pr1199 +burnash_gspread_pr1207 +burnash_gspread_pr1211 +burnash_gspread_pr1215 +burnash_gspread_pr1225 +burnash_gspread_pr1233 +burnash_gspread_pr1256 +burnash_gspread_pr1269 +burnash_gspread_pr1271 +burnash_gspread_pr1274 +burnash_gspread_pr1277 +burnash_gspread_pr1278 +burnash_gspread_pr1291 +burnash_gspread_pr1299 +burnash_gspread_pr1301 +burnash_gspread_pr1305 +burnash_gspread_pr1308 +burnash_gspread_pr1324 +burnash_gspread_pr1333 +burnash_gspread_pr1335 +burnash_gspread_pr1357 +burnash_gspread_pr1364 +burnash_gspread_pr1384 +burnash_gspread_pr1392 +burnash_gspread_pr1397 +burnash_gspread_pr1402 +burnash_gspread_pr1404 +burnash_gspread_pr1415 +burnash_gspread_pr1417 +burnash_gspread_pr1427 +burnash_gspread_pr1448 +burnash_gspread_pr1458 +burnash_gspread_pr1461 +burnash_gspread_pr1463 +burnash_gspread_pr1469 +burnash_gspread_pr1475 +burnash_gspread_pr1477 +burnash_gspread_pr1487 +burnash_gspread_pr1498 +burnash_gspread_pr1531 +burnash_gspread_pr941 +burnash_gspread_pr945 +burnash_gspread_pr948 +burnash_gspread_pr954 +burnash_gspread_pr956 +burnash_gspread_pr967 +burnash_gspread_pr979 +burnash_gspread_pr982 +burnash_gspread_pr984 +burnash_gspread_pr990 +burnash_gspread_pr992 +businho_pytest-ruff_pr25 +butler54_mdformat-frontmatter_pr5 +bxparks_bigquery-schema-generator_pr99 +c2nes_javalang_pr23 +c4deszes_ldfparser_pr106 +c4deszes_ldfparser_pr108 +c4deszes_ldfparser_pr11 +c4deszes_ldfparser_pr114 +c4deszes_ldfparser_pr116 +c4deszes_ldfparser_pr135 +c4deszes_ldfparser_pr139 +c4deszes_ldfparser_pr15 +c4deszes_ldfparser_pr16 +c4deszes_ldfparser_pr40 +c4deszes_ldfparser_pr59 +c4deszes_ldfparser_pr62 +c4deszes_ldfparser_pr67 +c4deszes_ldfparser_pr75 +c4deszes_ldfparser_pr76 +c4deszes_ldfparser_pr80 +c4deszes_ldfparser_pr90 +c4deszes_ldfparser_pr94 +c4deszes_ldfparser_pr97 +calmjs_calmjs.parse_pr41 +calmjs_calmjs.parse_pr44 +canimus_cuallee_pr13 +canimus_cuallee_pr14 +canimus_cuallee_pr17 +canimus_cuallee_pr18 +canimus_cuallee_pr20 +canimus_cuallee_pr27 +canimus_cuallee_pr28 +canimus_cuallee_pr8 +canonical_operator_pr1000 +canonical_operator_pr1001 +canonical_operator_pr1005 +canonical_operator_pr101 +canonical_operator_pr1013 +canonical_operator_pr1014 +canonical_operator_pr1017 +canonical_operator_pr1018 +canonical_operator_pr1024 +canonical_operator_pr1028 +canonical_operator_pr1032 +canonical_operator_pr1038 +canonical_operator_pr1041 +canonical_operator_pr1048 +canonical_operator_pr1049 +canonical_operator_pr1053 +canonical_operator_pr1054 +canonical_operator_pr1057 +canonical_operator_pr1067 +canonical_operator_pr1068 +canonical_operator_pr107 +canonical_operator_pr1074 +canonical_operator_pr1076 +canonical_operator_pr108 +canonical_operator_pr1082 +canonical_operator_pr1084 +canonical_operator_pr1086 +canonical_operator_pr1087 +canonical_operator_pr109 +canonical_operator_pr1091 +canonical_operator_pr110 +canonical_operator_pr1100 +canonical_operator_pr1106 +canonical_operator_pr1107 +canonical_operator_pr1111 +canonical_operator_pr1114 +canonical_operator_pr1122 +canonical_operator_pr1124 +canonical_operator_pr1134 +canonical_operator_pr1138 +canonical_operator_pr114 +canonical_operator_pr1142 +canonical_operator_pr1146 +canonical_operator_pr1147 +canonical_operator_pr1150 +canonical_operator_pr1151 +canonical_operator_pr1152 +canonical_operator_pr1155 +canonical_operator_pr1167 +canonical_operator_pr1170 +canonical_operator_pr1176 +canonical_operator_pr1181 +canonical_operator_pr1183 +canonical_operator_pr1189 +canonical_operator_pr1197 +canonical_operator_pr1209 +canonical_operator_pr121 +canonical_operator_pr1215 +canonical_operator_pr1247 +canonical_operator_pr1248 +canonical_operator_pr1267 +canonical_operator_pr1268 +canonical_operator_pr1281 +canonical_operator_pr129 +canonical_operator_pr1313 +canonical_operator_pr133 +canonical_operator_pr1338 +canonical_operator_pr1369 +canonical_operator_pr1370 +canonical_operator_pr1374 +canonical_operator_pr138 +canonical_operator_pr1381 +canonical_operator_pr1386 +canonical_operator_pr140 +canonical_operator_pr146 +canonical_operator_pr147 +canonical_operator_pr149 +canonical_operator_pr157 +canonical_operator_pr159 +canonical_operator_pr163 +canonical_operator_pr191 +canonical_operator_pr195 +canonical_operator_pr199 +canonical_operator_pr203 +canonical_operator_pr209 +canonical_operator_pr221 +canonical_operator_pr230 +canonical_operator_pr232 +canonical_operator_pr233 +canonical_operator_pr236 +canonical_operator_pr238 +canonical_operator_pr246 +canonical_operator_pr248 +canonical_operator_pr259 +canonical_operator_pr264 +canonical_operator_pr279 +canonical_operator_pr283 +canonical_operator_pr284 +canonical_operator_pr287 +canonical_operator_pr294 +canonical_operator_pr296 +canonical_operator_pr298 +canonical_operator_pr299 +canonical_operator_pr311 +canonical_operator_pr312 +canonical_operator_pr318 +canonical_operator_pr319 +canonical_operator_pr320 +canonical_operator_pr322 +canonical_operator_pr324 +canonical_operator_pr327 +canonical_operator_pr338 +canonical_operator_pr340 +canonical_operator_pr349 +canonical_operator_pr350 +canonical_operator_pr352 +canonical_operator_pr359 +canonical_operator_pr360 +canonical_operator_pr361 +canonical_operator_pr364 +canonical_operator_pr369 +canonical_operator_pr374 +canonical_operator_pr379 +canonical_operator_pr393 +canonical_operator_pr399 +canonical_operator_pr406 +canonical_operator_pr411 +canonical_operator_pr412 +canonical_operator_pr413 +canonical_operator_pr415 +canonical_operator_pr418 +canonical_operator_pr419 +canonical_operator_pr422 +canonical_operator_pr436 +canonical_operator_pr439 +canonical_operator_pr440 +canonical_operator_pr46 +canonical_operator_pr47 +canonical_operator_pr52 +canonical_operator_pr53 +canonical_operator_pr54 +canonical_operator_pr55 +canonical_operator_pr56 +canonical_operator_pr57 +canonical_operator_pr580 +canonical_operator_pr59 +canonical_operator_pr593 +canonical_operator_pr61 +canonical_operator_pr62 +canonical_operator_pr628 +canonical_operator_pr629 +canonical_operator_pr63 +canonical_operator_pr630 +canonical_operator_pr635 +canonical_operator_pr640 +canonical_operator_pr641 +canonical_operator_pr645 +canonical_operator_pr648 +canonical_operator_pr653 +canonical_operator_pr658 +canonical_operator_pr659 +canonical_operator_pr666 +canonical_operator_pr667 +canonical_operator_pr668 +canonical_operator_pr669 +canonical_operator_pr67 +canonical_operator_pr672 +canonical_operator_pr674 +canonical_operator_pr677 +canonical_operator_pr68 +canonical_operator_pr680 +canonical_operator_pr686 +canonical_operator_pr69 +canonical_operator_pr702 +canonical_operator_pr709 +canonical_operator_pr712 +canonical_operator_pr715 +canonical_operator_pr72 +canonical_operator_pr724 +canonical_operator_pr727 +canonical_operator_pr73 +canonical_operator_pr733 +canonical_operator_pr734 +canonical_operator_pr738 +canonical_operator_pr749 +canonical_operator_pr754 +canonical_operator_pr755 +canonical_operator_pr756 +canonical_operator_pr757 +canonical_operator_pr763 +canonical_operator_pr765 +canonical_operator_pr771 +canonical_operator_pr772 +canonical_operator_pr773 +canonical_operator_pr776 +canonical_operator_pr782 +canonical_operator_pr786 +canonical_operator_pr787 +canonical_operator_pr788 +canonical_operator_pr79 +canonical_operator_pr790 +canonical_operator_pr791 +canonical_operator_pr795 +canonical_operator_pr800 +canonical_operator_pr805 +canonical_operator_pr811 +canonical_operator_pr820 +canonical_operator_pr823 +canonical_operator_pr828 +canonical_operator_pr838 +canonical_operator_pr843 +canonical_operator_pr855 +canonical_operator_pr860 +canonical_operator_pr871 +canonical_operator_pr873 +canonical_operator_pr875 +canonical_operator_pr876 +canonical_operator_pr882 +canonical_operator_pr889 +canonical_operator_pr890 +canonical_operator_pr891 +canonical_operator_pr894 +canonical_operator_pr897 +canonical_operator_pr900 +canonical_operator_pr901 +canonical_operator_pr904 +canonical_operator_pr905 +canonical_operator_pr910 +canonical_operator_pr914 +canonical_operator_pr92 +canonical_operator_pr925 +canonical_operator_pr926 +canonical_operator_pr936 +canonical_operator_pr937 +canonical_operator_pr942 +canonical_operator_pr944 +canonical_operator_pr949 +canonical_operator_pr961 +canonical_operator_pr965 +canonical_operator_pr967 +canonical_operator_pr975 +canonical_operator_pr977 +canonical_operator_pr982 +canonical_operator_pr986 +canonical_operator_pr99 +canonical_operator_pr991 +canonical_operator_pr993 +canonical_operator_pr994 +canonical_operator_pr996 +canonical_operator_pr998 +canonical_pylxd_pr164 +canonical_pylxd_pr166 +canonical_pylxd_pr168 +canonical_pylxd_pr169 +canonical_pylxd_pr176 +canonical_pylxd_pr177 +canonical_pylxd_pr178 +canonical_pylxd_pr181 +canonical_pylxd_pr200 +canonical_pylxd_pr202 +canonical_pylxd_pr203 +canonical_pylxd_pr205 +canonical_pylxd_pr233 +canonical_pylxd_pr250 +canonical_pylxd_pr253 +canonical_pylxd_pr254 +canonical_pylxd_pr265 +canonical_pylxd_pr276 +canonical_pylxd_pr285 +canonical_pylxd_pr289 +canonical_pylxd_pr290 +canonical_pylxd_pr291 +canonical_pylxd_pr299 +cansarigol_pdbr_pr61 +capnproto_pycapnp_pr246 +carbonplan_xarray-schema_pr1 +carbonplan_xarray-schema_pr2 +careless25_text2digits_pr28 +carsonyl_pypac_pr5 +carsonyl_pypac_pr81 +carsonyl_pypac_pr83 +catcombo_jira2markdown_pr13 +catcombo_jira2markdown_pr15 +catcombo_jira2markdown_pr19 +catcombo_jira2markdown_pr30 +cbornet_blockbuster_pr12 +cbornet_blockbuster_pr20 +cbornet_blockbuster_pr35 +cbornet_blockbuster_pr36 +cbornet_blockbuster_pr39 +cbornet_blockbuster_pr4 +cclib_cclib_pr751 +cclib_cclib_pr770 +cclib_cclib_pr783 +cclib_cclib_pr792 +cclib_cclib_pr794 +cclib_cclib_pr831 +cclib_cclib_pr832 +cclib_cclib_pr840 +cdgriffith_puremagic_pr108 +cdgriffith_puremagic_pr113 +cdgriffith_puremagic_pr28 +censys_censys-python_pr100 +censys_censys-python_pr125 +censys_censys-python_pr147 +censys_censys-python_pr148 +censys_censys-python_pr157 +censys_censys-python_pr165 +censys_censys-python_pr172 +censys_censys-python_pr175 +censys_censys-python_pr177 +censys_censys-python_pr196 +censys_censys-python_pr207 +censys_censys-python_pr235 +censys_censys-python_pr241 +censys_censys-python_pr266 +censys_censys-python_pr267 +censys_censys-python_pr291 +censys_censys-python_pr312 +censys_censys-python_pr347 +censys_censys-python_pr384 +censys_censys-python_pr496 +censys_censys-python_pr541 +censys_censys-python_pr571 +censys_censys-python_pr655 +censys_censys-python_pr656 +censys_censys-python_pr687 +censys_censys-python_pr71 +censys_censys-python_pr91 +cerfacs-globc_icclim_pr110 +cerfacs-globc_icclim_pr129 +cerfacs-globc_icclim_pr132 +cerfacs-globc_icclim_pr135 +cerfacs-globc_icclim_pr88 +cerfacs-globc_icclim_pr89 +cesbit_pyleri_pr24 +cevans87_atools_pr7 +chargebee_chargebee-python_pr100 +chargebee_chargebee-python_pr101 +chargebee_chargebee-python_pr95 +childsish_dynamic-yaml_pr14 +childsish_dynamic-yaml_pr27 +chimpler_pyhocon_pr108 +chimpler_pyhocon_pr119 +chimpler_pyhocon_pr120 +chimpler_pyhocon_pr123 +chimpler_pyhocon_pr124 +chimpler_pyhocon_pr127 +chimpler_pyhocon_pr128 +chimpler_pyhocon_pr129 +chimpler_pyhocon_pr133 +chimpler_pyhocon_pr136 +chimpler_pyhocon_pr143 +chimpler_pyhocon_pr146 +chimpler_pyhocon_pr148 +chimpler_pyhocon_pr153 +chimpler_pyhocon_pr158 +chimpler_pyhocon_pr160 +chimpler_pyhocon_pr162 +chimpler_pyhocon_pr166 +chimpler_pyhocon_pr170 +chimpler_pyhocon_pr173 +chimpler_pyhocon_pr184 +chimpler_pyhocon_pr188 +chimpler_pyhocon_pr189 +chimpler_pyhocon_pr192 +chimpler_pyhocon_pr196 +chimpler_pyhocon_pr199 +chimpler_pyhocon_pr228 +chimpler_pyhocon_pr229 +chimpler_pyhocon_pr247 +chimpler_pyhocon_pr255 +chimpler_pyhocon_pr257 +chimpler_pyhocon_pr263 +chimpler_pyhocon_pr266 +chimpler_pyhocon_pr287 +chimpler_pyhocon_pr291 +chimpler_pyhocon_pr308 +chimpler_pyhocon_pr322 +chimpler_pyhocon_pr73 +chimpler_pyhocon_pr74 +chimpler_pyhocon_pr76 +chimpler_pyhocon_pr81 +chimpler_pyhocon_pr82 +chimpler_pyhocon_pr83 +chimpler_pyhocon_pr85 +chimpler_pyhocon_pr90 +chimpler_pyhocon_pr92 +chimpler_pyhocon_pr94 +chmp_ipytest_pr110 +choderalab_pymbar_pr513 +choderalab_pymbar_pr551 +choderalab_pymbar_pr558 +choderalab_pymbar_pr569 +chrisjsewell_pytest-notebook_pr41 +ciscorn_starlette-graphene3_pr11 +ciscorn_starlette-graphene3_pr31 +clarkduvall_serpy_pr15 +cldf_csvw_pr23 +cldf_csvw_pr29 +cldf_csvw_pr42 +clemense_yourdfpy_pr21 +clemense_yourdfpy_pr32 +clemense_yourdfpy_pr33 +clemense_yourdfpy_pr4 +clemense_yourdfpy_pr6 +click-contrib_sphinx-click_pr108 +clld_clldutils_pr93 +cloud-custodian_cel-python_pr12 +cloud-custodian_cel-python_pr130 +cloud-custodian_cel-python_pr18 +cloud-custodian_cel-python_pr36 +cloud-custodian_cel-python_pr92 +cloud-custodian_cel-python_pr96 +cloudevents_sdk-python_pr122 +cloudevents_sdk-python_pr149 +cloudevents_sdk-python_pr151 +cloudevents_sdk-python_pr173 +cloudevents_sdk-python_pr184 +cloudsmith-io_cloudsmith-cli_pr111 +cloudsmith-io_cloudsmith-cli_pr116 +cloudsmith-io_cloudsmith-cli_pr131 +cloudsmith-io_cloudsmith-cli_pr14 +cloudsmith-io_cloudsmith-cli_pr140 +cloudsmith-io_cloudsmith-cli_pr142 +cloudsmith-io_cloudsmith-cli_pr169 +cloudsmith-io_cloudsmith-cli_pr172 +cloudsmith-io_cloudsmith-cli_pr189 +cloudsmith-io_cloudsmith-cli_pr192 +cloudsmith-io_cloudsmith-cli_pr209 +cloudsmith-io_cloudsmith-cli_pr214 +cloudsmith-io_cloudsmith-cli_pr28 +cloudsmith-io_cloudsmith-cli_pr38 +cloudsmith-io_cloudsmith-cli_pr40 +cloudsmith-io_cloudsmith-cli_pr42 +cloudsmith-io_cloudsmith-cli_pr43 +cloudsmith-io_cloudsmith-cli_pr45 +cloudsmith-io_cloudsmith-cli_pr74 +cloudsmith-io_cloudsmith-cli_pr79 +cloudsmith-io_cloudsmith-cli_pr8 +cloudsmith-io_cloudsmith-cli_pr92 +cloudtools_awacs_pr159 +cloudtools_awacs_pr181 +cloudtools_awacs_pr186 +cloudtools_awacs_pr214 +cloudtools_awacs_pr248 +cloudtools_troposphere_pr1960 +cloudtools_troposphere_pr1966 +cloudtools_troposphere_pr1968 +cloudtools_troposphere_pr1980 +cloudtools_troposphere_pr1988 +cloudtools_troposphere_pr2013 +cloudtools_troposphere_pr2014 +cloudtools_troposphere_pr2018 +cloudtools_troposphere_pr2021 +cloudtools_troposphere_pr2024 +cloudtools_troposphere_pr2025 +cloudtools_troposphere_pr2027 +cloudtools_troposphere_pr2030 +cloudtools_troposphere_pr2039 +cloudtools_troposphere_pr2040 +cloudtools_troposphere_pr2041 +cloudtools_troposphere_pr2046 +cloudtools_troposphere_pr2048 +cloudtools_troposphere_pr2051 +cloudtools_troposphere_pr2055 +cloudtools_troposphere_pr2056 +cloudtools_troposphere_pr2057 +cloudtools_troposphere_pr2059 +cloudtools_troposphere_pr2064 +cloudtools_troposphere_pr2069 +cloudtools_troposphere_pr2085 +cloudtools_troposphere_pr2087 +cloudtools_troposphere_pr2088 +cloudtools_troposphere_pr2090 +cloudtools_troposphere_pr2091 +cloudtools_troposphere_pr2093 +cloudtools_troposphere_pr2097 +cloudtools_troposphere_pr2101 +cloudtools_troposphere_pr2102 +cloudtools_troposphere_pr2110 +cloudtools_troposphere_pr2120 +cloudtools_troposphere_pr2129 +cloudtools_troposphere_pr2130 +cloudtools_troposphere_pr2131 +cloudtools_troposphere_pr2133 +cloudtools_troposphere_pr2136 +cloudtools_troposphere_pr2143 +cloudtools_troposphere_pr2145 +cloudtools_troposphere_pr2156 +cloudtools_troposphere_pr2164 +cloudtools_troposphere_pr2168 +cloudtools_troposphere_pr2170 +cloudtools_troposphere_pr2171 +cloudtools_troposphere_pr2175 +cloudtools_troposphere_pr2177 +cloudtools_troposphere_pr2178 +cloudtools_troposphere_pr2179 +cloudtools_troposphere_pr2181 +cloudtools_troposphere_pr2182 +cloudtools_troposphere_pr2185 +cloudtools_troposphere_pr2191 +cloudtools_troposphere_pr2193 +cloudtools_troposphere_pr2195 +cloudtools_troposphere_pr2197 +cloudtools_troposphere_pr2200 +cloudtools_troposphere_pr2201 +cloudtools_troposphere_pr2202 +cloudtools_troposphere_pr2207 +cloudtools_troposphere_pr2211 +cloudtools_troposphere_pr2212 +cloudtools_troposphere_pr2222 +cloudtools_troposphere_pr2225 +cloudtools_troposphere_pr2230 +cloudtools_troposphere_pr2240 +cloudtools_troposphere_pr2241 +cloudtools_troposphere_pr2242 +cloudtools_troposphere_pr2244 +cloudtools_troposphere_pr2249 +cloudtools_troposphere_pr2250 +cloudtools_troposphere_pr2251 +cloudtools_troposphere_pr2254 +cloudtools_troposphere_pr2257 +cloudtools_troposphere_pr2258 +cloudtools_troposphere_pr2259 +cloudtools_troposphere_pr2263 +cloudtools_troposphere_pr2267 +cloudtools_troposphere_pr2269 +cloudtools_troposphere_pr2270 +cloudtools_troposphere_pr2271 +cloudtools_troposphere_pr2272 +cloudtools_troposphere_pr2278 +cloudtools_troposphere_pr2285 +cloudtools_troposphere_pr2286 +cloudtools_troposphere_pr2289 +cloudtools_troposphere_pr2297 +cloudtools_troposphere_pr2301 +cloudtools_troposphere_pr2311 +cloudtools_troposphere_pr2316 +cloudtools_troposphere_pr2317 +cloudtools_troposphere_pr2319 +cloudtools_troposphere_pr2320 +cloudtools_troposphere_pr2322 +cloudtools_troposphere_pr2323 +cloudtools_troposphere_pr2326 +cloudtools_troposphere_pr2327 +cloudtools_troposphere_pr2328 +cloudtools_troposphere_pr2329 +cloudtools_troposphere_pr2331 +cloudtools_troposphere_pr2332 +cloudtools_troposphere_pr2335 +cloudtools_troposphere_pr2336 +cloudtools_troposphere_pr2337 +cloudtools_troposphere_pr2338 +cloudtools_troposphere_pr2340 +cobrateam_django-htmlmin_pr122 +cobrateam_django-htmlmin_pr150 +cobrateam_django-htmlmin_pr99 +cocotb_cocotb_pr1619 +cocotb_cocotb_pr1620 +cocotb_cocotb_pr1635 +cocotb_cocotb_pr1644 +cocotb_cocotb_pr1646 +cocotb_cocotb_pr1692 +cocotb_cocotb_pr1714 +cocotb_cocotb_pr1723 +cocotb_cocotb_pr1725 +cocotb_cocotb_pr1743 +cocotb_cocotb_pr1752 +cocotb_cocotb_pr1760 +cocotb_cocotb_pr1780 +codingjoe_django-stdimage_pr191 +codingjoe_django-stdimage_pr217 +codingjoe_django-stdimage_pr225 +codingjoe_django-stdimage_pr324 +codrsquad_setupmeta_pr64 +codrsquad_setupmeta_pr81 +codrsquad_setupmeta_pr83 +codrsquad_setupmeta_pr91 +cogeotiff_rio-cogeo_pr14 +cogeotiff_rio-cogeo_pr239 +cogeotiff_rio-cogeo_pr252 +cogeotiff_rio-cogeo_pr255 +cogeotiff_rio-cogeo_pr260 +cogeotiff_rio-cogeo_pr278 +cogeotiff_rio-cogeo_pr279 +cogeotiff_rio-cogeo_pr283 +cogeotiff_rio-cogeo_pr285 +cogeotiff_rio-cogeo_pr293 +cogeotiff_rio-cogeo_pr294 +cogeotiff_rio-cogeo_pr305 +cogeotiff_rio-cogeo_pr37 +cogeotiff_rio-cogeo_pr44 +cogeotiff_rio-cogeo_pr57 +cogeotiff_rio-cogeo_pr61 +cogeotiff_rio-cogeo_pr65 +cohere-ai_cohere-compass-sdk_pr101 +cohere-ai_cohere-compass-sdk_pr108 +cohere-ai_cohere-compass-sdk_pr110 +cohere-ai_cohere-compass-sdk_pr116 +cohere-ai_cohere-compass-sdk_pr50 +cohere-ai_cohere-compass-sdk_pr53 +cohere-ai_cohere-compass-sdk_pr57 +cohere-ai_cohere-compass-sdk_pr58 +cohere-ai_cohere-compass-sdk_pr63 +cohere-ai_cohere-compass-sdk_pr70 +cohere-ai_cohere-compass-sdk_pr71 +cohere-ai_cohere-compass-sdk_pr74 +cohere-ai_cohere-compass-sdk_pr76 +cohere-ai_cohere-compass-sdk_pr79 +cohere-ai_cohere-compass-sdk_pr83 +cohere-ai_cohere-compass-sdk_pr87 +cohere-ai_cohere-compass-sdk_pr88 +cohere-ai_cohere-compass-sdk_pr98 +cohere-ai_cohere-compass-sdk_pr99 +coinbase_coinbase-advanced-py_pr18 +commit-check_commit-check_pr244 +commit-check_commit-check_pr276 +commit-check_commit-check_pr292 +commit-check_commit-check_pr299 +commit-check_commit-check_pr304 +commit-check_commit-check_pr305 +commit-check_commit-check_pr50 +commit-check_commit-check_pr51 +commit-check_commit-check_pr60 +commit-check_commit-check_pr73 +common-workflow-language_cwl-utils_pr101 +common-workflow-language_cwl-utils_pr102 +common-workflow-language_cwl-utils_pr117 +common-workflow-language_cwl-utils_pr132 +common-workflow-language_cwl-utils_pr144 +common-workflow-language_cwl-utils_pr145 +common-workflow-language_cwl-utils_pr146 +common-workflow-language_cwl-utils_pr165 +common-workflow-language_cwl-utils_pr191 +common-workflow-language_cwl-utils_pr192 +common-workflow-language_cwl-utils_pr193 +common-workflow-language_cwl-utils_pr196 +common-workflow-language_cwl-utils_pr199 +common-workflow-language_cwl-utils_pr206 +common-workflow-language_cwl-utils_pr223 +common-workflow-language_cwl-utils_pr247 +common-workflow-language_cwl-utils_pr267 +common-workflow-language_cwl-utils_pr297 +common-workflow-language_cwl-utils_pr329 +common-workflow-language_cwl-utils_pr343 +common-workflow-language_cwl-utils_pr345 +compas-dev_compas_pr1078 +compas-dev_compas_pr1084 +compas-dev_compas_pr1088 +compas-dev_compas_pr1090 +compas-dev_compas_pr1093 +compas-dev_compas_pr1098 +compas-dev_compas_pr1104 +compas-dev_compas_pr1106 +compas-dev_compas_pr1113 +compas-dev_compas_pr1118 +compas-dev_compas_pr1123 +compas-dev_compas_pr1124 +compas-dev_compas_pr1129 +compas-dev_compas_pr1130 +compas-dev_compas_pr1131 +compas-dev_compas_pr1137 +compas-dev_compas_pr1144 +compas-dev_compas_pr1146 +compas-dev_compas_pr1150 +compas-dev_compas_pr1152 +compas-dev_compas_pr1157 +compas-dev_compas_pr1162 +compas-dev_compas_pr1163 +compas-dev_compas_pr1170 +compas-dev_compas_pr1172 +compas-dev_compas_pr1174 +compas-dev_compas_pr1316 +compas-dev_compas_pr327 +compas-dev_compas_pr328 +compas-dev_compas_pr331 +compas-dev_compas_pr332 +compas-dev_compas_pr333 +compas-dev_compas_pr339 +compas-dev_compas_pr347 +compas-dev_compas_pr365 +compas-dev_compas_pr370 +compas-dev_compas_pr371 +compas-dev_compas_pr372 +compas-dev_compas_pr373 +compas-dev_compas_pr374 +compas-dev_compas_pr376 +compas-dev_compas_pr378 +compas-dev_compas_pr382 +compas-dev_compas_pr386 +compas-dev_compas_pr389 +compas-dev_compas_pr390 +compas-dev_compas_pr394 +compas-dev_compas_pr395 +compas-dev_compas_pr403 +compas-dev_compas_pr404 +compas-dev_compas_pr419 +compas-dev_compas_pr420 +compas-dev_compas_pr422 +compas-dev_compas_pr528 +compas-dev_compas_pr537 +compas-dev_compas_pr541 +compas-dev_compas_pr547 +compas-dev_compas_pr550 +compas-dev_compas_pr592 +compas-dev_compas_pr596 +compas-dev_compas_pr598 +compas-dev_compas_pr602 +compas-dev_compas_pr608 +compas-dev_compas_pr611 +compas-dev_compas_pr623 +compas-dev_compas_pr634 +compas-dev_compas_pr635 +compas-dev_compas_pr638 +compas-dev_compas_pr642 +compas-dev_compas_pr651 +compas-dev_compas_pr667 +compas-dev_compas_pr668 +compas-dev_compas_pr674 +compas-dev_compas_pr680 +compas-dev_compas_pr681 +compas-dev_compas_pr686 +compas-dev_compas_pr690 +compas-dev_compas_pr708 +compas-dev_compas_pr712 +compas-dev_compas_pr731 +compas-dev_compas_pr734 +compas-dev_compas_pr735 +compas-dev_compas_pr761 +compas-dev_compas_pr764 +compas-dev_compas_pr765 +compas-dev_compas_pr770 +compas-dev_compas_pr771 +compas-dev_compas_pr774 +compas-dev_compas_pr778 +compas-dev_compas_pr780 +compas-dev_compas_pr781 +compas-dev_compas_pr782 +compas-dev_compas_pr783 +compas-dev_compas_pr785 +compas-dev_compas_pr786 +compas-dev_compas_pr790 +compas-dev_compas_pr796 +compas-dev_compas_pr799 +compas-dev_compas_pr803 +compas-dev_compas_pr804 +compas-dev_compas_pr805 +compas-dev_compas_pr814 +compas-dev_compas_pr818 +compas-dev_compas_pr820 +compas-dev_compas_pr821 +compilerla_conventional-pre-commit_pr105 +compilerla_conventional-pre-commit_pr140 +comtravo_ctparse_pr10 +comtravo_ctparse_pr104 +comtravo_ctparse_pr129 +comtravo_ctparse_pr2 +comtravo_ctparse_pr29 +comtravo_ctparse_pr30 +comtravo_ctparse_pr31 +comtravo_ctparse_pr32 +comtravo_ctparse_pr35 +comtravo_ctparse_pr37 +comtravo_ctparse_pr39 +comtravo_ctparse_pr40 +comtravo_ctparse_pr41 +comtravo_ctparse_pr46 +comtravo_ctparse_pr47 +comtravo_ctparse_pr58 +comtravo_ctparse_pr60 +comtravo_ctparse_pr61 +comtravo_ctparse_pr62 +comtravo_ctparse_pr63 +comtravo_ctparse_pr7 +comtravo_ctparse_pr70 +comtravo_ctparse_pr71 +configcat_python-sdk_pr15 +configcat_python-sdk_pr16 +configcat_python-sdk_pr17 +configcat_python-sdk_pr19 +configcat_python-sdk_pr25 +configcat_python-sdk_pr32 +configcat_python-sdk_pr35 +configcat_python-sdk_pr37 +configcat_python-sdk_pr38 +configcat_python-sdk_pr40 +configcat_python-sdk_pr43 +configcat_python-sdk_pr46 +configcat_python-sdk_pr8 +configcat_python-sdk_pr9 +containerbuildsystem_dockerfile-parse_pr110 +containerbuildsystem_dockerfile-parse_pr119 +containerbuildsystem_dockerfile-parse_pr5 +containerbuildsystem_dockerfile-parse_pr56 +containerbuildsystem_dockerfile-parse_pr60 +containerbuildsystem_dockerfile-parse_pr65 +containerbuildsystem_dockerfile-parse_pr92 +containers_podman-py_pr19 +containers_podman-py_pr37 +containers_podman-py_pr41 +containers_podman-py_pr44 +containers_podman-py_pr46 +containers_podman-py_pr52 +contentful_contentful-management.py_pr119 +contentful_contentful-management.py_pr28 +contentful_contentful-management.py_pr32 +contentful_contentful-management.py_pr33 +contentful_rich-text-renderer.py_pr13 +contentful_rich-text-renderer.py_pr4 +cookiecutter_cookiecutter_pr1200 +cookiecutter_cookiecutter_pr1284 +cookiecutter_cookiecutter_pr1468 +cookiecutter_cookiecutter_pr1485 +cookiecutter_cookiecutter_pr1493 +cookiecutter_cookiecutter_pr1496 +cookiecutter_cookiecutter_pr1542 +cookiecutter_cookiecutter_pr1545 +cookiecutter_cookiecutter_pr1546 +cookiecutter_cookiecutter_pr1569 +cookiecutter_cookiecutter_pr1621 +cookiecutter_cookiecutter_pr1626 +cookiecutter_cookiecutter_pr1651 +cookiecutter_cookiecutter_pr1669 +cookiecutter_cookiecutter_pr1679 +cookiecutter_cookiecutter_pr1689 +cookiecutter_cookiecutter_pr1692 +cookiecutter_cookiecutter_pr1706 +cookiecutter_cookiecutter_pr1716 +cookiecutter_cookiecutter_pr1719 +cookiecutter_cookiecutter_pr1721 +cookiecutter_cookiecutter_pr1758 +cookiecutter_cookiecutter_pr1770 +cookiecutter_cookiecutter_pr1779 +cookiecutter_cookiecutter_pr1866 +cookiecutter_cookiecutter_pr1881 +cookiecutter_cookiecutter_pr1901 +cookiecutter_cookiecutter_pr1903 +cookiecutter_cookiecutter_pr1920 +cookiecutter_cookiecutter_pr1923 +cookiecutter_cookiecutter_pr1924 +cookiecutter_cookiecutter_pr1942 +cookiecutter_cookiecutter_pr1950 +cookiecutter_cookiecutter_pr1981 +cookiecutter_cookiecutter_pr1995 +cookiecutter_cookiecutter_pr1997 +cookiecutter_cookiecutter_pr2010 +cookiecutter_cookiecutter_pr2015 +cookiecutter_cookiecutter_pr2020 +cookiecutter_cookiecutter_pr2029 +cookiecutter_cookiecutter_pr2051 +cookiecutter_cookiecutter_pr2054 +cookiecutter_cookiecutter_pr2060 +cookiecutter_cookiecutter_pr2171 +corenting_immutabledict_pr244 +corenting_immutabledict_pr307 +corteva_geocube_pr101 +corteva_geocube_pr112 +corteva_geocube_pr119 +corteva_geocube_pr122 +corteva_geocube_pr171 +corteva_geocube_pr180 +corteva_geocube_pr95 +corydolphin_flask-cors_pr272 +corydolphin_flask-cors_pr318 +corydolphin_flask-cors_pr363 +corydolphin_flask-cors_pr390 +corydolphin_flask-cors_pr391 +cphyc_matplotlib-label-lines_pr153 +cphyc_matplotlib-label-lines_pr22 +cphyc_matplotlib-label-lines_pr26 +cphyc_matplotlib-label-lines_pr59 +cphyc_matplotlib-label-lines_pr8 +craffel_pretty-midi_pr222 +crate_sqlalchemy-cratedb_pr140 +crate_sqlalchemy-cratedb_pr203 +crflynn_pbspark_pr15 +crflynn_pbspark_pr18 +crflynn_pbspark_pr33 +crflynn_pbspark_pr39 +cronofy_pycronofy_pr102 +cronofy_pycronofy_pr107 +cronofy_pycronofy_pr17 +cronofy_pycronofy_pr2 +cronofy_pycronofy_pr20 +cronofy_pycronofy_pr21 +cronofy_pycronofy_pr22 +cronofy_pycronofy_pr23 +cronofy_pycronofy_pr24 +cronofy_pycronofy_pr30 +cronofy_pycronofy_pr36 +cronofy_pycronofy_pr39 +cronofy_pycronofy_pr4 +cronofy_pycronofy_pr40 +cronofy_pycronofy_pr42 +cronofy_pycronofy_pr47 +cronofy_pycronofy_pr50 +cronofy_pycronofy_pr55 +cronofy_pycronofy_pr60 +cronofy_pycronofy_pr63 +cronofy_pycronofy_pr64 +cronofy_pycronofy_pr69 +cronofy_pycronofy_pr70 +cronofy_pycronofy_pr79 +cronofy_pycronofy_pr8 +cronofy_pycronofy_pr89 +cronofy_pycronofy_pr99 +crs4_repo2rocrate_pr10 +crs4_repo2rocrate_pr13 +crs4_repo2rocrate_pr14 +csparpa_pyowm_pr230 +csurfer_rake-nltk_pr59 +csurfer_rake-nltk_pr62 +cthoyt_class-resolver_pr13 +cthoyt_class-resolver_pr17 +cthoyt_class-resolver_pr19 +cthoyt_class-resolver_pr20 +cthoyt_class-resolver_pr30 +cthoyt_class-resolver_pr34 +cthoyt_class-resolver_pr36 +cthoyt_class-resolver_pr37 +cthoyt_class-resolver_pr38 +cthoyt_class-resolver_pr42 +cthoyt_class-resolver_pr43 +cthoyt_class-resolver_pr68 +cthoyt_class-resolver_pr69 +cthoyt_class-resolver_pr71 +cthoyt_class-resolver_pr74 +cthoyt_class-resolver_pr75 +cthoyt_class-resolver_pr85 +cthoyt_pystow_pr104 +cthoyt_pystow_pr108 +cthoyt_pystow_pr17 +cthoyt_pystow_pr29 +cthoyt_pystow_pr3 +cthoyt_pystow_pr34 +cthoyt_pystow_pr38 +cthoyt_pystow_pr39 +cthoyt_pystow_pr4 +cthoyt_pystow_pr42 +cthoyt_pystow_pr43 +cthoyt_pystow_pr47 +cthoyt_pystow_pr55 +cthoyt_pystow_pr56 +cthoyt_pystow_pr59 +cthoyt_pystow_pr61 +cthoyt_pystow_pr76 +cthoyt_pystow_pr80 +cucumber_cucumber-expressions_pr259 +cucumber_gherkin_pr241 +cucumber_gherkin_pr64 +cuenca-mx_clabe_pr167 +cunla_fakeredis-py_pr105 +cunla_fakeredis-py_pr109 +cunla_fakeredis-py_pr110 +cunla_fakeredis-py_pr111 +cunla_fakeredis-py_pr112 +cunla_fakeredis-py_pr127 +cunla_fakeredis-py_pr135 +cunla_fakeredis-py_pr139 +cunla_fakeredis-py_pr143 +cunla_fakeredis-py_pr147 +cunla_fakeredis-py_pr152 +cunla_fakeredis-py_pr180 +cunla_fakeredis-py_pr19 +cunla_fakeredis-py_pr202 +cunla_fakeredis-py_pr206 +cunla_fakeredis-py_pr207 +cunla_fakeredis-py_pr208 +cunla_fakeredis-py_pr223 +cunla_fakeredis-py_pr234 +cunla_fakeredis-py_pr238 +cunla_fakeredis-py_pr248 +cunla_fakeredis-py_pr257 +cunla_fakeredis-py_pr27 +cunla_fakeredis-py_pr280 +cunla_fakeredis-py_pr281 +cunla_fakeredis-py_pr303 +cunla_fakeredis-py_pr307 +cunla_fakeredis-py_pr317 +cunla_fakeredis-py_pr319 +cunla_fakeredis-py_pr41 +cunla_fakeredis-py_pr42 +cunla_fakeredis-py_pr46 +cunla_fakeredis-py_pr49 +cunla_fakeredis-py_pr74 +cunla_fakeredis-py_pr85 +da4089_simplefix_pr17 +da4089_simplefix_pr20 +daggaz_json-stream_pr11 +daggaz_json-stream_pr25 +daggaz_json-stream_pr71 +dajiaji_pyhpke_pr16 +dandi_dandi-cli_pr20 +dandi_dandi-cli_pr24 +dandi_dandi-cli_pr28 +dandi_dandi-cli_pr34 +dandi_dandi-cli_pr36 +dandi_dandischema_pr30 +dandi_dandischema_pr40 +dandi_dandischema_pr48 +dandi_dandischema_pr58 +dandi_dandischema_pr60 +dandi_dandischema_pr68 +dandi_dandischema_pr70 +dantebben_nox-uv_pr35 +dantebben_nox-uv_pr4 +dantebben_nox-uv_pr47 +dantebben_nox-uv_pr56 +dantebben_nox-uv_pr61 +dantebben_nox-uv_pr8 +dapr_python-sdk_pr84 +dapr_python-sdk_pr89 +darosior_python-bip32_pr17 +darosior_python-bip32_pr2 +darosior_python-bip32_pr23 +darosior_python-bip32_pr33 +darosior_python-bip32_pr49 +darvid_python-hyperscan_pr136 +darvid_python-hyperscan_pr70 +dask_dask-jobqueue_pr582 +dask_dask-jobqueue_pr623 +dask_dask-jobqueue_pr680 +dask_dask-jobqueue_pr690 +dask_partd_pr12 +dask_partd_pr24 +data-apis_array-api-compat_pr110 +data-apis_array-api-compat_pr126 +data-apis_array-api-compat_pr130 +data-apis_array-api-compat_pr147 +data-apis_array-api-compat_pr166 +data-apis_array-api-compat_pr174 +data-apis_array-api-compat_pr207 +data-apis_array-api-compat_pr224 +data-apis_array-api-compat_pr231 +data-apis_array-api-compat_pr238 +data-apis_array-api-compat_pr239 +data-apis_array-api-compat_pr240 +data-apis_array-api-compat_pr244 +data-apis_array-api-compat_pr249 +data-apis_array-api-compat_pr263 +data-apis_array-api-compat_pr276 +data-apis_array-api-compat_pr286 +data-apis_array-api-compat_pr290 +data-apis_array-api-compat_pr291 +data-apis_array-api-compat_pr294 +data-apis_array-api-compat_pr299 +data-apis_array-api-compat_pr303 +data-apis_array-api-compat_pr305 +data-apis_array-api-compat_pr308 +data-apis_array-api-compat_pr318 +data-apis_array-api-compat_pr76 +data-apis_array-api-compat_pr78 +data-apis_array-api-compat_pr79 +data-apis_array-api-compat_pr80 +data-apis_array-api-compat_pr94 +data-apis_array-api-compat_pr96 +davidvujic_poetry-multiproject-plugin_pr56 +davidvujic_poetry-multiproject-plugin_pr67 +davidvujic_poetry-multiproject-plugin_pr75 +dbader_schedule_pr15 +dbader_schedule_pr22 +dbader_schedule_pr28 +dbader_schedule_pr401 +dbader_schedule_pr404 +dbader_schedule_pr43 +dbader_schedule_pr46 +dbader_schedule_pr604 +dbatten5_maison_pr16 +dbatten5_maison_pr30 +dbatten5_maison_pr373 +dbatten5_maison_pr377 +dbcli_pgcli_pr608 +dbcli_pgcli_pr612 +dbcli_pgcli_pr613 +dbcli_pgcli_pr614 +dbcli_pgcli_pr619 +dbcli_pgcli_pr620 +dbcli_pgcli_pr621 +dbcli_pgcli_pr624 +dbcli_pgcli_pr633 +dbcli_pgcli_pr639 +dbcli_pgcli_pr641 +dbcli_pgcli_pr647 +dbcli_pgcli_pr649 +dbcli_pgcli_pr654 +dbcli_pgcli_pr655 +dbcli_pgcli_pr656 +dbcli_pgcli_pr659 +dbcli_pgcli_pr667 +dbcli_pgcli_pr673 +dbcli_pgcli_pr677 +dbcli_pgcli_pr687 +dbcli_pgcli_pr688 +dbcli_pgcli_pr701 +dbcli_pgcli_pr703 +dbcli_pgcli_pr706 +dbcli_pgcli_pr709 +dbcli_pgcli_pr710 +dbcli_pgcli_pr714 +dbcli_pgcli_pr715 +dbcli_pgcli_pr722 +dbcli_pgcli_pr724 +dbcli_pgcli_pr729 +dbcli_pgcli_pr750 +dbcli_pgcli_pr761 +dbcli_pgcli_pr766 +dbcli_pgcli_pr770 +dbcli_pgcli_pr771 +dbcli_pgcli_pr773 +dbcli_pgcli_pr782 +dbcli_pgcli_pr785 +dbcli_pgcli_pr798 +dbcli_pgcli_pr820 +dbcli_pgcli_pr821 +dbcli_pgcli_pr856 +dbcli_pgcli_pr861 +dbcli_pgcli_pr871 +dbcli_pgcli_pr875 +dbcli_pgcli_pr876 +dbcli_pgcli_pr877 +dbcli_pgcli_pr878 +dbcli_pgcli_pr921 +dbcli_pgcli_pr941 +dbcli_pgcli_pr942 +dbcli_pgspecial_pr131 +dbcli_pgspecial_pr136 +dbcli_pgspecial_pr137 +dbcli_pgspecial_pr150 +dbcli_pgspecial_pr65 +dbcli_pgspecial_pr79 +dbcli_pgspecial_pr80 +dbt-labs_dbt-adapters_pr119 +dbt-labs_dbt-adapters_pr126 +dbt-labs_dbt-adapters_pr165 +dbt-labs_dbt-adapters_pr179 +dbt-labs_dbt-adapters_pr197 +dbt-labs_dbt-adapters_pr217 +dbt-labs_dbt-adapters_pr231 +dbt-labs_dbt-adapters_pr236 +dbt-labs_dbt-adapters_pr244 +dbt-labs_dbt-adapters_pr247 +dbt-labs_dbt-adapters_pr260 +dbt-labs_dbt-adapters_pr282 +dbt-labs_dbt-adapters_pr300 +dbt-labs_dbt-adapters_pr350 +dbt-labs_dbt-adapters_pr368 +dbt-labs_dbt-adapters_pr43 +dbt-labs_dbt-adapters_pr44 +dbt-labs_dbt-adapters_pr78 +dbt-labs_dbt-adapters_pr91 +dbt-labs_dbt-common_pr235 +dbt-labs_dbt-common_pr291 +dbt-labs_dbt-common_pr308 +dbt-labs_dbt-common_pr311 +dbt-labs_dbt-common_pr313 +dbt-labs_dbt-common_pr314 +dbt-labs_dbt-common_pr318 +dbt-labs_dbt-common_pr323 +dbt-msft_dbt-sqlserver_pr122 +dbt-msft_dbt-sqlserver_pr141 +dbt-msft_dbt-sqlserver_pr147 +dbt-msft_dbt-sqlserver_pr151 +dbt-msft_dbt-sqlserver_pr158 +dbt-msft_dbt-sqlserver_pr231 +dchevell_flask-executor_pr12 +dchevell_flask-executor_pr2 +ddmee_polling2_pr27 +ddmee_polling2_pr8 +declaresub_abnf_pr20 +deedy5_primp_pr7 +deepghs_hfutils_pr2 +deeplook_sparklines_pr16 +deeplook_sparklines_pr2 +deeplook_sparklines_pr8 +deepset-ai_haystack-experimental_pr10 +deepset-ai_haystack-experimental_pr13 +deepset-ai_haystack-experimental_pr15 +deepset-ai_haystack-experimental_pr17 +deepset-ai_haystack-experimental_pr22 +deepset-ai_haystack-experimental_pr23 +deepset-ai_haystack-experimental_pr30 +deepset-ai_haystack-experimental_pr32 +deepset-ai_haystack-experimental_pr37 +deepset-ai_haystack-experimental_pr395 +deepset-ai_haystack-experimental_pr40 +deepset-ai_haystack-experimental_pr42 +deepset-ai_haystack-experimental_pr49 +deepset-ai_haystack-experimental_pr52 +deepset-ai_haystack-experimental_pr53 +deepset-ai_haystack-experimental_pr57 +deepset-ai_haystack-experimental_pr61 +deepset-ai_haystack-experimental_pr62 +defnull_multipart_pr30 +delta-io_delta-sharing_pr105 +delta-io_delta-sharing_pr107 +delta-io_delta-sharing_pr108 +delta-io_delta-sharing_pr111 +delta-io_delta-sharing_pr12 +delta-io_delta-sharing_pr120 +delta-io_delta-sharing_pr140 +delta-io_delta-sharing_pr142 +delta-io_delta-sharing_pr145 +delta-io_delta-sharing_pr148 +delta-io_delta-sharing_pr150 +delta-io_delta-sharing_pr151 +delta-io_delta-sharing_pr153 +delta-io_delta-sharing_pr155 +delta-io_delta-sharing_pr163 +delta-io_delta-sharing_pr181 +delta-io_delta-sharing_pr188 +delta-io_delta-sharing_pr199 +delta-io_delta-sharing_pr201 +delta-io_delta-sharing_pr207 +delta-io_delta-sharing_pr209 +delta-io_delta-sharing_pr211 +delta-io_delta-sharing_pr217 +delta-io_delta-sharing_pr235 +delta-io_delta-sharing_pr255 +delta-io_delta-sharing_pr26 +delta-io_delta-sharing_pr285 +delta-io_delta-sharing_pr30 +delta-io_delta-sharing_pr302 +delta-io_delta-sharing_pr309 +delta-io_delta-sharing_pr326 +delta-io_delta-sharing_pr333 +delta-io_delta-sharing_pr334 +delta-io_delta-sharing_pr349 +delta-io_delta-sharing_pr356 +delta-io_delta-sharing_pr36 +delta-io_delta-sharing_pr364 +delta-io_delta-sharing_pr369 +delta-io_delta-sharing_pr37 +delta-io_delta-sharing_pr384 +delta-io_delta-sharing_pr394 +delta-io_delta-sharing_pr41 +delta-io_delta-sharing_pr420 +delta-io_delta-sharing_pr421 +delta-io_delta-sharing_pr43 +delta-io_delta-sharing_pr445 +delta-io_delta-sharing_pr472 +delta-io_delta-sharing_pr478 +delta-io_delta-sharing_pr48 +delta-io_delta-sharing_pr49 +delta-io_delta-sharing_pr494 +delta-io_delta-sharing_pr527 +delta-io_delta-sharing_pr536 +delta-io_delta-sharing_pr553 +delta-io_delta-sharing_pr56 +delta-io_delta-sharing_pr578 +delta-io_delta-sharing_pr586 +delta-io_delta-sharing_pr590 +delta-io_delta-sharing_pr591 +delta-io_delta-sharing_pr603 +delta-io_delta-sharing_pr613 +delta-io_delta-sharing_pr621 +delta-io_delta-sharing_pr628 +delta-io_delta-sharing_pr653 +delta-io_delta-sharing_pr654 +delta-io_delta-sharing_pr657 +delta-io_delta-sharing_pr660 +delta-io_delta-sharing_pr670 +delta-io_delta-sharing_pr681 +delta-io_delta-sharing_pr686 +delta-io_delta-sharing_pr69 +delta-io_delta-sharing_pr693 +delta-io_delta-sharing_pr708 +delta-io_delta-sharing_pr736 +delta-io_delta-sharing_pr737 +delta-io_delta-sharing_pr743 +delta-io_delta-sharing_pr75 +delta-io_delta-sharing_pr757 +delta-io_delta-sharing_pr760 +delta-io_delta-sharing_pr763 +delta-io_delta-sharing_pr77 +delta-io_delta-sharing_pr771 +delta-io_delta-sharing_pr788 +delta-io_delta-sharing_pr791 +delta-io_delta-sharing_pr801 +delta-io_delta-sharing_pr81 +delta-io_delta-sharing_pr84 +delta-io_delta-sharing_pr92 +delta-io_delta-sharing_pr93 +demisto_demisto-sdk_pr101 +demisto_demisto-sdk_pr102 +demisto_demisto-sdk_pr115 +demisto_demisto-sdk_pr15 +demisto_demisto-sdk_pr16 +demisto_demisto-sdk_pr18 +demisto_demisto-sdk_pr26 +demisto_demisto-sdk_pr35 +demisto_demisto-sdk_pr36 +demisto_demisto-sdk_pr39 +demisto_demisto-sdk_pr4 +demisto_demisto-sdk_pr42 +demisto_demisto-sdk_pr46 +demisto_demisto-sdk_pr49 +demisto_demisto-sdk_pr54 +demisto_demisto-sdk_pr56 +demisto_demisto-sdk_pr58 +demisto_demisto-sdk_pr62 +demisto_demisto-sdk_pr64 +demisto_demisto-sdk_pr7 +demisto_demisto-sdk_pr80 +demisto_demisto-sdk_pr82 +demisto_demisto-sdk_pr84 +demisto_demisto-sdk_pr85 +demisto_demisto-sdk_pr86 +demisto_demisto-sdk_pr92 +demisto_demisto-sdk_pr99 +denisart_graphql-query_pr39 +deschler_django-modeltranslation_pr656 +deschler_django-modeltranslation_pr657 +deschler_django-modeltranslation_pr662 +deschler_django-modeltranslation_pr671 +deschler_django-modeltranslation_pr685 +deschler_django-modeltranslation_pr687 +deschler_django-modeltranslation_pr735 +deschler_django-modeltranslation_pr739 +deschler_django-modeltranslation_pr782 +deschler_django-modeltranslation_pr783 +deschler_django-modeltranslation_pr794 +dev-petrov_pytest-lazy-fixtures_pr40 +dev-petrov_pytest-lazy-fixtures_pr41 +dev-petrov_pytest-lazy-fixtures_pr44 +developmentseed_cogeo-mosaic_pr183 +developmentseed_cogeo-mosaic_pr184 +developmentseed_cogeo-mosaic_pr185 +developmentseed_cogeo-mosaic_pr241 +developmentseed_geojson-pydantic_pr101 +developmentseed_geojson-pydantic_pr105 +developmentseed_geojson-pydantic_pr138 +developmentseed_geojson-pydantic_pr143 +developmentseed_geojson-pydantic_pr148 +developmentseed_geojson-pydantic_pr153 +developmentseed_geojson-pydantic_pr167 +developmentseed_geojson-pydantic_pr38 +developmentseed_geojson-pydantic_pr64 +developmentseed_geojson-pydantic_pr67 +developmentseed_geojson-pydantic_pr69 +developmentseed_geojson-pydantic_pr70 +developmentseed_geojson-pydantic_pr86 +developmentseed_geojson-pydantic_pr91 +developmentseed_geojson-pydantic_pr94 +developmentseed_geojson-pydantic_pr97 +developmentseed_morecantile_pr104 +developmentseed_morecantile_pr111 +developmentseed_morecantile_pr122 +developmentseed_morecantile_pr123 +developmentseed_morecantile_pr131 +developmentseed_morecantile_pr132 +developmentseed_morecantile_pr142 +developmentseed_morecantile_pr146 +developmentseed_morecantile_pr154 +developmentseed_morecantile_pr158 +developmentseed_morecantile_pr159 +developmentseed_morecantile_pr177 +developmentseed_morecantile_pr191 +developmentseed_morecantile_pr192 +developmentseed_morecantile_pr68 +developmentseed_morecantile_pr72 +developmentseed_morecantile_pr74 +developmentseed_morecantile_pr82 +developmentseed_morecantile_pr84 +developmentseed_morecantile_pr93 +developmentseed_morecantile_pr94 +developmentseed_morecantile_pr95 +developmentseed_rio-stac_pr65 +developmentseed_rio-stac_pr71 +developmentseed_starlette-cramjam_pr4 +devrimcavusoglu_pybboxes_pr19 +devrimcavusoglu_pybboxes_pr24 +dhatim_python-license-check_pr103 +dhatim_python-license-check_pr94 +dhermes_bezier_pr176 +dhermes_bezier_pr191 +dhermes_bezier_pr194 +dhermes_bezier_pr208 +dhermes_bezier_pr233 +dhermes_bezier_pr259 +dhermes_bezier_pr265 +dhermes_bezier_pr267 +dhermes_bezier_pr319 +di_id_pr149 +di_pip-api_pr109 +di_pip-api_pr99 +didix21_mdutils_pr27 +didix21_mdutils_pr45 +didix21_mdutils_pr61 +digitalocean_pydo_pr20 +digitalocean_pydo_pr34 +digitalocean_pydo_pr38 +digitalocean_pydo_pr43 +dimastbk_python-calamine_pr51 +disqus_django-bitfield_pr104 +diyan_pywinrm_pr132 +diyan_pywinrm_pr186 +diyan_pywinrm_pr202 +diyan_pywinrm_pr213 +diyan_pywinrm_pr222 +diyan_pywinrm_pr262 +django-cas-ng_django-cas-ng_pr187 +django-cas-ng_django-cas-ng_pr197 +django-cas-ng_django-cas-ng_pr222 +django-cas-ng_django-cas-ng_pr247 +django-cas-ng_django-cas-ng_pr259 +django-commons_django-cookie-consent_pr81 +django-commons_django-fsm-2_pr42 +django-commons_django-fsm-2_pr54 +django-crispy-forms_crispy-bootstrap5_pr107 +django-crispy-forms_crispy-bootstrap5_pr113 +django-crispy-forms_crispy-bootstrap5_pr151 +django-crispy-forms_crispy-bootstrap5_pr158 +django-crispy-forms_crispy-bootstrap5_pr162 +django-crispy-forms_crispy-bootstrap5_pr180 +django-crispy-forms_crispy-bootstrap5_pr183 +django-crispy-forms_crispy-bootstrap5_pr187 +django-crispy-forms_crispy-bootstrap5_pr200 +django-crispy-forms_crispy-bootstrap5_pr31 +django-crispy-forms_crispy-bootstrap5_pr44 +django-crispy-forms_crispy-bootstrap5_pr53 +django-crispy-forms_crispy-bootstrap5_pr56 +django-crispy-forms_crispy-bootstrap5_pr63 +django-crispy-forms_crispy-bootstrap5_pr64 +django-crispy-forms_crispy-bootstrap5_pr65 +django-crispy-forms_crispy-bootstrap5_pr81 +django-crispy-forms_crispy-bootstrap5_pr93 +django-crispy-forms_django-crispy-forms_pr1008 +django-crispy-forms_django-crispy-forms_pr1029 +django-crispy-forms_django-crispy-forms_pr1032 +django-crispy-forms_django-crispy-forms_pr1091 +django-crispy-forms_django-crispy-forms_pr1099 +django-crispy-forms_django-crispy-forms_pr1114 +django-crispy-forms_django-crispy-forms_pr1116 +django-crispy-forms_django-crispy-forms_pr1123 +django-crispy-forms_django-crispy-forms_pr1130 +django-crispy-forms_django-crispy-forms_pr1155 +django-crispy-forms_django-crispy-forms_pr1157 +django-crispy-forms_django-crispy-forms_pr1159 +django-crispy-forms_django-crispy-forms_pr1190 +django-crispy-forms_django-crispy-forms_pr1195 +django-crispy-forms_django-crispy-forms_pr1224 +django-crispy-forms_django-crispy-forms_pr1225 +django-crispy-forms_django-crispy-forms_pr1226 +django-crispy-forms_django-crispy-forms_pr1229 +django-crispy-forms_django-crispy-forms_pr1230 +django-crispy-forms_django-crispy-forms_pr1231 +django-crispy-forms_django-crispy-forms_pr1262 +django-crispy-forms_django-crispy-forms_pr1286 +django-crispy-forms_django-crispy-forms_pr1289 +django-crispy-forms_django-crispy-forms_pr1293 +django-crispy-forms_django-crispy-forms_pr897 +django-crispy-forms_django-crispy-forms_pr920 +django-crispy-forms_django-crispy-forms_pr952 +django-crispy-forms_django-crispy-forms_pr966 +django-extensions_django-extensions_pr1837 +django-extensions_django-extensions_pr1869 +django-extensions_django-extensions_pr1878 +django-extensions_django-extensions_pr1914 +django-extensions_django-extensions_pr1941 +django-hijack_django-hijack_pr505 +django-hijack_django-hijack_pr528 +django-hijack_django-hijack_pr629 +django-hijack_django-hijack_pr651 +django-json-api_django-rest-framework-json-api_pr1182 +django-json-api_django-rest-framework-json-api_pr1286 +django-treebeard_django-treebeard_pr150 +django-treebeard_django-treebeard_pr158 +django-treebeard_django-treebeard_pr178 +django-treebeard_django-treebeard_pr183 +django-treebeard_django-treebeard_pr91 +dlwh_draccus_pr41 +dmort27_panphon_pr10 +dmort27_panphon_pr68 +docopt_docopt_pr6 +doloopwhile_pyjq_pr53 +dorthu_openapi3_pr24 +dorthu_openapi3_pr34 +dorthu_openapi3_pr35 +dorthu_openapi3_pr39 +dorthu_openapi3_pr42 +dorthu_openapi3_pr46 +dorthu_openapi3_pr57 +dpath-maintainers_dpath-python_pr106 +dpath-maintainers_dpath-python_pr169 +dpath-maintainers_dpath-python_pr181 +dpath-maintainers_dpath-python_pr22 +dpkp_kafka-python_pr1761 +dpkp_kafka-python_pr1768 +dpkp_kafka-python_pr1769 +dpkp_kafka-python_pr1781 +dpkp_kafka-python_pr1782 +dpkp_kafka-python_pr1821 +dpkp_kafka-python_pr1909 +dpkp_kafka-python_pr1912 +dpkp_kafka-python_pr1918 +dpkp_kafka-python_pr1993 +dpkp_kafka-python_pr1995 +dpkp_kafka-python_pr2038 +drgarcia1986_simple-settings_pr10 +drgarcia1986_simple-settings_pr11 +drgarcia1986_simple-settings_pr19 +drgarcia1986_simple-settings_pr20 +drgarcia1986_simple-settings_pr21 +drgarcia1986_simple-settings_pr23 +drgarcia1986_simple-settings_pr24 +drgarcia1986_simple-settings_pr6 +drgarcia1986_simple-settings_pr8 +dropbox_stone_pr307 +dropbox_stone_pr326 +dropbox_stone_pr330 +dropbox_stone_pr345 +duplocloud_duploctl_pr1 +duplocloud_duploctl_pr15 +duplocloud_duploctl_pr19 +duplocloud_duploctl_pr26 +duplocloud_duploctl_pr37 +duplocloud_duploctl_pr40 +duplocloud_duploctl_pr41 +duplocloud_duploctl_pr43 +duplocloud_duploctl_pr45 +duplocloud_duploctl_pr47 +duplocloud_duploctl_pr50 +duplocloud_duploctl_pr56 +dwavesystems_dimod_pr370 +dwavesystems_dimod_pr387 +dwavesystems_dimod_pr398 +dwavesystems_dimod_pr415 +dwavesystems_dimod_pr417 +dwavesystems_dimod_pr420 +dwavesystems_dimod_pr427 +dwavesystems_dimod_pr451 +dwavesystems_dimod_pr464 +dwavesystems_dimod_pr494 +dwavesystems_dimod_pr539 +dwavesystems_dwave-cloud-client_pr106 +dwavesystems_dwave-cloud-client_pr120 +dwavesystems_dwave-cloud-client_pr122 +dwavesystems_dwave-cloud-client_pr145 +dwavesystems_dwave-cloud-client_pr15 +dwavesystems_dwave-cloud-client_pr152 +dwavesystems_dwave-cloud-client_pr164 +dwavesystems_dwave-cloud-client_pr168 +dwavesystems_dwave-cloud-client_pr169 +dwavesystems_dwave-cloud-client_pr174 +dwavesystems_dwave-cloud-client_pr184 +dwavesystems_dwave-cloud-client_pr189 +dwavesystems_dwave-cloud-client_pr213 +dwavesystems_dwave-cloud-client_pr222 +dwavesystems_dwave-cloud-client_pr34 +dwavesystems_dwave-cloud-client_pr35 +dwavesystems_dwave-cloud-client_pr38 +dwavesystems_dwave-cloud-client_pr386 +dwavesystems_dwave-cloud-client_pr402 +dwavesystems_dwave-cloud-client_pr404 +dwavesystems_dwave-cloud-client_pr421 +dwavesystems_dwave-cloud-client_pr431 +dwavesystems_dwave-cloud-client_pr432 +dwavesystems_dwave-cloud-client_pr47 +dwavesystems_dwave-cloud-client_pr50 +dwavesystems_dwave-cloud-client_pr575 +dwavesystems_dwave-cloud-client_pr92 +dwavesystems_dwave-cloud-client_pr93 +ecies_py_pr392 +ecies_py_pr78 +ecmwf_cfgrib_pr280 +ecmwf_cfgrib_pr288 +edornd_argdantic_pr51 +eerimoq_asn1tools_pr100 +eerimoq_asn1tools_pr112 +eerimoq_asn1tools_pr137 +eerimoq_asn1tools_pr157 +eerimoq_asn1tools_pr57 +eerimoq_asn1tools_pr6 +eerimoq_asn1tools_pr74 +eerimoq_asn1tools_pr77 +eerimoq_asn1tools_pr87 +eerimoq_asn1tools_pr89 +eerkunt_terraform-compliance_pr113 +eerkunt_terraform-compliance_pr117 +eerkunt_terraform-compliance_pr118 +eerkunt_terraform-compliance_pr141 +eerkunt_terraform-compliance_pr142 +eerkunt_terraform-compliance_pr152 +eerkunt_terraform-compliance_pr169 +eerkunt_terraform-compliance_pr176 +eerkunt_terraform-compliance_pr196 +eerkunt_terraform-compliance_pr213 +eerkunt_terraform-compliance_pr286 +eerkunt_terraform-compliance_pr299 +eerkunt_terraform-compliance_pr317 +eerkunt_terraform-compliance_pr320 +eerkunt_terraform-compliance_pr352 +eerkunt_terraform-compliance_pr401 +eerkunt_terraform-compliance_pr414 +eerkunt_terraform-compliance_pr440 +eerkunt_terraform-compliance_pr444 +eerkunt_terraform-compliance_pr445 +eerkunt_terraform-compliance_pr448 +eerkunt_terraform-compliance_pr469 +eerkunt_terraform-compliance_pr513 +eerkunt_terraform-compliance_pr522 +eerkunt_terraform-compliance_pr532 +eerkunt_terraform-compliance_pr548 +eerkunt_terraform-compliance_pr553 +eerkunt_terraform-compliance_pr563 +eerkunt_terraform-compliance_pr742 +eerkunt_terraform-compliance_pr98 +eht16_python-logstash-async_pr92 +eigenein_protobuf_pr178 +eigenein_protobuf_pr191 +eigenein_protobuf_pr37 +ej2_python-quickbooks_pr19 +ej2_python-quickbooks_pr37 +ej2_python-quickbooks_pr4 +elalish_manifold_pr1005 +elalish_manifold_pr1023 +elalish_manifold_pr1033 +elalish_manifold_pr1045 +elalish_manifold_pr1055 +elalish_manifold_pr1079 +elalish_manifold_pr1080 +elalish_manifold_pr1123 +elalish_manifold_pr1167 +elalish_manifold_pr1216 +elalish_manifold_pr1219 +elalish_manifold_pr1223 +elalish_manifold_pr1246 +elalish_manifold_pr1263 +elalish_manifold_pr1273 +elalish_manifold_pr1291 +elalish_manifold_pr1332 +elalish_manifold_pr1384 +elalish_manifold_pr1391 +elalish_manifold_pr1399 +elalish_manifold_pr1401 +elalish_manifold_pr1416 +elalish_manifold_pr1423 +elalish_manifold_pr1425 +elalish_manifold_pr1427 +elalish_manifold_pr1429 +elastic_elastic-transport-python_pr100 +elastic_elastic-transport-python_pr127 +elastic_elastic-transport-python_pr137 +elastic_elastic-transport-python_pr14 +elastic_elastic-transport-python_pr143 +elastic_elastic-transport-python_pr148 +elastic_elastic-transport-python_pr26 +elastic_elastic-transport-python_pr3 +elastic_elastic-transport-python_pr30 +elastic_elastic-transport-python_pr31 +elastic_elastic-transport-python_pr4 +elastic_elastic-transport-python_pr55 +elastic_elastic-transport-python_pr57 +elastic_elastic-transport-python_pr6 +elastic_elasticsearch-py_pr1128 +elastic_elasticsearch-py_pr1176 +elastic_elasticsearch-py_pr143 +elastic_elasticsearch-py_pr2030 +elastic_elasticsearch-py_pr2039 +elastic_elasticsearch-py_pr2064 +elastic_elasticsearch-py_pr2083 +elastic_elasticsearch-py_pr2193 +elastic_elasticsearch-py_pr2299 +elastic_elasticsearch-py_pr2393 +elastic_elasticsearch-py_pr2427 +elastic_elasticsearch-py_pr2561 +elastic_elasticsearch-py_pr2581 +elastic_elasticsearch-py_pr2602 +elastic_elasticsearch-py_pr2607 +elastic_elasticsearch-py_pr2625 +elastic_elasticsearch-py_pr2632 +elastic_elasticsearch-py_pr2666 +elastic_elasticsearch-py_pr2675 +elastic_elasticsearch-py_pr3064 +elastic_elasticsearch-py_pr3078 +elastic_elasticsearch-py_pr3080 +elastic_elasticsearch-py_pr3103 +elastic_elasticsearch-py_pr3125 +elastic_elasticsearch-py_pr454 +elastic_elasticsearch-py_pr481 +elastic_elasticsearch-py_pr539 +elastic_elasticsearch-py_pr569 +elastic_elasticsearch-py_pr612 +eoda-dev_py-maplibregl_pr123 +eoda-dev_py-maplibregl_pr58 +eoda-dev_py-maplibregl_pr60 +eoda-dev_py-maplibregl_pr83 +eoda-dev_py-maplibregl_pr92 +eoda-dev_py-maplibregl_pr97 +epicserve_django-cache-url_pr11 +epicserve_django-cache-url_pr24 +erdogant_pca_pr14 +erezlife_html2docx_pr11 +erezlife_html2docx_pr21 +erezlife_html2docx_pr40 +erezsh_runtype_pr20 +erezsh_runtype_pr31 +erezsh_runtype_pr32 +erezsh_runtype_pr39 +erezsh_runtype_pr43 +erezsh_runtype_pr8 +erikbern_synchronicity_pr100 +erikbern_synchronicity_pr106 +erikbern_synchronicity_pr11 +erikbern_synchronicity_pr111 +erikbern_synchronicity_pr122 +erikbern_synchronicity_pr126 +erikbern_synchronicity_pr130 +erikbern_synchronicity_pr131 +erikbern_synchronicity_pr133 +erikbern_synchronicity_pr14 +erikbern_synchronicity_pr142 +erikbern_synchronicity_pr144 +erikbern_synchronicity_pr147 +erikbern_synchronicity_pr148 +erikbern_synchronicity_pr15 +erikbern_synchronicity_pr150 +erikbern_synchronicity_pr152 +erikbern_synchronicity_pr154 +erikbern_synchronicity_pr155 +erikbern_synchronicity_pr160 +erikbern_synchronicity_pr165 +erikbern_synchronicity_pr169 +erikbern_synchronicity_pr171 +erikbern_synchronicity_pr172 +erikbern_synchronicity_pr174 +erikbern_synchronicity_pr175 +erikbern_synchronicity_pr179 +erikbern_synchronicity_pr182 +erikbern_synchronicity_pr184 +erikbern_synchronicity_pr193 +erikbern_synchronicity_pr194 +erikbern_synchronicity_pr199 +erikbern_synchronicity_pr2 +erikbern_synchronicity_pr204 +erikbern_synchronicity_pr208 +erikbern_synchronicity_pr21 +erikbern_synchronicity_pr22 +erikbern_synchronicity_pr23 +erikbern_synchronicity_pr233 +erikbern_synchronicity_pr26 +erikbern_synchronicity_pr27 +erikbern_synchronicity_pr29 +erikbern_synchronicity_pr30 +erikbern_synchronicity_pr33 +erikbern_synchronicity_pr34 +erikbern_synchronicity_pr38 +erikbern_synchronicity_pr41 +erikbern_synchronicity_pr43 +erikbern_synchronicity_pr47 +erikbern_synchronicity_pr50 +erikbern_synchronicity_pr51 +erikbern_synchronicity_pr52 +erikbern_synchronicity_pr55 +erikbern_synchronicity_pr57 +erikbern_synchronicity_pr58 +erikbern_synchronicity_pr62 +erikbern_synchronicity_pr65 +erikbern_synchronicity_pr69 +erikbern_synchronicity_pr7 +erikbern_synchronicity_pr72 +erikbern_synchronicity_pr76 +erikbern_synchronicity_pr77 +erikbern_synchronicity_pr78 +erikbern_synchronicity_pr8 +erikbern_synchronicity_pr81 +erikbern_synchronicity_pr83 +erikbern_synchronicity_pr86 +erikbern_synchronicity_pr90 +erikbern_synchronicity_pr91 +erikbern_synchronicity_pr92 +erikbern_synchronicity_pr98 +erikbern_synchronicity_pr99 +eriwen_lcov-to-cobertura-xml_pr38 +espdev_csaps_pr10 +espdev_csaps_pr102 +espdev_csaps_pr28 +espdev_csaps_pr32 +espdev_csaps_pr47 +espdev_csaps_pr96 +esphome_aioesphomeapi_pr1038 +esphome_aioesphomeapi_pr1045 +esphome_aioesphomeapi_pr1063 +esphome_aioesphomeapi_pr1066 +esphome_aioesphomeapi_pr1082 +esphome_aioesphomeapi_pr1086 +esphome_aioesphomeapi_pr1099 +esphome_aioesphomeapi_pr1101 +esphome_aioesphomeapi_pr1109 +esphome_aioesphomeapi_pr1121 +esphome_aioesphomeapi_pr1132 +esphome_aioesphomeapi_pr1219 +esphome_aioesphomeapi_pr1237 +esphome_aioesphomeapi_pr1258 +esphome_aioesphomeapi_pr1261 +esphome_aioesphomeapi_pr1267 +esphome_aioesphomeapi_pr1304 +esphome_aioesphomeapi_pr1311 +esphome_aioesphomeapi_pr1312 +esphome_aioesphomeapi_pr1317 +esphome_aioesphomeapi_pr1333 +esphome_aioesphomeapi_pr1334 +esphome_aioesphomeapi_pr276 +esphome_aioesphomeapi_pr310 +esphome_aioesphomeapi_pr316 +esphome_aioesphomeapi_pr317 +esphome_aioesphomeapi_pr324 +esphome_aioesphomeapi_pr326 +esphome_aioesphomeapi_pr327 +esphome_aioesphomeapi_pr329 +esphome_aioesphomeapi_pr330 +esphome_aioesphomeapi_pr339 +esphome_aioesphomeapi_pr352 +esphome_aioesphomeapi_pr353 +esphome_aioesphomeapi_pr359 +esphome_aioesphomeapi_pr362 +esphome_aioesphomeapi_pr382 +esphome_aioesphomeapi_pr384 +esphome_aioesphomeapi_pr390 +esphome_aioesphomeapi_pr396 +esphome_aioesphomeapi_pr397 +esphome_aioesphomeapi_pr409 +esphome_aioesphomeapi_pr412 +esphome_aioesphomeapi_pr417 +esphome_aioesphomeapi_pr421 +esphome_aioesphomeapi_pr426 +esphome_aioesphomeapi_pr428 +esphome_aioesphomeapi_pr438 +esphome_aioesphomeapi_pr447 +esphome_aioesphomeapi_pr454 +esphome_aioesphomeapi_pr455 +esphome_aioesphomeapi_pr456 +esphome_aioesphomeapi_pr458 +esphome_aioesphomeapi_pr461 +esphome_aioesphomeapi_pr462 +esphome_aioesphomeapi_pr463 +esphome_aioesphomeapi_pr464 +esphome_aioesphomeapi_pr465 +esphome_aioesphomeapi_pr471 +esphome_aioesphomeapi_pr474 +esphome_aioesphomeapi_pr475 +esphome_aioesphomeapi_pr477 +esphome_aioesphomeapi_pr479 +esphome_aioesphomeapi_pr480 +esphome_aioesphomeapi_pr481 +esphome_aioesphomeapi_pr483 +esphome_aioesphomeapi_pr486 +esphome_aioesphomeapi_pr487 +esphome_aioesphomeapi_pr488 +esphome_aioesphomeapi_pr490 +esphome_aioesphomeapi_pr496 +esphome_aioesphomeapi_pr498 +esphome_aioesphomeapi_pr500 +esphome_aioesphomeapi_pr503 +esphome_aioesphomeapi_pr512 +esphome_aioesphomeapi_pr519 +esphome_aioesphomeapi_pr524 +esphome_aioesphomeapi_pr529 +esphome_aioesphomeapi_pr556 +esphome_aioesphomeapi_pr559 +esphome_aioesphomeapi_pr570 +esphome_aioesphomeapi_pr573 +esphome_aioesphomeapi_pr574 +esphome_aioesphomeapi_pr577 +esphome_aioesphomeapi_pr646 +esphome_aioesphomeapi_pr653 +esphome_aioesphomeapi_pr664 +esphome_aioesphomeapi_pr665 +esphome_aioesphomeapi_pr666 +esphome_aioesphomeapi_pr826 +esphome_aioesphomeapi_pr827 +esphome_aioesphomeapi_pr828 +esphome_aioesphomeapi_pr840 +esphome_aioesphomeapi_pr853 +esphome_aioesphomeapi_pr854 +esphome_aioesphomeapi_pr871 +esphome_aioesphomeapi_pr923 +esphome_aioesphomeapi_pr948 +esphome_aioesphomeapi_pr954 +esphome_aioesphomeapi_pr990 +espressif_idf-build-apps_pr103 +espressif_idf-build-apps_pr107 +espressif_idf-build-apps_pr110 +espressif_idf-build-apps_pr111 +espressif_idf-build-apps_pr112 +espressif_idf-build-apps_pr114 +espressif_idf-build-apps_pr116 +espressif_idf-build-apps_pr118 +espressif_idf-build-apps_pr120 +espressif_idf-build-apps_pr123 +espressif_idf-build-apps_pr124 +espressif_idf-build-apps_pr128 +espressif_idf-build-apps_pr130 +espressif_idf-build-apps_pr135 +espressif_idf-build-apps_pr143 +espressif_idf-build-apps_pr144 +espressif_idf-build-apps_pr145 +espressif_idf-build-apps_pr147 +espressif_idf-build-apps_pr149 +espressif_idf-build-apps_pr151 +espressif_idf-build-apps_pr152 +espressif_idf-build-apps_pr160 +espressif_idf-build-apps_pr161 +espressif_idf-build-apps_pr163 +espressif_idf-build-apps_pr164 +espressif_idf-build-apps_pr165 +espressif_idf-build-apps_pr166 +espressif_idf-build-apps_pr169 +espressif_idf-build-apps_pr171 +espressif_idf-build-apps_pr176 +espressif_idf-build-apps_pr177 +espressif_idf-build-apps_pr186 +espressif_idf-build-apps_pr76 +espressif_idf-build-apps_pr78 +espressif_idf-build-apps_pr79 +espressif_idf-build-apps_pr81 +espressif_idf-build-apps_pr83 +espressif_idf-build-apps_pr84 +espressif_idf-build-apps_pr88 +espressif_idf-build-apps_pr90 +espressif_idf-build-apps_pr91 +ethereum_eth-account_pr254 +ethereum_eth-keyfile_pr22 +ethereum_eth-keyfile_pr25 +ethereum_eth-keys_pr74 +ethereum_eth-tester_pr245 +ethereum_eth-tester_pr266 +ethereum_eth-tester_pr269 +ethereum_eth-utils_pr100 +ethereum_eth-utils_pr108 +ethereum_eth-utils_pr113 +ethereum_eth-utils_pr115 +ethereum_eth-utils_pr188 +ethereum_eth-utils_pr190 +ethereum_eth-utils_pr191 +ethereum_eth-utils_pr199 +ethereum_eth-utils_pr204 +ethereum_eth-utils_pr205 +ethereum_eth-utils_pr207 +ethereum_eth-utils_pr226 +ethereum_eth-utils_pr268 +ethereum_eth-utils_pr278 +ethereum_eth-utils_pr285 +ethereum_eth-utils_pr303 +ethereum_eth-utils_pr322 +ethereum_eth-utils_pr78 +ethereum_eth-utils_pr83 +ethereum_eth-utils_pr84 +ethereum_eth-utils_pr87 +ethereum_eth-utils_pr99 +ethereum_hexbytes_pr13 +ethereum_hexbytes_pr7 +ethereum_hexbytes_pr9 +ethereum_py-trie_pr100 +ethereum_py-trie_pr106 +ethereum_py-trie_pr110 +ethereum_py-trie_pr49 +ethereum_py-trie_pr54 +ethereum_py-trie_pr60 +ethereum_py-trie_pr77 +ethereum_py-trie_pr80 +ethereum_py-trie_pr82 +ethereum_py-trie_pr83 +ethereum_py-trie_pr84 +ethereum_py-trie_pr86 +ethereum_py-trie_pr90 +ethereum_py-trie_pr91 +ethereum_py-trie_pr93 +ethereum_py-trie_pr98 +ethereum_pyrlp_pr117 +evergreen-ci_evergreen.py_pr1 +evergreen-ci_evergreen.py_pr2 +evergreen-ci_evergreen.py_pr21 +evergreen-ci_evergreen.py_pr25 +evergreen-ci_evergreen.py_pr27 +evergreen-ci_evergreen.py_pr28 +evergreen-ci_evergreen.py_pr29 +evergreen-ci_evergreen.py_pr37 +evergreen-ci_evergreen.py_pr40 +evergreen-ci_evergreen.py_pr41 +evergreen-ci_evergreen.py_pr42 +evergreen-ci_evergreen.py_pr43 +evergreen-ci_evergreen.py_pr47 +evergreen-ci_evergreen.py_pr5 +evergreen-ci_evergreen.py_pr51 +evergreen-ci_evergreen.py_pr52 +evergreen-ci_evergreen.py_pr54 +evergreen-ci_evergreen.py_pr56 +evergreen-ci_evergreen.py_pr57 +evergreen-ci_evergreen.py_pr59 +evergreen-ci_evergreen.py_pr6 +evergreen-ci_shrub.py_pr12 +evergreen-ci_shrub.py_pr13 +evergreen-ci_shrub.py_pr14 +evergreen-ci_shrub.py_pr15 +evergreen-ci_shrub.py_pr18 +evergreen-ci_shrub.py_pr19 +evergreen-ci_shrub.py_pr27 +evidentlyai_evidently_pr117 +evidentlyai_evidently_pr122 +evidentlyai_evidently_pr127 +evidentlyai_evidently_pr129 +evidentlyai_evidently_pr134 +evidentlyai_evidently_pr141 +evidentlyai_evidently_pr142 +evidentlyai_evidently_pr144 +evidentlyai_evidently_pr146 +evidentlyai_evidently_pr147 +evidentlyai_evidently_pr148 +evidentlyai_evidently_pr151 +evidentlyai_evidently_pr152 +evidentlyai_evidently_pr153 +evidentlyai_evidently_pr158 +evidentlyai_evidently_pr162 +evidentlyai_evidently_pr282 +evidentlyai_evidently_pr284 +evidentlyai_evidently_pr289 +evidentlyai_evidently_pr291 +evidentlyai_evidently_pr301 +evidentlyai_evidently_pr304 +evidentlyai_evidently_pr308 +evidentlyai_evidently_pr312 +evidentlyai_evidently_pr313 +evidentlyai_evidently_pr316 +evidentlyai_evidently_pr336 +evidentlyai_evidently_pr339 +evidentlyai_evidently_pr340 +evidentlyai_evidently_pr341 +evidentlyai_evidently_pr348 +evidentlyai_evidently_pr352 +evidentlyai_evidently_pr357 +evidentlyai_evidently_pr360 +evidentlyai_evidently_pr361 +evidentlyai_evidently_pr363 +evidentlyai_evidently_pr364 +evidentlyai_evidently_pr366 +evidentlyai_evidently_pr367 +evidentlyai_evidently_pr373 +evidentlyai_evidently_pr380 +evidentlyai_evidently_pr381 +evidentlyai_evidently_pr391 +evidentlyai_evidently_pr400 +evidentlyai_evidently_pr404 +evidentlyai_evidently_pr405 +evidentlyai_evidently_pr406 +evidentlyai_evidently_pr408 +evidentlyai_evidently_pr418 +evidentlyai_evidently_pr422 +evidentlyai_evidently_pr424 +evidentlyai_evidently_pr430 +evidentlyai_evidently_pr441 +evidentlyai_evidently_pr444 +evidentlyai_evidently_pr445 +evidentlyai_evidently_pr453 +evidentlyai_evidently_pr454 +evidentlyai_evidently_pr455 +evidentlyai_evidently_pr456 +evidentlyai_evidently_pr458 +evidentlyai_evidently_pr463 +evidentlyai_evidently_pr472 +evidentlyai_evidently_pr474 +evidentlyai_evidently_pr499 +evidentlyai_evidently_pr502 +evidentlyai_evidently_pr504 +evidentlyai_evidently_pr505 +evidentlyai_evidently_pr517 +evidentlyai_evidently_pr520 +evidentlyai_evidently_pr521 +evidentlyai_evidently_pr528 +evidentlyai_evidently_pr532 +evidentlyai_evidently_pr533 +evidentlyai_evidently_pr536 +evidentlyai_evidently_pr537 +evidentlyai_evidently_pr542 +evidentlyai_evidently_pr545 +evidentlyai_evidently_pr546 +evidentlyai_evidently_pr554 +evidentlyai_evidently_pr557 +evidentlyai_evidently_pr558 +evidentlyai_evidently_pr563 +evidentlyai_evidently_pr564 +evidentlyai_evidently_pr566 +evidentlyai_evidently_pr567 +evidentlyai_evidently_pr569 +evidentlyai_evidently_pr574 +evidentlyai_evidently_pr580 +evidentlyai_evidently_pr583 +evidentlyai_evidently_pr585 +evidentlyai_evidently_pr586 +evidentlyai_evidently_pr587 +evidentlyai_evidently_pr593 +evidentlyai_evidently_pr601 +evidentlyai_evidently_pr617 +evidentlyai_evidently_pr622 +exasol_error-reporting-python_pr30 +exasol_error-reporting-python_pr31 +exasol_error-reporting-python_pr50 +exasol_error-reporting-python_pr64 +excitoon_gitignorefile_pr17 +excitoon_gitignorefile_pr33 +executablebooks_myst-nb_pr218 +executablebooks_myst-nb_pr219 +executablebooks_myst-nb_pr600 +executablebooks_myst-nb_pr604 +executablebooks_myst-nb_pr609 +executablebooks_myst-nb_pr620 +executablebooks_myst-nb_pr641 +executablebooks_sphinx-design_pr105 +executablebooks_sphinx-design_pr13 +executablebooks_sphinx-design_pr17 +executablebooks_sphinx-external-toc_pr14 +executablebooks_sphinx-external-toc_pr15 +executablebooks_sphinx-external-toc_pr44 +executablebooks_sphinx-panels_pr42 +explodinglabs_jsonrpcclient_pr220 +explodinglabs_jsonrpcserver_pr107 +explodinglabs_jsonrpcserver_pr108 +explodinglabs_jsonrpcserver_pr113 +explodinglabs_jsonrpcserver_pr118 +explodinglabs_jsonrpcserver_pr120 +explodinglabs_jsonrpcserver_pr123 +explodinglabs_jsonrpcserver_pr127 +explodinglabs_jsonrpcserver_pr168 +explodinglabs_jsonrpcserver_pr170 +explodinglabs_jsonrpcserver_pr176 +explodinglabs_jsonrpcserver_pr179 +explodinglabs_jsonrpcserver_pr193 +explodinglabs_jsonrpcserver_pr198 +explodinglabs_jsonrpcserver_pr201 +explodinglabs_jsonrpcserver_pr42 +explodinglabs_jsonrpcserver_pr45 +explodinglabs_jsonrpcserver_pr94 +explosion_catalogue_pr33 +explosion_confection_pr65 +explosion_spacy-curated-transformers_pr3 +explosion_wasabi_pr11 +explosion_wasabi_pr12 +ezyang_expecttest_pr11 +ezyang_expecttest_pr7 +facebookresearch_clusterscope_pr102 +facebookresearch_clusterscope_pr104 +facebookresearch_clusterscope_pr106 +facebookresearch_clusterscope_pr108 +facebookresearch_clusterscope_pr14 +facebookresearch_clusterscope_pr143 +facebookresearch_clusterscope_pr29 +facebookresearch_clusterscope_pr3 +facebookresearch_clusterscope_pr33 +facebookresearch_clusterscope_pr34 +facebookresearch_clusterscope_pr35 +facebookresearch_clusterscope_pr52 +facebookresearch_clusterscope_pr66 +facebookresearch_clusterscope_pr67 +facebookresearch_clusterscope_pr68 +facebookresearch_clusterscope_pr69 +facebookresearch_clusterscope_pr81 +facebookresearch_clusterscope_pr82 +facebookresearch_clusterscope_pr86 +facebookresearch_clusterscope_pr87 +facebookresearch_clusterscope_pr93 +facebookresearch_clusterscope_pr95 +facebookresearch_clusterscope_pr98 +facebookresearch_dora_pr48 +facelessuser_bracex_pr5 +facelessuser_coloraide_pr10 +facelessuser_coloraide_pr103 +facelessuser_coloraide_pr105 +facelessuser_coloraide_pr106 +facelessuser_coloraide_pr113 +facelessuser_coloraide_pr115 +facelessuser_coloraide_pr123 +facelessuser_coloraide_pr124 +facelessuser_coloraide_pr126 +facelessuser_coloraide_pr13 +facelessuser_coloraide_pr134 +facelessuser_coloraide_pr136 +facelessuser_coloraide_pr137 +facelessuser_coloraide_pr138 +facelessuser_coloraide_pr14 +facelessuser_coloraide_pr142 +facelessuser_coloraide_pr147 +facelessuser_coloraide_pr148 +facelessuser_coloraide_pr149 +facelessuser_coloraide_pr151 +facelessuser_coloraide_pr156 +facelessuser_coloraide_pr159 +facelessuser_coloraide_pr160 +facelessuser_coloraide_pr161 +facelessuser_coloraide_pr165 +facelessuser_coloraide_pr166 +facelessuser_coloraide_pr167 +facelessuser_coloraide_pr176 +facelessuser_coloraide_pr177 +facelessuser_coloraide_pr178 +facelessuser_coloraide_pr179 +facelessuser_coloraide_pr181 +facelessuser_coloraide_pr184 +facelessuser_coloraide_pr189 +facelessuser_coloraide_pr19 +facelessuser_coloraide_pr192 +facelessuser_coloraide_pr193 +facelessuser_coloraide_pr196 +facelessuser_coloraide_pr201 +facelessuser_coloraide_pr203 +facelessuser_coloraide_pr205 +facelessuser_coloraide_pr208 +facelessuser_coloraide_pr210 +facelessuser_coloraide_pr214 +facelessuser_coloraide_pr215 +facelessuser_coloraide_pr216 +facelessuser_coloraide_pr22 +facelessuser_coloraide_pr226 +facelessuser_coloraide_pr232 +facelessuser_coloraide_pr233 +facelessuser_coloraide_pr237 +facelessuser_coloraide_pr239 +facelessuser_coloraide_pr24 +facelessuser_coloraide_pr242 +facelessuser_coloraide_pr248 +facelessuser_coloraide_pr249 +facelessuser_coloraide_pr25 +facelessuser_coloraide_pr252 +facelessuser_coloraide_pr254 +facelessuser_coloraide_pr258 +facelessuser_coloraide_pr260 +facelessuser_coloraide_pr262 +facelessuser_coloraide_pr263 +facelessuser_coloraide_pr266 +facelessuser_coloraide_pr267 +facelessuser_coloraide_pr273 +facelessuser_coloraide_pr275 +facelessuser_coloraide_pr276 +facelessuser_coloraide_pr278 +facelessuser_coloraide_pr28 +facelessuser_coloraide_pr280 +facelessuser_coloraide_pr283 +facelessuser_coloraide_pr284 +facelessuser_coloraide_pr286 +facelessuser_coloraide_pr297 +facelessuser_coloraide_pr30 +facelessuser_coloraide_pr300 +facelessuser_coloraide_pr304 +facelessuser_coloraide_pr305 +facelessuser_coloraide_pr307 +facelessuser_coloraide_pr32 +facelessuser_coloraide_pr322 +facelessuser_coloraide_pr325 +facelessuser_coloraide_pr329 +facelessuser_coloraide_pr331 +facelessuser_coloraide_pr336 +facelessuser_coloraide_pr338 +facelessuser_coloraide_pr34 +facelessuser_coloraide_pr340 +facelessuser_coloraide_pr344 +facelessuser_coloraide_pr347 +facelessuser_coloraide_pr348 +facelessuser_coloraide_pr349 +facelessuser_coloraide_pr350 +facelessuser_coloraide_pr351 +facelessuser_coloraide_pr356 +facelessuser_coloraide_pr357 +facelessuser_coloraide_pr358 +facelessuser_coloraide_pr362 +facelessuser_coloraide_pr363 +facelessuser_coloraide_pr367 +facelessuser_coloraide_pr37 +facelessuser_coloraide_pr370 +facelessuser_coloraide_pr372 +facelessuser_coloraide_pr376 +facelessuser_coloraide_pr377 +facelessuser_coloraide_pr379 +facelessuser_coloraide_pr38 +facelessuser_coloraide_pr382 +facelessuser_coloraide_pr383 +facelessuser_coloraide_pr384 +facelessuser_coloraide_pr386 +facelessuser_coloraide_pr387 +facelessuser_coloraide_pr389 +facelessuser_coloraide_pr39 +facelessuser_coloraide_pr393 +facelessuser_coloraide_pr395 +facelessuser_coloraide_pr396 +facelessuser_coloraide_pr397 +facelessuser_coloraide_pr423 +facelessuser_coloraide_pr424 +facelessuser_coloraide_pr425 +facelessuser_coloraide_pr427 +facelessuser_coloraide_pr428 +facelessuser_coloraide_pr431 +facelessuser_coloraide_pr433 +facelessuser_coloraide_pr436 +facelessuser_coloraide_pr44 +facelessuser_coloraide_pr451 +facelessuser_coloraide_pr455 +facelessuser_coloraide_pr456 +facelessuser_coloraide_pr457 +facelessuser_coloraide_pr458 +facelessuser_coloraide_pr461 +facelessuser_coloraide_pr463 +facelessuser_coloraide_pr464 +facelessuser_coloraide_pr469 +facelessuser_coloraide_pr47 +facelessuser_coloraide_pr479 +facelessuser_coloraide_pr487 +facelessuser_coloraide_pr488 +facelessuser_coloraide_pr51 +facelessuser_coloraide_pr52 +facelessuser_coloraide_pr60 +facelessuser_coloraide_pr61 +facelessuser_coloraide_pr66 +facelessuser_coloraide_pr67 +facelessuser_coloraide_pr75 +facelessuser_coloraide_pr76 +facelessuser_coloraide_pr77 +facelessuser_coloraide_pr79 +facelessuser_coloraide_pr82 +facelessuser_coloraide_pr84 +facelessuser_coloraide_pr85 +facelessuser_coloraide_pr88 +facelessuser_coloraide_pr89 +facelessuser_coloraide_pr98 +facelessuser_pyspelling_pr123 +facelessuser_pyspelling_pr128 +facelessuser_pyspelling_pr144 +facelessuser_pyspelling_pr163 +facelessuser_pyspelling_pr201 +facelessuser_pyspelling_pr206 +facelessuser_pyspelling_pr209 +facelessuser_pyspelling_pr211 +facelessuser_pyspelling_pr32 +facelessuser_pyspelling_pr33 +facelessuser_pyspelling_pr35 +facelessuser_pyspelling_pr41 +facelessuser_pyspelling_pr46 +facelessuser_pyspelling_pr48 +facelessuser_pyspelling_pr52 +facelessuser_pyspelling_pr55 +facelessuser_pyspelling_pr60 +facelessuser_pyspelling_pr61 +facelessuser_pyspelling_pr63 +facelessuser_pyspelling_pr71 +facelessuser_pyspelling_pr78 +facelessuser_pyspelling_pr86 +facelessuser_pyspelling_pr87 +facelessuser_pyspelling_pr98 +facelessuser_soupsieve_pr100 +facelessuser_soupsieve_pr102 +facelessuser_soupsieve_pr107 +facelessuser_soupsieve_pr108 +facelessuser_soupsieve_pr109 +facelessuser_soupsieve_pr126 +facelessuser_soupsieve_pr127 +facelessuser_soupsieve_pr129 +facelessuser_soupsieve_pr131 +facelessuser_soupsieve_pr136 +facelessuser_soupsieve_pr140 +facelessuser_soupsieve_pr141 +facelessuser_soupsieve_pr148 +facelessuser_soupsieve_pr149 +facelessuser_soupsieve_pr150 +facelessuser_soupsieve_pr157 +facelessuser_soupsieve_pr158 +facelessuser_soupsieve_pr163 +facelessuser_soupsieve_pr166 +facelessuser_soupsieve_pr177 +facelessuser_soupsieve_pr178 +facelessuser_soupsieve_pr179 +facelessuser_soupsieve_pr204 +facelessuser_soupsieve_pr211 +facelessuser_soupsieve_pr213 +facelessuser_soupsieve_pr217 +facelessuser_soupsieve_pr226 +facelessuser_soupsieve_pr227 +facelessuser_soupsieve_pr229 +facelessuser_soupsieve_pr256 +facelessuser_soupsieve_pr270 +facelessuser_soupsieve_pr71 +facelessuser_soupsieve_pr73 +facelessuser_soupsieve_pr77 +facelessuser_soupsieve_pr80 +facelessuser_soupsieve_pr83 +facelessuser_soupsieve_pr84 +facelessuser_soupsieve_pr88 +facelessuser_soupsieve_pr90 +facelessuser_soupsieve_pr96 +facelessuser_soupsieve_pr97 +facelessuser_wcmatch_pr111 +facelessuser_wcmatch_pr114 +facelessuser_wcmatch_pr147 +facelessuser_wcmatch_pr161 +facelessuser_wcmatch_pr169 +facelessuser_wcmatch_pr191 +facelessuser_wcmatch_pr206 +facelessuser_wcmatch_pr221 +facelessuser_wcmatch_pr223 +facelessuser_wcmatch_pr225 +facelessuser_wcmatch_pr31 +facelessuser_wcmatch_pr35 +facelessuser_wcmatch_pr4 +facelessuser_wcmatch_pr46 +facelessuser_wcmatch_pr47 +facelessuser_wcmatch_pr50 +facelessuser_wcmatch_pr62 +facelessuser_wcmatch_pr64 +facelessuser_wcmatch_pr8 +facelessuser_wcmatch_pr96 +facelessuser_wcmatch_pr98 +falconry_falcon_pr2366 +falconry_falcon_pr2448 +falconry_falcon_pr2487 +falconry_falcon_pr2496 +falconry_falcon_pr2498 +falconry_falcon_pr2503 +falconry_falcon_pr2535 +falconry_falcon_pr2541 +falconry_falcon_pr2572 +falconry_falcon_pr2581 +falconry_falcon_pr2584 +farridav_django-jazzmin_pr100 +farridav_django-jazzmin_pr107 +farridav_django-jazzmin_pr113 +farridav_django-jazzmin_pr114 +farridav_django-jazzmin_pr131 +farridav_django-jazzmin_pr136 +farridav_django-jazzmin_pr139 +farridav_django-jazzmin_pr143 +farridav_django-jazzmin_pr144 +farridav_django-jazzmin_pr152 +farridav_django-jazzmin_pr156 +farridav_django-jazzmin_pr158 +farridav_django-jazzmin_pr164 +farridav_django-jazzmin_pr174 +farridav_django-jazzmin_pr175 +farridav_django-jazzmin_pr178 +farridav_django-jazzmin_pr180 +farridav_django-jazzmin_pr52 +farridav_django-jazzmin_pr53 +farridav_django-jazzmin_pr56 +farridav_django-jazzmin_pr67 +farridav_django-jazzmin_pr69 +farridav_django-jazzmin_pr88 +farridav_django-jazzmin_pr90 +fastavro_fastavro_pr324 +fastavro_fastavro_pr327 +fastavro_fastavro_pr331 +fastavro_fastavro_pr335 +fastavro_fastavro_pr337 +fastavro_fastavro_pr338 +fastavro_fastavro_pr339 +fastavro_fastavro_pr342 +fastavro_fastavro_pr349 +fastavro_fastavro_pr356 +fastavro_fastavro_pr357 +fastavro_fastavro_pr359 +fastavro_fastavro_pr364 +fastavro_fastavro_pr381 +fastavro_fastavro_pr384 +fastavro_fastavro_pr385 +fastavro_fastavro_pr386 +fastavro_fastavro_pr396 +fastavro_fastavro_pr398 +fastavro_fastavro_pr438 +fastavro_fastavro_pr449 +fastavro_fastavro_pr451 +fastavro_fastavro_pr454 +fastavro_fastavro_pr482 +fastavro_fastavro_pr491 +fastavro_fastavro_pr492 +fastavro_fastavro_pr497 +fastavro_fastavro_pr498 +fastavro_fastavro_pr499 +fastavro_fastavro_pr717 +fastavro_fastavro_pr792 +fbruzzesi_iso-week-date_pr114 +fbruzzesi_iso-week-date_pr120 +fbruzzesi_iso-week-date_pr128 +fbruzzesi_iso-week-date_pr23 +fbruzzesi_iso-week-date_pr25 +fbruzzesi_iso-week-date_pr33 +fbruzzesi_iso-week-date_pr35 +fbruzzesi_iso-week-date_pr53 +fbruzzesi_iso-week-date_pr84 +fetchai_cosmpy_pr10 +fetchai_cosmpy_pr11 +fetchai_cosmpy_pr28 +fetchai_cosmpy_pr31 +fetchai_cosmpy_pr6 +fillipe-gsm_python-tsp_pr39 +firebolt-db_firebolt-sdk_pr11 +firebolt-db_firebolt-sdk_pr13 +firebolt-db_firebolt-sdk_pr16 +firebolt-db_firebolt-sdk_pr20 +firebolt-db_firebolt-sdk_pr21 +firebolt-db_firebolt-sdk_pr7 +firebolt-db_firebolt-sdk_pr8 +firebolt-db_firebolt-sdk_pr9 +fivetran_airflow-provider-fivetran_pr30 +fivetran_airflow-provider-fivetran_pr43 +flaport_sax_pr58 +flaport_sax_pr63 +flexxui_pscript_pr63 +flexxui_pscript_pr70 +florimondmanca_asgi-lifespan_pr10 +florimondmanca_asgi-lifespan_pr19 +florimondmanca_asgi-lifespan_pr24 +florimondmanca_asgi-lifespan_pr26 +florimondmanca_asgi-lifespan_pr7 +florimondmanca_asgi-lifespan_pr8 +florimondmanca_asgi-lifespan_pr9 +fohrloop_wakepy_pr121 +fohrloop_wakepy_pr307 +fohrloop_wakepy_pr356 +fohrloop_wakepy_pr379 +fohrloop_wakepy_pr385 +fohrloop_wakepy_pr396 +fohrloop_wakepy_pr417 +fohrloop_wakepy_pr429 +fohrloop_wakepy_pr430 +fohrloop_wakepy_pr434 +fohrloop_wakepy_pr446 +fohrloop_wakepy_pr447 +fohrloop_wakepy_pr452 +fohrloop_wakepy_pr459 +fohrloop_wakepy_pr460 +fohrloop_wakepy_pr464 +fohrloop_wakepy_pr469 +fohrloop_wakepy_pr474 +fohrloop_wakepy_pr477 +fohrloop_wakepy_pr479 +fohrloop_wakepy_pr79 +fohrloop_wakepy_pr82 +fohrloop_wakepy_pr92 +fohrloop_wakepy_pr97 +fonttools_fonttools_pr1359 +fonttools_fonttools_pr1361 +fonttools_fonttools_pr1430 +fonttools_fonttools_pr1439 +fonttools_fonttools_pr1450 +fonttools_fonttools_pr1453 +fonttools_fonttools_pr1460 +fonttools_fonttools_pr1462 +fonttools_fonttools_pr1464 +fonttools_fonttools_pr1469 +fonttools_fonttools_pr1472 +fonttools_fonttools_pr1477 +fonttools_fonttools_pr1488 +fonttools_fonttools_pr1521 +fonttools_fonttools_pr1535 +fonttools_fonttools_pr1539 +fonttools_fonttools_pr1540 +fonttools_fonttools_pr1563 +fonttools_fonttools_pr1564 +fonttools_fonttools_pr1567 +fonttools_fonttools_pr1599 +fonttools_fonttools_pr1669 +fonttools_fonttools_pr1700 +fonttools_fonttools_pr1706 +fonttools_fonttools_pr1715 +fonttools_fonttools_pr1719 +fonttools_fonttools_pr1720 +fonttools_fonttools_pr1732 +fonttools_fonttools_pr1747 +fonttools_fonttools_pr1752 +fonttools_fonttools_pr1753 +fonttools_fonttools_pr1763 +fonttools_fonttools_pr1767 +fonttools_fonttools_pr1772 +fonttools_fonttools_pr1781 +fonttools_fonttools_pr1782 +fonttools_fonttools_pr1785 +fonttools_fonttools_pr1797 +fonttools_fonttools_pr1802 +fonttools_fonttools_pr1809 +fonttools_fonttools_pr1811 +fonttools_fonttools_pr1814 +fonttools_fonttools_pr1816 +fonttools_fonttools_pr1818 +fonttools_fonttools_pr1826 +fonttools_fonttools_pr1827 +fonttools_fonttools_pr1828 +fonttools_fonttools_pr1830 +fonttools_fonttools_pr1836 +fonttools_fonttools_pr1842 +fonttools_fonttools_pr1850 +fonttools_fonttools_pr1860 +fonttools_fonttools_pr1870 +fonttools_fonttools_pr1872 +fonttools_fonttools_pr1876 +fonttools_fonttools_pr1878 +fonttools_fonttools_pr1883 +fonttools_fonttools_pr1902 +fonttools_fonttools_pr1903 +fonttools_fonttools_pr1905 +fonttools_fonttools_pr1908 +fonttools_fonttools_pr1921 +fonttools_fonttools_pr1926 +fonttools_fonttools_pr1938 +fonttools_fonttools_pr1944 +fonttools_fonttools_pr1952 +fonttools_fonttools_pr1957 +fonttools_fonttools_pr1963 +fonttools_fonttools_pr1967 +fonttools_fonttools_pr1970 +fonttools_fonttools_pr1973 +fonttools_fonttools_pr1983 +fonttools_fonttools_pr1986 +fonttools_fonttools_pr1987 +fonttools_fonttools_pr1998 +fonttools_fonttools_pr2008 +fonttools_fonttools_pr2026 +fonttools_fonttools_pr2037 +fonttools_fonttools_pr2039 +fonttools_fonttools_pr2045 +fonttools_fonttools_pr2075 +fonttools_fonttools_pr2077 +fonttools_fonttools_pr2080 +fonttools_fonttools_pr2092 +fonttools_fonttools_pr2094 +fonttools_fonttools_pr2101 +fonttools_fonttools_pr2112 +fonttools_fonttools_pr2129 +fonttools_fonttools_pr2137 +fonttools_fonttools_pr2146 +fonttools_fonttools_pr2155 +fonttools_fonttools_pr2161 +fonttools_fonttools_pr2170 +fonttools_fonttools_pr2172 +fonttools_fonttools_pr2173 +fonttools_fonttools_pr2175 +fonttools_fonttools_pr2177 +fonttools_fonttools_pr2181 +fonttools_fonttools_pr2182 +fonttools_fonttools_pr2229 +fonttools_fonttools_pr2236 +fonttools_fonttools_pr2237 +fonttools_fonttools_pr2238 +fonttools_fonttools_pr2259 +fonttools_fonttools_pr2261 +fonttools_fonttools_pr2274 +fonttools_fonttools_pr2277 +fonttools_fonttools_pr2285 +fonttools_fonttools_pr2305 +fonttools_fonttools_pr2308 +fonttools_fonttools_pr2313 +fonttools_fonttools_pr2326 +fonttools_fonttools_pr2348 +fonttools_fonttools_pr2353 +fonttools_fonttools_pr2366 +fonttools_fonttools_pr2376 +fonttools_fonttools_pr2386 +fonttools_fonttools_pr2413 +fonttools_fonttools_pr2416 +fonttools_fonttools_pr2424 +fonttools_fonttools_pr2430 +fonttools_fonttools_pr2432 +fonttools_fonttools_pr2439 +fonttools_fonttools_pr2446 +fonttools_fonttools_pr2447 +fonttools_fonttools_pr2462 +fonttools_fonttools_pr2477 +fonttools_fonttools_pr2499 +fonttools_fonttools_pr2504 +fonttools_fonttools_pr2506 +fonttools_fonttools_pr2513 +fonttools_fonttools_pr2521 +fonttools_fonttools_pr2528 +fonttools_fonttools_pr2540 +fonttools_fonttools_pr2544 +fonttools_fonttools_pr2549 +fonttools_fonttools_pr2551 +fonttools_fonttools_pr2552 +fonttools_fonttools_pr2553 +fonttools_fonttools_pr2555 +fonttools_fonttools_pr2577 +fonttools_fonttools_pr2589 +fonttools_fonttools_pr2600 +fonttools_fonttools_pr2603 +fonttools_fonttools_pr2609 +fonttools_fonttools_pr2611 +fonttools_fonttools_pr2645 +fonttools_fonttools_pr2651 +fonttools_fonttools_pr2660 +fonttools_fonttools_pr2662 +fonttools_fonttools_pr2673 +fonttools_fonttools_pr2679 +fonttools_fonttools_pr2684 +fonttools_fonttools_pr271 +fonttools_fonttools_pr2717 +fonttools_fonttools_pr2728 +fonttools_fonttools_pr273 +fonttools_fonttools_pr2743 +fonttools_fonttools_pr275 +fonttools_fonttools_pr2762 +fonttools_fonttools_pr2776 +fonttools_fonttools_pr278 +fonttools_fonttools_pr2789 +fonttools_fonttools_pr2794 +fonttools_fonttools_pr2837 +fonttools_fonttools_pr2846 +fonttools_fonttools_pr2849 +fonttools_fonttools_pr2861 +fonttools_fonttools_pr2880 +fonttools_fonttools_pr2889 +fonttools_fonttools_pr2891 +fonttools_fonttools_pr2921 +fonttools_fonttools_pr2922 +fonttools_fonttools_pr2950 +fonttools_fonttools_pr2968 +fonttools_fonttools_pr297 +fonttools_fonttools_pr2971 +fonttools_fonttools_pr2988 +fonttools_fonttools_pr299 +fonttools_fonttools_pr2993 +fonttools_fonttools_pr2995 +fonttools_fonttools_pr3005 +fonttools_fonttools_pr3012 +fonttools_fonttools_pr3020 +fonttools_fonttools_pr3024 +fonttools_fonttools_pr3027 +fonttools_fonttools_pr3029 +fonttools_fonttools_pr303 +fonttools_fonttools_pr3032 +fonttools_fonttools_pr3034 +fonttools_fonttools_pr3038 +fonttools_fonttools_pr305 +fonttools_fonttools_pr3053 +fonttools_fonttools_pr3075 +fonttools_fonttools_pr3092 +fonttools_fonttools_pr3103 +fonttools_fonttools_pr3110 +fonttools_fonttools_pr3114 +fonttools_fonttools_pr3115 +fonttools_fonttools_pr3119 +fonttools_fonttools_pr3124 +fonttools_fonttools_pr3126 +fonttools_fonttools_pr3129 +fonttools_fonttools_pr3130 +fonttools_fonttools_pr3140 +fonttools_fonttools_pr3145 +fonttools_fonttools_pr315 +fonttools_fonttools_pr3155 +fonttools_fonttools_pr3156 +fonttools_fonttools_pr3179 +fonttools_fonttools_pr3190 +fonttools_fonttools_pr3201 +fonttools_fonttools_pr3212 +fonttools_fonttools_pr3241 +fonttools_fonttools_pr325 +fonttools_fonttools_pr3253 +fonttools_fonttools_pr3268 +fonttools_fonttools_pr327 +fonttools_fonttools_pr330 +fonttools_fonttools_pr3304 +fonttools_fonttools_pr3305 +fonttools_fonttools_pr3319 +fonttools_fonttools_pr3323 +fonttools_fonttools_pr3324 +fonttools_fonttools_pr3330 +fonttools_fonttools_pr3333 +fonttools_fonttools_pr3336 +fonttools_fonttools_pr334 +fonttools_fonttools_pr3346 +fonttools_fonttools_pr3353 +fonttools_fonttools_pr3363 +fonttools_fonttools_pr3374 +fonttools_fonttools_pr3380 +fonttools_fonttools_pr3413 +fonttools_fonttools_pr3424 +fonttools_fonttools_pr3426 +fonttools_fonttools_pr3429 +fonttools_fonttools_pr3446 +fonttools_fonttools_pr3456 +fonttools_fonttools_pr3457 +fonttools_fonttools_pr3506 +fonttools_fonttools_pr3509 +fonttools_fonttools_pr3520 +fonttools_fonttools_pr3559 +fonttools_fonttools_pr3561 +fonttools_fonttools_pr3601 +fonttools_fonttools_pr3653 +fonttools_fonttools_pr3672 +fonttools_fonttools_pr3682 +fonttools_fonttools_pr3688 +fonttools_fonttools_pr3689 +fonttools_fonttools_pr3717 +fonttools_fonttools_pr3726 +fonttools_fonttools_pr3732 +fonttools_fonttools_pr3743 +fonttools_fonttools_pr3752 +fonttools_fonttools_pr3756 +fonttools_fonttools_pr3758 +fonttools_fonttools_pr3781 +fonttools_fonttools_pr3783 +fonttools_fonttools_pr3784 +fonttools_fonttools_pr3794 +fonttools_fonttools_pr3797 +fonttools_fonttools_pr3798 +fonttools_fonttools_pr3799 +fonttools_fonttools_pr3800 +fonttools_fonttools_pr3803 +fonttools_fonttools_pr3804 +fonttools_fonttools_pr3805 +fonttools_fonttools_pr3811 +fonttools_fonttools_pr3818 +fonttools_fonttools_pr3831 +fonttools_fonttools_pr3835 +fonttools_fonttools_pr3838 +fonttools_fonttools_pr3847 +fonttools_fonttools_pr3849 +fonttools_fonttools_pr3853 +fonttools_fonttools_pr3868 +fonttools_fonttools_pr3874 +fonttools_fonttools_pr3894 +fonttools_fonttools_pr3895 +fonttools_fonttools_pr3901 +fonttools_fonttools_pr3907 +fonttools_fonttools_pr3912 +fonttools_fonttools_pr3956 +fonttools_fonttools_pr3973 +formencode_formencode_pr184 +fortifyadmin_fortifyapi_pr7 +fortran-lang_fortls_pr49 +fortran-lang_fortls_pr58 +fortran-lang_fortls_pr67 +fortran-lang_fortls_pr75 +fortran-lang_fortls_pr82 +fortran-lang_fortls_pr83 +fox-it_dissect.cstruct_pr104 +fox-it_dissect.cstruct_pr111 +fox-it_dissect.cstruct_pr120 +fox-it_dissect.cstruct_pr122 +fox-it_dissect.cstruct_pr129 +fox-it_dissect.cstruct_pr137 +fox-it_dissect.cstruct_pr139 +fox-it_dissect.cstruct_pr17 +fox-it_dissect.cstruct_pr18 +fox-it_dissect.cstruct_pr19 +fox-it_dissect.cstruct_pr20 +fox-it_dissect.cstruct_pr3 +fox-it_dissect.cstruct_pr35 +fox-it_dissect.cstruct_pr39 +fox-it_dissect.cstruct_pr43 +fox-it_dissect.cstruct_pr66 +fox-it_dissect.cstruct_pr84 +fox-it_dissect.cstruct_pr88 +fox-it_dissect.cstruct_pr91 +fox-it_dissect.cstruct_pr93 +fox-it_dissect.cstruct_pr99 +fox-it_dissect.util_pr17 +fox-it_dissect.util_pr21 +fox-it_dissect.util_pr35 +fox-it_dissect.util_pr65 +fox-it_dissect.util_pr70 +fox-it_dissect.util_pr71 +fox-it_dissect.util_pr77 +fox-it_dissect.util_pr90 +fox-it_dissect.util_pr97 +frankie567_httpx-oauth_pr328 +frankie567_httpx-ws_pr108 +frankie567_httpx-ws_pr110 +frankie567_httpx-ws_pr115 +frankie567_httpx-ws_pr54 +frawau_aioblescan_pr27 +frawau_aioblescan_pr31 +freakboy3742_pyxero_pr393 +freakboy3742_pyxero_pr396 +frederickjansen_polyline_pr2 +fredrik-johansson_mpmath_pr408 +fredrik-johansson_mpmath_pr409 +fredrik-johansson_mpmath_pr412 +fredrik-johansson_mpmath_pr426 +fredrik-johansson_mpmath_pr439 +fredrik-johansson_mpmath_pr531 +fredrik-johansson_mpmath_pr533 +fredrik-johansson_mpmath_pr537 +fredrik-johansson_mpmath_pr557 +fredrik-johansson_mpmath_pr566 +fredrik-johansson_mpmath_pr664 +fredrik-johansson_mpmath_pr679 +fredrik-johansson_mpmath_pr689 +fredrikaverpil_creosote_pr206 +fredrikaverpil_creosote_pr217 +fredrikaverpil_creosote_pr270 +fredrikaverpil_creosote_pr305 +fredrikaverpil_creosote_pr311 +frictionlessdata_datapackage-py_pr168 +frictionlessdata_datapackage-py_pr177 +frictionlessdata_datapackage-py_pr179 +frictionlessdata_datapackage-py_pr189 +frictionlessdata_datapackage-py_pr204 +frictionlessdata_datapackage-py_pr211 +frictionlessdata_datapackage-py_pr218 +frictionlessdata_datapackage-py_pr220 +frictionlessdata_datapackage-py_pr222 +frictionlessdata_datapackage-py_pr226 +frictionlessdata_datapackage-py_pr228 +frictionlessdata_datapackage-py_pr229 +frictionlessdata_datapackage-py_pr241 +frictionlessdata_datapackage-py_pr247 +frictionlessdata_datapackage-py_pr249 +frictionlessdata_datapackage-py_pr260 +frictionlessdata_datapackage-py_pr262 +frictionlessdata_frictionless-py_pr1007 +frictionlessdata_frictionless-py_pr1030 +frictionlessdata_frictionless-py_pr1039 +frictionlessdata_frictionless-py_pr1045 +frictionlessdata_frictionless-py_pr1047 +frictionlessdata_frictionless-py_pr1051 +frictionlessdata_frictionless-py_pr1052 +frictionlessdata_frictionless-py_pr1060 +frictionlessdata_frictionless-py_pr1064 +frictionlessdata_frictionless-py_pr1070 +frictionlessdata_frictionless-py_pr1073 +frictionlessdata_frictionless-py_pr1074 +frictionlessdata_frictionless-py_pr1075 +frictionlessdata_frictionless-py_pr1080 +frictionlessdata_frictionless-py_pr1081 +frictionlessdata_frictionless-py_pr1082 +frictionlessdata_frictionless-py_pr1089 +frictionlessdata_frictionless-py_pr547 +frictionlessdata_frictionless-py_pr548 +frictionlessdata_frictionless-py_pr554 +frictionlessdata_frictionless-py_pr556 +frictionlessdata_frictionless-py_pr557 +frictionlessdata_frictionless-py_pr566 +frictionlessdata_frictionless-py_pr569 +frictionlessdata_frictionless-py_pr571 +frictionlessdata_frictionless-py_pr572 +frictionlessdata_frictionless-py_pr573 +frictionlessdata_frictionless-py_pr579 +frictionlessdata_frictionless-py_pr580 +frictionlessdata_frictionless-py_pr581 +frictionlessdata_frictionless-py_pr583 +frictionlessdata_frictionless-py_pr589 +frictionlessdata_frictionless-py_pr655 +frictionlessdata_frictionless-py_pr657 +frictionlessdata_frictionless-py_pr658 +frictionlessdata_frictionless-py_pr659 +frictionlessdata_frictionless-py_pr660 +frictionlessdata_frictionless-py_pr672 +frictionlessdata_frictionless-py_pr673 +frictionlessdata_frictionless-py_pr674 +frictionlessdata_frictionless-py_pr689 +frictionlessdata_frictionless-py_pr723 +frictionlessdata_frictionless-py_pr781 +frictionlessdata_frictionless-py_pr806 +frictionlessdata_frictionless-py_pr808 +frictionlessdata_frictionless-py_pr819 +frictionlessdata_frictionless-py_pr822 +frictionlessdata_frictionless-py_pr829 +frictionlessdata_frictionless-py_pr841 +frictionlessdata_frictionless-py_pr842 +frictionlessdata_frictionless-py_pr843 +frictionlessdata_frictionless-py_pr848 +frictionlessdata_frictionless-py_pr849 +frictionlessdata_frictionless-py_pr851 +frictionlessdata_frictionless-py_pr857 +frictionlessdata_frictionless-py_pr875 +frictionlessdata_frictionless-py_pr886 +frictionlessdata_frictionless-py_pr900 +frictionlessdata_frictionless-py_pr902 +frictionlessdata_frictionless-py_pr912 +frictionlessdata_frictionless-py_pr924 +frictionlessdata_frictionless-py_pr945 +frictionlessdata_frictionless-py_pr974 +frictionlessdata_frictionless-py_pr983 +frictionlessdata_frictionless-py_pr985 +frictionlessdata_frictionless-py_pr994 +frictionlessdata_frictionless-py_pr998 +frictionlessdata_goodtables_pr219 +frictionlessdata_goodtables_pr223 +frictionlessdata_goodtables_pr225 +frictionlessdata_goodtables_pr240 +frictionlessdata_goodtables_pr241 +frictionlessdata_goodtables_pr254 +frictionlessdata_goodtables_pr290 +frictionlessdata_goodtables_pr298 +frictionlessdata_goodtables_pr306 +frictionlessdata_goodtables_pr316 +frictionlessdata_goodtables_pr318 +frictionlessdata_goodtables_pr331 +frictionlessdata_goodtables_pr334 +frictionlessdata_goodtables_pr346 +frictionlessdata_goodtables_pr363 +frictionlessdata_goodtables_pr365 +frictionlessdata_goodtables_pr421 +frictionlessdata_goodtables_pr466 +frictionlessdata_goodtables_pr470 +frictionlessdata_tableschema-py_pr120 +frictionlessdata_tableschema-py_pr124 +frictionlessdata_tableschema-py_pr133 +frictionlessdata_tableschema-py_pr140 +frictionlessdata_tableschema-py_pr146 +frictionlessdata_tableschema-py_pr178 +frictionlessdata_tableschema-py_pr179 +frictionlessdata_tableschema-py_pr197 +frictionlessdata_tableschema-py_pr199 +frictionlessdata_tableschema-py_pr200 +frictionlessdata_tableschema-py_pr206 +frictionlessdata_tableschema-py_pr207 +frictionlessdata_tableschema-py_pr208 +frictionlessdata_tableschema-py_pr211 +frictionlessdata_tableschema-py_pr216 +frictionlessdata_tableschema-py_pr219 +frictionlessdata_tableschema-py_pr222 +frictionlessdata_tableschema-py_pr224 +frictionlessdata_tableschema-py_pr227 +frictionlessdata_tableschema-py_pr231 +frictionlessdata_tableschema-py_pr269 +frictionlessdata_tableschema-py_pr270 +frictionlessdata_tableschema-py_pr272 +frictionlessdata_tableschema-py_pr274 +frictionlessdata_tableschema-py_pr276 +frictionlessdata_tableschema-py_pr45 +frictionlessdata_tableschema-py_pr61 +frictionlessdata_tableschema-py_pr73 +frictionlessdata_tableschema-py_pr74 +frictionlessdata_tableschema-py_pr76 +frictionlessdata_tableschema-py_pr77 +frictionlessdata_tableschema-py_pr90 +frictionlessdata_tabulator-py_pr107 +frictionlessdata_tabulator-py_pr110 +frictionlessdata_tabulator-py_pr125 +frictionlessdata_tabulator-py_pr127 +frictionlessdata_tabulator-py_pr129 +frictionlessdata_tabulator-py_pr130 +frictionlessdata_tabulator-py_pr141 +frictionlessdata_tabulator-py_pr145 +frictionlessdata_tabulator-py_pr147 +frictionlessdata_tabulator-py_pr166 +frictionlessdata_tabulator-py_pr185 +frictionlessdata_tabulator-py_pr193 +frictionlessdata_tabulator-py_pr196 +frictionlessdata_tabulator-py_pr207 +frictionlessdata_tabulator-py_pr210 +frictionlessdata_tabulator-py_pr212 +frictionlessdata_tabulator-py_pr215 +frictionlessdata_tabulator-py_pr233 +frictionlessdata_tabulator-py_pr251 +frictionlessdata_tabulator-py_pr253 +frictionlessdata_tabulator-py_pr255 +frictionlessdata_tabulator-py_pr258 +frictionlessdata_tabulator-py_pr289 +frictionlessdata_tabulator-py_pr304 +frictionlessdata_tabulator-py_pr316 +frictionlessdata_tabulator-py_pr323 +frictionlessdata_tabulator-py_pr344 +frictionlessdata_tabulator-py_pr54 +frictionlessdata_tabulator-py_pr55 +frictionlessdata_tabulator-py_pr57 +frictionlessdata_tabulator-py_pr58 +frictionlessdata_tabulator-py_pr60 +frictionlessdata_tabulator-py_pr65 +frictionlessdata_tabulator-py_pr68 +frictionlessdata_tabulator-py_pr69 +frictionlessdata_tabulator-py_pr70 +frictionlessdata_tabulator-py_pr80 +frictionlessdata_tabulator-py_pr83 +frictionlessdata_tabulator-py_pr87 +frictionlessdata_tabulator-py_pr88 +frispete_keyrings.cryptfile_pr19 +frostming_marko_pr104 +frostming_marko_pr123 +frostming_marko_pr127 +frostming_marko_pr136 +frostming_marko_pr172 +frostming_marko_pr175 +frostming_marko_pr222 +frostming_marko_pr230 +frostming_marko_pr237 +frostming_marko_pr242 +frostming_marko_pr48 +frostming_marko_pr50 +frostming_marko_pr54 +frostming_marko_pr57 +frostming_marko_pr63 +frostming_marko_pr71 +frostming_marko_pr77 +frostming_marko_pr88 +frostming_marko_pr93 +frostming_unearth_pr10 +frostming_unearth_pr127 +frostming_unearth_pr132 +frostming_unearth_pr142 +frostming_unearth_pr158 +frostming_unearth_pr166 +frostming_unearth_pr26 +frostming_unearth_pr36 +frostming_unearth_pr43 +frostming_unearth_pr6 +frostming_unearth_pr62 +frostming_unearth_pr66 +frostming_unearth_pr70 +frostming_unearth_pr71 +frostming_unearth_pr75 +frostming_unearth_pr78 +frostming_unearth_pr90 +fugue-project_triad_pr101 +fugue-project_triad_pr102 +fugue-project_triad_pr109 +fugue-project_triad_pr111 +fugue-project_triad_pr112 +fugue-project_triad_pr114 +fugue-project_triad_pr115 +fugue-project_triad_pr118 +fugue-project_triad_pr12 +fugue-project_triad_pr120 +fugue-project_triad_pr125 +fugue-project_triad_pr128 +fugue-project_triad_pr13 +fugue-project_triad_pr130 +fugue-project_triad_pr16 +fugue-project_triad_pr17 +fugue-project_triad_pr18 +fugue-project_triad_pr19 +fugue-project_triad_pr23 +fugue-project_triad_pr34 +fugue-project_triad_pr38 +fugue-project_triad_pr51 +fugue-project_triad_pr55 +fugue-project_triad_pr56 +fugue-project_triad_pr58 +fugue-project_triad_pr60 +fugue-project_triad_pr64 +fugue-project_triad_pr65 +fugue-project_triad_pr66 +fugue-project_triad_pr67 +fugue-project_triad_pr72 +fugue-project_triad_pr77 +fugue-project_triad_pr81 +fugue-project_triad_pr84 +fugue-project_triad_pr89 +fugue-project_triad_pr90 +fugue-project_triad_pr92 +fugue-project_triad_pr93 +fugue-project_triad_pr94 +fugue-project_triad_pr97 +fugue-project_triad_pr98 +fuhrysteve_marshmallow-jsonschema_pr119 +fuhrysteve_marshmallow-jsonschema_pr135 +fuhrysteve_marshmallow-jsonschema_pr139 +fuhrysteve_marshmallow-jsonschema_pr160 +fuhrysteve_marshmallow-jsonschema_pr36 +fuhrysteve_marshmallow-jsonschema_pr37 +fulder_pki-tools_pr119 +fulder_pki-tools_pr121 +fulder_pki-tools_pr127 +fulder_pki-tools_pr21 +fulder_pki-tools_pr34 +fulder_pki-tools_pr35 +fulder_pki-tools_pr4 +fulder_pki-tools_pr6 +gahjelle_pyconfs_pr17 +gauge-sh_tach_pr10 +gauge-sh_tach_pr11 +gauge-sh_tach_pr26 +gauge-sh_tach_pr4 +gauge-sh_tach_pr7 +gb-libs_pydantic-geojson_pr33 +geoalchemy_geoalchemy2_pr540 +geomet_geomet_pr18 +geomet_geomet_pr54 +geopandas_geopandas_pr2027 +geopandas_geopandas_pr2067 +geopandas_geopandas_pr2151 +geopandas_geopandas_pr2224 +geopandas_geopandas_pr2225 +geopandas_geopandas_pr2227 +geopandas_geopandas_pr2243 +geopandas_geopandas_pr2275 +geopandas_geopandas_pr2297 +geopandas_geopandas_pr2314 +geopandas_geopandas_pr2332 +geopandas_geopandas_pr2366 +geopandas_geopandas_pr2373 +geopandas_geopandas_pr2415 +geopandas_geopandas_pr2420 +geopandas_geopandas_pr2437 +geopandas_geopandas_pr2453 +geopandas_geopandas_pr2470 +geopandas_geopandas_pr2498 +geopandas_geopandas_pr2503 +geopandas_geopandas_pr2505 +geopandas_geopandas_pr2537 +geopandas_geopandas_pr2539 +geopandas_geopandas_pr2541 +geopandas_geopandas_pr2542 +geopandas_geopandas_pr2552 +geopandas_geopandas_pr2570 +geopandas_geopandas_pr2571 +geopandas_geopandas_pr2575 +geopandas_geopandas_pr2577 +geopandas_geopandas_pr2578 +geopandas_geopandas_pr2580 +geopandas_geopandas_pr2595 +geopandas_geopandas_pr2618 +geopandas_geopandas_pr2621 +geopandas_geopandas_pr2624 +geopandas_geopandas_pr2663 +geopandas_geopandas_pr2667 +geopandas_geopandas_pr2680 +geopandas_geopandas_pr2685 +geopandas_geopandas_pr2762 +geopandas_geopandas_pr2775 +geopandas_geopandas_pr2785 +geopandas_geopandas_pr2788 +geopandas_geopandas_pr2796 +geopandas_geopandas_pr2811 +geopandas_geopandas_pr2827 +geopandas_geopandas_pr2831 +geopandas_geopandas_pr2833 +geopandas_geopandas_pr2846 +geopandas_geopandas_pr2859 +geopandas_geopandas_pr2861 +geopandas_geopandas_pr2868 +geopandas_geopandas_pr2877 +geopandas_geopandas_pr2886 +geopandas_geopandas_pr2902 +geopandas_geopandas_pr2903 +geopandas_geopandas_pr2907 +geopandas_geopandas_pr2909 +geopandas_geopandas_pr2910 +geopandas_geopandas_pr2914 +geopandas_geopandas_pr2915 +geopandas_geopandas_pr2919 +geopandas_geopandas_pr2929 +geopandas_geopandas_pr2940 +geopandas_geopandas_pr2944 +geopandas_geopandas_pr2959 +geopandas_geopandas_pr2960 +geopandas_geopandas_pr2963 +geopandas_geopandas_pr2986 +geopandas_geopandas_pr2992 +geopandas_geopandas_pr2993 +geopandas_geopandas_pr3010 +geopandas_geopandas_pr3017 +geopandas_geopandas_pr3088 +geopandas_geopandas_pr3151 +geopandas_geopandas_pr3154 +geopandas_geopandas_pr3177 +geopandas_geopandas_pr3202 +geopandas_geopandas_pr3211 +geopandas_geopandas_pr3215 +geopandas_geopandas_pr3219 +geopandas_geopandas_pr3226 +geopandas_geopandas_pr3228 +geopandas_geopandas_pr3231 +geopandas_geopandas_pr3233 +geopandas_geopandas_pr3237 +geopandas_geopandas_pr3240 +geopandas_geopandas_pr3261 +geopandas_geopandas_pr3267 +geopandas_geopandas_pr3271 +geopandas_geopandas_pr3272 +geopandas_geopandas_pr3275 +geopandas_geopandas_pr3278 +geopandas_geopandas_pr3282 +geopandas_geopandas_pr3287 +geopandas_geopandas_pr3290 +geopandas_geopandas_pr3296 +geopandas_geopandas_pr3301 +geopandas_geopandas_pr3314 +geopandas_geopandas_pr3316 +geopandas_geopandas_pr3317 +geopandas_geopandas_pr3318 +geopandas_geopandas_pr3329 +geopandas_geopandas_pr3337 +geopandas_geopandas_pr3347 +geopandas_geopandas_pr3360 +geopandas_geopandas_pr3364 +geopandas_geopandas_pr3383 +geopandas_geopandas_pr3395 +geopandas_geopandas_pr3408 +geopandas_geopandas_pr3412 +geopandas_geopandas_pr3415 +geopandas_geopandas_pr3416 +geopandas_geopandas_pr3424 +geopandas_geopandas_pr3436 +geopandas_geopandas_pr3438 +geopandas_geopandas_pr3443 +geopandas_geopandas_pr3445 +geopandas_geopandas_pr3449 +geopandas_geopandas_pr3463 +geopandas_geopandas_pr3466 +geopandas_geopandas_pr3468 +geopandas_geopandas_pr3471 +geopandas_geopandas_pr3502 +geopandas_geopandas_pr3504 +geopandas_geopandas_pr3505 +geopandas_geopandas_pr3543 +geopandas_geopandas_pr3544 +geopandas_geopandas_pr3552 +geopandas_geopandas_pr3560 +geopandas_geopandas_pr3561 +geopandas_geopandas_pr3564 +geopandas_geopandas_pr3572 +geopandas_geopandas_pr3576 +geopandas_geopandas_pr3591 +geopandas_geopandas_pr3596 +geopandas_geopandas_pr3599 +geopandas_geopandas_pr3611 +geopandas_geopandas_pr3616 +geopandas_geopandas_pr3628 +geopandas_geopandas_pr3640 +geopandas_geopandas_pr416 +geopandas_xyzservices_pr11 +geopandas_xyzservices_pr27 +geopandas_xyzservices_pr34 +geopandas_xyzservices_pr38 +geopandas_xyzservices_pr51 +geopandas_xyzservices_pr76 +geopozo_logistro_pr25 +geopozo_logistro_pr9 +geopy_geopy_pr272 +geopy_geopy_pr279 +geopy_geopy_pr281 +geopython_pygeofilter_pr111 +georgebv_drf-pydantic_pr20 +georgebv_drf-pydantic_pr23 +georgebv_drf-pydantic_pr26 +georgebv_drf-pydantic_pr27 +georgebv_drf-pydantic_pr36 +georgebv_drf-pydantic_pr43 +geotab_mygeotab-python_pr11 +geotab_mygeotab-python_pr20 +geotab_mygeotab-python_pr7 +getmoto_py-partiql-parser_pr24 +getmoto_py-partiql-parser_pr28 +getpelican_feedgenerator_pr23 +getpelican_feedgenerator_pr32 +getpelican_feedgenerator_pr4 +getpelican_feedgenerator_pr7 +getsentry_responses_pr231 +getsentry_responses_pr269 +getsentry_responses_pr278 +getsentry_responses_pr285 +getsentry_responses_pr298 +getsentry_responses_pr301 +getsentry_responses_pr302 +getsentry_responses_pr303 +getsentry_responses_pr308 +getsentry_responses_pr316 +getsentry_responses_pr317 +getsentry_responses_pr318 +getsentry_responses_pr347 +getsentry_responses_pr350 +getsentry_responses_pr360 +getsentry_responses_pr363 +getsentry_responses_pr365 +getsentry_responses_pr370 +getsentry_responses_pr390 +getsentry_responses_pr398 +getsentry_responses_pr407 +getsentry_responses_pr409 +getsentry_responses_pr412 +getsentry_responses_pr413 +getsentry_responses_pr415 +getsentry_responses_pr416 +getsentry_responses_pr419 +getsentry_responses_pr420 +getsentry_responses_pr422 +getsentry_responses_pr427 +getsentry_responses_pr432 +getsentry_responses_pr433 +getsentry_responses_pr444 +getsentry_responses_pr447 +getsentry_responses_pr455 +getsentry_responses_pr462 +getsentry_responses_pr465 +getsentry_responses_pr470 +getsentry_responses_pr472 +getsentry_responses_pr476 +getsentry_responses_pr480 +getsentry_responses_pr482 +getsentry_responses_pr485 +getsentry_responses_pr487 +getsentry_responses_pr497 +getsentry_responses_pr498 +getsentry_responses_pr505 +getsentry_responses_pr507 +getsentry_responses_pr508 +getsentry_responses_pr516 +getsentry_responses_pr522 +getsentry_responses_pr524 +getsentry_responses_pr529 +getsentry_responses_pr534 +getsentry_responses_pr535 +getsentry_responses_pr536 +getsentry_responses_pr562 +getsentry_responses_pr564 +getsentry_responses_pr575 +getsentry_responses_pr578 +getsentry_responses_pr580 +getsentry_responses_pr581 +getsentry_responses_pr583 +getsentry_responses_pr593 +getsentry_responses_pr622 +getsentry_responses_pr643 +getsentry_responses_pr648 +getsentry_responses_pr659 +getsentry_responses_pr663 +getsentry_responses_pr664 +getsentry_responses_pr668 +getsentry_responses_pr671 +getsentry_responses_pr673 +getsentry_responses_pr690 +getsentry_responses_pr702 +getsentry_responses_pr711 +getsentry_responses_pr712 +getsentry_responses_pr717 +getsentry_responses_pr720 +getsentry_responses_pr739 +getsentry_responses_pr776 +ghazi-git_drf-standardized-errors_pr16 +ghazi-git_drf-standardized-errors_pr30 +ghazi-git_drf-standardized-errors_pr75 +giampaolo_pyftpdlib_pr626 +giampaolo_pyftpdlib_pr628 +giampaolo_pyftpdlib_pr638 +giampaolo_pyftpdlib_pr651 +giampaolo_pyftpdlib_pr652 +giampaolo_pyftpdlib_pr656 +gijzelaerr_python-snap7_pr250 +gijzelaerr_python-snap7_pr268 +gijzelaerr_python-snap7_pr28 +gijzelaerr_python-snap7_pr283 +gijzelaerr_python-snap7_pr308 +gijzelaerr_python-snap7_pr326 +gijzelaerr_python-snap7_pr368 +gijzelaerr_python-snap7_pr373 +gijzelaerr_python-snap7_pr385 +gijzelaerr_python-snap7_pr529 +gijzelaerr_python-snap7_pr55 +gjoseph92_stackstac_pr208 +gjoseph92_stackstac_pr209 +gjoseph92_stackstac_pr256 +globus_globus-sdk-python_pr1000 +globus_globus-sdk-python_pr1001 +globus_globus-sdk-python_pr1002 +globus_globus-sdk-python_pr1003 +globus_globus-sdk-python_pr1004 +globus_globus-sdk-python_pr1011 +globus_globus-sdk-python_pr1017 +globus_globus-sdk-python_pr1018 +globus_globus-sdk-python_pr1020 +globus_globus-sdk-python_pr1022 +globus_globus-sdk-python_pr1027 +globus_globus-sdk-python_pr1029 +globus_globus-sdk-python_pr1030 +globus_globus-sdk-python_pr1032 +globus_globus-sdk-python_pr1034 +globus_globus-sdk-python_pr1038 +globus_globus-sdk-python_pr1039 +globus_globus-sdk-python_pr1040 +globus_globus-sdk-python_pr1041 +globus_globus-sdk-python_pr1044 +globus_globus-sdk-python_pr1048 +globus_globus-sdk-python_pr1051 +globus_globus-sdk-python_pr1054 +globus_globus-sdk-python_pr1057 +globus_globus-sdk-python_pr1059 +globus_globus-sdk-python_pr1063 +globus_globus-sdk-python_pr1065 +globus_globus-sdk-python_pr1066 +globus_globus-sdk-python_pr1071 +globus_globus-sdk-python_pr1072 +globus_globus-sdk-python_pr1073 +globus_globus-sdk-python_pr1074 +globus_globus-sdk-python_pr1075 +globus_globus-sdk-python_pr1078 +globus_globus-sdk-python_pr1079 +globus_globus-sdk-python_pr1080 +globus_globus-sdk-python_pr1092 +globus_globus-sdk-python_pr1098 +globus_globus-sdk-python_pr113 +globus_globus-sdk-python_pr500 +globus_globus-sdk-python_pr528 +globus_globus-sdk-python_pr529 +globus_globus-sdk-python_pr530 +globus_globus-sdk-python_pr534 +globus_globus-sdk-python_pr536 +globus_globus-sdk-python_pr540 +globus_globus-sdk-python_pr548 +globus_globus-sdk-python_pr549 +globus_globus-sdk-python_pr554 +globus_globus-sdk-python_pr563 +globus_globus-sdk-python_pr568 +globus_globus-sdk-python_pr571 +globus_globus-sdk-python_pr573 +globus_globus-sdk-python_pr577 +globus_globus-sdk-python_pr591 +globus_globus-sdk-python_pr596 +globus_globus-sdk-python_pr597 +globus_globus-sdk-python_pr60 +globus_globus-sdk-python_pr602 +globus_globus-sdk-python_pr603 +globus_globus-sdk-python_pr604 +globus_globus-sdk-python_pr612 +globus_globus-sdk-python_pr613 +globus_globus-sdk-python_pr616 +globus_globus-sdk-python_pr620 +globus_globus-sdk-python_pr621 +globus_globus-sdk-python_pr622 +globus_globus-sdk-python_pr626 +globus_globus-sdk-python_pr628 +globus_globus-sdk-python_pr630 +globus_globus-sdk-python_pr631 +globus_globus-sdk-python_pr640 +globus_globus-sdk-python_pr641 +globus_globus-sdk-python_pr642 +globus_globus-sdk-python_pr644 +globus_globus-sdk-python_pr646 +globus_globus-sdk-python_pr647 +globus_globus-sdk-python_pr65 +globus_globus-sdk-python_pr655 +globus_globus-sdk-python_pr658 +globus_globus-sdk-python_pr66 +globus_globus-sdk-python_pr662 +globus_globus-sdk-python_pr672 +globus_globus-sdk-python_pr675 +globus_globus-sdk-python_pr676 +globus_globus-sdk-python_pr678 +globus_globus-sdk-python_pr680 +globus_globus-sdk-python_pr681 +globus_globus-sdk-python_pr683 +globus_globus-sdk-python_pr684 +globus_globus-sdk-python_pr686 +globus_globus-sdk-python_pr687 +globus_globus-sdk-python_pr689 +globus_globus-sdk-python_pr690 +globus_globus-sdk-python_pr691 +globus_globus-sdk-python_pr693 +globus_globus-sdk-python_pr694 +globus_globus-sdk-python_pr695 +globus_globus-sdk-python_pr696 +globus_globus-sdk-python_pr698 +globus_globus-sdk-python_pr700 +globus_globus-sdk-python_pr708 +globus_globus-sdk-python_pr710 +globus_globus-sdk-python_pr712 +globus_globus-sdk-python_pr715 +globus_globus-sdk-python_pr72 +globus_globus-sdk-python_pr721 +globus_globus-sdk-python_pr722 +globus_globus-sdk-python_pr723 +globus_globus-sdk-python_pr725 +globus_globus-sdk-python_pr726 +globus_globus-sdk-python_pr736 +globus_globus-sdk-python_pr741 +globus_globus-sdk-python_pr743 +globus_globus-sdk-python_pr744 +globus_globus-sdk-python_pr745 +globus_globus-sdk-python_pr747 +globus_globus-sdk-python_pr749 +globus_globus-sdk-python_pr752 +globus_globus-sdk-python_pr757 +globus_globus-sdk-python_pr760 +globus_globus-sdk-python_pr764 +globus_globus-sdk-python_pr766 +globus_globus-sdk-python_pr769 +globus_globus-sdk-python_pr770 +globus_globus-sdk-python_pr772 +globus_globus-sdk-python_pr773 +globus_globus-sdk-python_pr774 +globus_globus-sdk-python_pr776 +globus_globus-sdk-python_pr778 +globus_globus-sdk-python_pr78 +globus_globus-sdk-python_pr782 +globus_globus-sdk-python_pr786 +globus_globus-sdk-python_pr790 +globus_globus-sdk-python_pr793 +globus_globus-sdk-python_pr798 +globus_globus-sdk-python_pr807 +globus_globus-sdk-python_pr809 +globus_globus-sdk-python_pr81 +globus_globus-sdk-python_pr813 +globus_globus-sdk-python_pr827 +globus_globus-sdk-python_pr828 +globus_globus-sdk-python_pr849 +globus_globus-sdk-python_pr85 +globus_globus-sdk-python_pr865 +globus_globus-sdk-python_pr868 +globus_globus-sdk-python_pr884 +globus_globus-sdk-python_pr887 +globus_globus-sdk-python_pr890 +globus_globus-sdk-python_pr892 +globus_globus-sdk-python_pr894 +globus_globus-sdk-python_pr895 +globus_globus-sdk-python_pr896 +globus_globus-sdk-python_pr897 +globus_globus-sdk-python_pr903 +globus_globus-sdk-python_pr920 +globus_globus-sdk-python_pr921 +globus_globus-sdk-python_pr922 +globus_globus-sdk-python_pr923 +globus_globus-sdk-python_pr927 +globus_globus-sdk-python_pr928 +globus_globus-sdk-python_pr93 +globus_globus-sdk-python_pr934 +globus_globus-sdk-python_pr936 +globus_globus-sdk-python_pr939 +globus_globus-sdk-python_pr94 +globus_globus-sdk-python_pr942 +globus_globus-sdk-python_pr948 +globus_globus-sdk-python_pr949 +globus_globus-sdk-python_pr95 +globus_globus-sdk-python_pr951 +globus_globus-sdk-python_pr952 +globus_globus-sdk-python_pr955 +globus_globus-sdk-python_pr956 +globus_globus-sdk-python_pr957 +globus_globus-sdk-python_pr958 +globus_globus-sdk-python_pr961 +globus_globus-sdk-python_pr965 +globus_globus-sdk-python_pr971 +globus_globus-sdk-python_pr972 +globus_globus-sdk-python_pr974 +globus_globus-sdk-python_pr975 +globus_globus-sdk-python_pr977 +globus_globus-sdk-python_pr979 +globus_globus-sdk-python_pr984 +globus_globus-sdk-python_pr986 +globus_globus-sdk-python_pr989 +globus_globus-sdk-python_pr990 +globus_globus-sdk-python_pr993 +globus_globus-sdk-python_pr994 +globus_globus-sdk-python_pr998 +glotzerlab_parsnip_pr29 +glotzerlab_parsnip_pr33 +glotzerlab_parsnip_pr34 +glotzerlab_parsnip_pr35 +glotzerlab_parsnip_pr38 +glut23_webvtt-py_pr66 +glut23_webvtt-py_pr67 +gmplot_gmplot_pr104 +gmplot_gmplot_pr110 +gmplot_gmplot_pr111 +gmplot_gmplot_pr115 +gmplot_gmplot_pr128 +gmplot_gmplot_pr136 +gmplot_gmplot_pr170 +gmplot_gmplot_pr181 +gmplot_gmplot_pr40 +gmr_pamqp_pr14 +gmr_pamqp_pr37 +gmr_pamqp_pr48 +gmr_pamqp_pr52 +gocardless_airflow-dbt_pr15 +gocardless_airflow-dbt_pr17 +gocardless_airflow-dbt_pr22 +gocardless_airflow-dbt_pr28 +gocardless_airflow-dbt_pr34 +gocardless_airflow-dbt_pr4 +gocardless_airflow-dbt_pr40 +gocardless_airflow-dbt_pr49 +gocardless_airflow-dbt_pr60 +godatadriven_pydantic-avro_pr10 +godatadriven_pydantic-avro_pr11 +godatadriven_pydantic-avro_pr113 +godatadriven_pydantic-avro_pr12 +godatadriven_pydantic-avro_pr137 +godatadriven_pydantic-avro_pr143 +godatadriven_pydantic-avro_pr144 +godatadriven_pydantic-avro_pr20 +godatadriven_pydantic-avro_pr26 +godatadriven_pydantic-avro_pr31 +godatadriven_pydantic-avro_pr4 +godatadriven_pydantic-avro_pr43 +godatadriven_pydantic-avro_pr49 +godatadriven_pydantic-avro_pr58 +godatadriven_pydantic-avro_pr8 +godatadriven_pydantic-avro_pr82 +golosegor_pyspark-nested-fields-functions_pr7 +goodmami_wn_pr173 +goodmami_wn_pr206 +goodmami_wn_pr218 +goodmami_wn_pr227 +goodmami_wn_pr229 +goodmami_wn_pr232 +goodmami_wn_pr240 +goodmami_wn_pr243 +goodmami_wn_pr247 +goodmami_wn_pr249 +goodmami_wn_pr251 +goodmami_wn_pr258 +goodmami_wn_pr259 +goodmami_wn_pr264 +goodmami_wn_pr284 +goodmami_wn_pr287 +goodmami_wn_pr288 +google-deepmind_treescope_pr27 +google-deepmind_treescope_pr33 +google-deepmind_treescope_pr43 +google-deepmind_treescope_pr48 +google_brotli_pr1021 +google_brotli_pr1022 +google_brotli_pr1023 +google_brotli_pr1182 +google_brotli_pr1278 +google_brotli_pr1282 +google_brotli_pr1305 +google_brotli_pr1316 +google_brotli_pr1326 +google_brotli_pr1328 +google_brotli_pr1329 +google_brotli_pr1330 +google_brotli_pr1340 +google_brotli_pr1342 +google_brotli_pr1349 +google_brotli_pr1392 +google_brotli_pr582 +google_brotli_pr583 +google_brotli_pr601 +google_brotli_pr611 +google_brotli_pr612 +google_brotli_pr636 +google_brotli_pr657 +google_brotli_pr677 +google_brotli_pr686 +google_brotli_pr699 +google_brotli_pr702 +google_brotli_pr709 +google_brotli_pr714 +google_brotli_pr719 +google_brotli_pr722 +google_brotli_pr761 +google_brotli_pr766 +google_brotli_pr768 +google_brotli_pr798 +google_brotli_pr887 +google_brotli_pr893 +google_brotli_pr906 +google_brotli_pr929 +google_brotli_pr965 +google_brotli_pr988 +google_brotli_pr997 +google_flatbuffers_pr235 +google_flatbuffers_pr237 +google_flatbuffers_pr238 +google_flatbuffers_pr259 +google_flatbuffers_pr286 +google_flatbuffers_pr288 +google_flatbuffers_pr344 +google_flatbuffers_pr3491 +google_flatbuffers_pr3493 +google_flatbuffers_pr363 +google_flatbuffers_pr3791 +google_flatbuffers_pr3816 +google_flatbuffers_pr3843 +google_flatbuffers_pr3844 +google_flatbuffers_pr3850 +google_flatbuffers_pr3854 +google_flatbuffers_pr3859 +google_flatbuffers_pr3905 +google_flatbuffers_pr3994 +google_flatbuffers_pr4003 +google_flatbuffers_pr4119 +google_flatbuffers_pr4132 +google_flatbuffers_pr4153 +google_flatbuffers_pr4197 +google_flatbuffers_pr4210 +google_flatbuffers_pr4214 +google_flatbuffers_pr4217 +google_flatbuffers_pr4259 +google_flatbuffers_pr4296 +google_flatbuffers_pr4301 +google_flatbuffers_pr4312 +google_flatbuffers_pr4341 +google_flatbuffers_pr4386 +google_flatbuffers_pr4395 +google_flatbuffers_pr4433 +google_flatbuffers_pr4452 +google_flatbuffers_pr4453 +google_flatbuffers_pr4459 +google_flatbuffers_pr4476 +google_flatbuffers_pr4481 +google_flatbuffers_pr4491 +google_flatbuffers_pr4516 +google_flatbuffers_pr4551 +google_flatbuffers_pr4572 +google_flatbuffers_pr4575 +google_flatbuffers_pr4583 +google_flatbuffers_pr4590 +google_flatbuffers_pr4594 +google_flatbuffers_pr4595 +google_flatbuffers_pr4608 +google_flatbuffers_pr4621 +google_flatbuffers_pr4633 +google_flatbuffers_pr4648 +google_flatbuffers_pr4672 +google_flatbuffers_pr4676 +google_flatbuffers_pr4695 +google_flatbuffers_pr4700 +google_flatbuffers_pr4701 +google_flatbuffers_pr4730 +google_flatbuffers_pr4736 +google_flatbuffers_pr4768 +google_flatbuffers_pr4781 +google_flatbuffers_pr4820 +google_flatbuffers_pr4829 +google_flatbuffers_pr4842 +google_flatbuffers_pr4849 +google_flatbuffers_pr4862 +google_flatbuffers_pr4912 +google_flatbuffers_pr4923 +google_flatbuffers_pr4926 +google_flatbuffers_pr4928 +google_flatbuffers_pr4933 +google_flatbuffers_pr4940 +google_flatbuffers_pr4944 +google_flatbuffers_pr4946 +google_flatbuffers_pr4966 +google_flatbuffers_pr4970 +google_flatbuffers_pr4975 +google_flatbuffers_pr4994 +google_flatbuffers_pr4995 +google_flatbuffers_pr5009 +google_flatbuffers_pr5021 +google_flatbuffers_pr5040 +google_flatbuffers_pr5105 +google_flatbuffers_pr5123 +google_flatbuffers_pr5128 +google_flatbuffers_pr5136 +google_flatbuffers_pr5139 +google_flatbuffers_pr5155 +google_flatbuffers_pr5168 +google_flatbuffers_pr5174 +google_flatbuffers_pr5177 +google_flatbuffers_pr5188 +google_flatbuffers_pr5205 +google_flatbuffers_pr5209 +google_flatbuffers_pr5221 +google_flatbuffers_pr5229 +google_flatbuffers_pr5232 +google_flatbuffers_pr5235 +google_flatbuffers_pr5271 +google_flatbuffers_pr5307 +google_flatbuffers_pr5314 +google_flatbuffers_pr5318 +google_flatbuffers_pr5336 +google_flatbuffers_pr5337 +google_flatbuffers_pr5344 +google_flatbuffers_pr5347 +google_flatbuffers_pr5355 +google_flatbuffers_pr5385 +google_flatbuffers_pr5421 +google_flatbuffers_pr5428 +google_flatbuffers_pr5486 +google_flatbuffers_pr5491 +google_flatbuffers_pr5512 +google_flatbuffers_pr5533 +google_flatbuffers_pr5543 +google_flatbuffers_pr5564 +google_flatbuffers_pr5574 +google_flatbuffers_pr5577 +google_flatbuffers_pr5579 +google_flatbuffers_pr5586 +google_flatbuffers_pr5587 +google_flatbuffers_pr5598 +google_flatbuffers_pr5613 +google_flatbuffers_pr5616 +google_flatbuffers_pr5631 +google_flatbuffers_pr5634 +google_flatbuffers_pr5640 +google_flatbuffers_pr5669 +google_flatbuffers_pr5681 +google_flatbuffers_pr5697 +google_flatbuffers_pr5707 +google_flatbuffers_pr5721 +google_flatbuffers_pr5725 +google_flatbuffers_pr5740 +google_flatbuffers_pr5752 +google_flatbuffers_pr5785 +google_flatbuffers_pr5802 +google_flatbuffers_pr5827 +google_flatbuffers_pr5830 +google_flatbuffers_pr5835 +google_flatbuffers_pr5853 +google_flatbuffers_pr5921 +google_flatbuffers_pr5934 +google_flatbuffers_pr5938 +google_flatbuffers_pr5981 +google_flatbuffers_pr5991 +google_flatbuffers_pr5998 +google_flatbuffers_pr5999 +google_flatbuffers_pr6004 +google_flatbuffers_pr6009 +google_flatbuffers_pr6016 +google_flatbuffers_pr6029 +google_flatbuffers_pr6040 +google_flatbuffers_pr608 +google_flatbuffers_pr6095 +google_flatbuffers_pr6098 +google_flatbuffers_pr6105 +google_flatbuffers_pr6129 +google_flatbuffers_pr6135 +google_flatbuffers_pr6137 +google_flatbuffers_pr6142 +google_flatbuffers_pr6155 +google_flatbuffers_pr6156 +google_flatbuffers_pr6193 +google_flatbuffers_pr6206 +google_flatbuffers_pr6207 +google_flatbuffers_pr6210 +google_flatbuffers_pr6214 +google_flatbuffers_pr6217 +google_flatbuffers_pr6232 +google_flatbuffers_pr6235 +google_flatbuffers_pr6256 +google_flatbuffers_pr6257 +google_flatbuffers_pr6269 +google_flatbuffers_pr6308 +google_flatbuffers_pr6318 +google_flatbuffers_pr6328 +google_flatbuffers_pr6336 +google_flatbuffers_pr6354 +google_flatbuffers_pr6365 +google_flatbuffers_pr6373 +google_flatbuffers_pr6387 +google_flatbuffers_pr6388 +google_flatbuffers_pr6389 +google_flatbuffers_pr6392 +google_flatbuffers_pr6403 +google_flatbuffers_pr6417 +google_flatbuffers_pr6450 +google_flatbuffers_pr6452 +google_flatbuffers_pr6456 +google_flatbuffers_pr6539 +google_flatbuffers_pr6554 +google_flatbuffers_pr6564 +google_flatbuffers_pr6588 +google_flatbuffers_pr6592 +google_flatbuffers_pr6593 +google_flatbuffers_pr6606 +google_flatbuffers_pr6635 +google_flatbuffers_pr6651 +google_flatbuffers_pr6661 +google_flatbuffers_pr6662 +google_flatbuffers_pr6663 +google_flatbuffers_pr6716 +google_flatbuffers_pr6722 +google_flatbuffers_pr6723 +google_flatbuffers_pr6725 +google_flatbuffers_pr6729 +google_flatbuffers_pr6735 +google_flatbuffers_pr6736 +google_flatbuffers_pr6743 +google_flatbuffers_pr6755 +google_flatbuffers_pr6758 +google_flatbuffers_pr6769 +google_flatbuffers_pr6785 +google_flatbuffers_pr6802 +google_flatbuffers_pr6808 +google_flatbuffers_pr6815 +google_flatbuffers_pr6852 +google_flatbuffers_pr6866 +google_flatbuffers_pr6868 +google_flatbuffers_pr6879 +google_flatbuffers_pr6915 +google_flatbuffers_pr6920 +google_flatbuffers_pr6924 +google_importlab_pr10 +google_importlab_pr13 +google_importlab_pr17 +google_importlab_pr20 +google_importlab_pr23 +google_importlab_pr29 +google_importlab_pr30 +google_importlab_pr5 +google_importlab_pr54 +google_importlab_pr56 +google_importlab_pr7 +google_importlab_pr9 +google_mediapy_pr10 +google_mediapy_pr22 +google_mediapy_pr28 +google_mediapy_pr34 +google_mediapy_pr35 +google_mediapy_pr46 +google_mediapy_pr48 +google_mediapy_pr52 +google_mediapy_pr55 +google_mediapy_pr60 +google_pasta_pr10 +google_pasta_pr11 +google_pinject_pr49 +googleapis_proto-plus-python_pr107 +googleapis_proto-plus-python_pr110 +googleapis_proto-plus-python_pr112 +googleapis_proto-plus-python_pr118 +googleapis_proto-plus-python_pr129 +googleapis_proto-plus-python_pr140 +googleapis_proto-plus-python_pr154 +googleapis_proto-plus-python_pr164 +googleapis_proto-plus-python_pr178 +googleapis_proto-plus-python_pr180 +googleapis_proto-plus-python_pr202 +googleapis_proto-plus-python_pr211 +googleapis_proto-plus-python_pr213 +googleapis_proto-plus-python_pr215 +googleapis_proto-plus-python_pr226 +googleapis_proto-plus-python_pr227 +googleapis_proto-plus-python_pr232 +googleapis_proto-plus-python_pr248 +googleapis_proto-plus-python_pr252 +googleapis_proto-plus-python_pr255 +googleapis_proto-plus-python_pr267 +googleapis_proto-plus-python_pr280 +googleapis_proto-plus-python_pr295 +googleapis_proto-plus-python_pr301 +googleapis_proto-plus-python_pr302 +googleapis_proto-plus-python_pr327 +googleapis_proto-plus-python_pr334 +googleapis_proto-plus-python_pr336 +googleapis_proto-plus-python_pr348 +googleapis_proto-plus-python_pr35 +googleapis_proto-plus-python_pr384 +googleapis_proto-plus-python_pr39 +googleapis_proto-plus-python_pr40 +googleapis_proto-plus-python_pr433 +googleapis_proto-plus-python_pr477 +googleapis_proto-plus-python_pr57 +googleapis_proto-plus-python_pr61 +googleapis_proto-plus-python_pr73 +googleapis_proto-plus-python_pr90 +googleapis_proto-plus-python_pr92 +googleapis_python-datastore_pr104 +googleapis_python-datastore_pr115 +googleapis_python-datastore_pr120 +googleapis_python-datastore_pr123 +googleapis_python-datastore_pr136 +googleapis_python-datastore_pr141 +googleapis_python-datastore_pr143 +googleapis_python-datastore_pr165 +googleapis_python-datastore_pr19 +googleapis_python-datastore_pr190 +googleapis_python-datastore_pr239 +googleapis_python-datastore_pr242 +googleapis_python-datastore_pr248 +googleapis_python-db-dtypes-pandas_pr100 +googleapis_python-db-dtypes-pandas_pr102 +googleapis_python-db-dtypes-pandas_pr11 +googleapis_python-db-dtypes-pandas_pr20 +googleapis_python-db-dtypes-pandas_pr32 +googleapis_python-db-dtypes-pandas_pr39 +googleapis_python-db-dtypes-pandas_pr54 +googleapis_python-db-dtypes-pandas_pr60 +googleapis_python-db-dtypes-pandas_pr64 +googleapis_python-db-dtypes-pandas_pr8 +googleapis_python-db-dtypes-pandas_pr85 +googleapis_python-documentai-toolbox_pr10 +googleapis_python-documentai-toolbox_pr12 +googleapis_python-documentai-toolbox_pr14 +googleapis_python-documentai-toolbox_pr15 +googleapis_python-documentai-toolbox_pr17 +googleapis_python-documentai-toolbox_pr21 +googleapis_python-documentai-toolbox_pr23 +googleapis_python-documentai-toolbox_pr7 +googleapis_python-firestore_pr182 +googleapis_python-firestore_pr202 +googleapis_python-firestore_pr205 +googleapis_python-firestore_pr219 +googleapis_python-firestore_pr222 +googleapis_python-firestore_pr225 +googleapis_python-firestore_pr254 +googleapis_python-firestore_pr256 +googleapis_python-firestore_pr269 +googleapis_python-firestore_pr274 +googleapis_python-firestore_pr280 +googleapis_python-firestore_pr300 +googleapis_python-firestore_pr316 +googleapis_python-firestore_pr319 +googleapis_python-firestore_pr325 +googleapis_python-firestore_pr331 +googleapis_python-firestore_pr340 +googleapis_python-firestore_pr370 +googleapis_python-firestore_pr385 +googleapis_python-firestore_pr388 +googleapis_python-firestore_pr396 +googleapis_python-firestore_pr402 +googleapis_python-firestore_pr405 +googleapis_python-firestore_pr407 +googleapis_python-firestore_pr420 +googleapis_python-firestore_pr440 +googleapis_python-firestore_pr452 +googleapis_python-firestore_pr456 +googleapis_python-firestore_pr458 +googleapis_python-firestore_pr464 +googleapis_python-firestore_pr467 +googleapis_python-firestore_pr500 +googleapis_python-firestore_pr501 +googleapis_python-firestore_pr513 +googleapis_python-firestore_pr523 +googleapis_python-runtimeconfig_pr265 +googlefonts_ufo2ft_pr289 +googlefonts_ufo2ft_pr299 +googlefonts_ufo2ft_pr300 +googlefonts_ufo2ft_pr314 +googlefonts_ufo2ft_pr316 +googlefonts_ufo2ft_pr318 +googlefonts_ufo2ft_pr322 +googlefonts_ufo2ft_pr324 +googlefonts_ufo2ft_pr333 +googlefonts_ufo2ft_pr335 +googlefonts_ufo2ft_pr354 +googlefonts_ufo2ft_pr358 +googlefonts_ufo2ft_pr359 +googlefonts_ufo2ft_pr361 +googlefonts_ufo2ft_pr364 +googlefonts_ufo2ft_pr380 +googlefonts_ufo2ft_pr495 +googlefonts_ufo2ft_pr714 +googlefonts_ufo2ft_pr732 +googlefonts_ufo2ft_pr772 +googlefonts_ufo2ft_pr780 +googlefonts_ufo2ft_pr787 +googlefonts_ufo2ft_pr79 +googlefonts_ufo2ft_pr796 +googlefonts_ufo2ft_pr805 +googlefonts_ufo2ft_pr811 +googlefonts_ufo2ft_pr813 +googlefonts_ufo2ft_pr815 +googlefonts_ufo2ft_pr816 +googlefonts_ufo2ft_pr817 +googlefonts_ufo2ft_pr821 +googlefonts_ufo2ft_pr826 +googlefonts_ufo2ft_pr840 +googlefonts_ufo2ft_pr841 +googlefonts_ufo2ft_pr842 +googlefonts_ufo2ft_pr845 +googlefonts_ufo2ft_pr866 +googlefonts_ufo2ft_pr869 +googlefonts_ufo2ft_pr870 +googlefonts_ufo2ft_pr871 +googlefonts_ufo2ft_pr873 +googlefonts_ufo2ft_pr876 +googlefonts_ufo2ft_pr881 +googlefonts_ufo2ft_pr886 +googlefonts_ufo2ft_pr89 +googlefonts_ufo2ft_pr897 +googlefonts_ufo2ft_pr909 +googlefonts_ufo2ft_pr916 +googlefonts_ufo2ft_pr918 +googlefonts_ufo2ft_pr926 +googlefonts_ufo2ft_pr931 +googlefonts_ufo2ft_pr935 +googlefonts_ufo2ft_pr936 +googlefonts_ufo2ft_pr942 +googlefonts_ufo2ft_pr943 +goose3_goose3_pr118 +goose3_goose3_pr119 +goose3_goose3_pr126 +goose3_goose3_pr134 +goose3_goose3_pr137 +goose3_goose3_pr138 +goose3_goose3_pr142 +goose3_goose3_pr147 +goose3_goose3_pr149 +goose3_goose3_pr152 +goose3_goose3_pr154 +goose3_goose3_pr157 +goose3_goose3_pr159 +goose3_goose3_pr162 +goose3_goose3_pr163 +goose3_goose3_pr168 +goose3_goose3_pr171 +goose3_goose3_pr176 +goose3_goose3_pr180 +goose3_goose3_pr214 +goose3_goose3_pr24 +goose3_goose3_pr25 +goose3_goose3_pr35 +goose3_goose3_pr43 +goose3_goose3_pr46 +goose3_goose3_pr52 +goose3_goose3_pr54 +goose3_goose3_pr60 +goose3_goose3_pr64 +goose3_goose3_pr66 +goose3_goose3_pr73 +goose3_goose3_pr77 +goose3_goose3_pr80 +goose3_goose3_pr85 +goose3_goose3_pr89 +goose3_goose3_pr90 +goose3_goose3_pr93 +gorakhargosh_watchdog_pr1011 +gorakhargosh_watchdog_pr1014 +gorakhargosh_watchdog_pr1032 +gorakhargosh_watchdog_pr1033 +gorakhargosh_watchdog_pr1050 +gorakhargosh_watchdog_pr1051 +gorakhargosh_watchdog_pr1055 +gorakhargosh_watchdog_pr1057 +gorakhargosh_watchdog_pr1060 +gorakhargosh_watchdog_pr1084 +gorakhargosh_watchdog_pr1086 +gorakhargosh_watchdog_pr1088 +gorakhargosh_watchdog_pr1096 +gorakhargosh_watchdog_pr1101 +gorakhargosh_watchdog_pr1102 +gorakhargosh_watchdog_pr464 +gorakhargosh_watchdog_pr477 +gorakhargosh_watchdog_pr498 +gorakhargosh_watchdog_pr503 +gorakhargosh_watchdog_pr506 +gorakhargosh_watchdog_pr513 +gorakhargosh_watchdog_pr515 +gorakhargosh_watchdog_pr527 +gorakhargosh_watchdog_pr528 +gorakhargosh_watchdog_pr530 +gorakhargosh_watchdog_pr534 +gorakhargosh_watchdog_pr536 +gorakhargosh_watchdog_pr573 +gorakhargosh_watchdog_pr581 +gorakhargosh_watchdog_pr588 +gorakhargosh_watchdog_pr597 +gorakhargosh_watchdog_pr602 +gorakhargosh_watchdog_pr616 +gorakhargosh_watchdog_pr622 +gorakhargosh_watchdog_pr631 +gorakhargosh_watchdog_pr642 +gorakhargosh_watchdog_pr655 +gorakhargosh_watchdog_pr676 +gorakhargosh_watchdog_pr677 +gorakhargosh_watchdog_pr698 +gorakhargosh_watchdog_pr704 +gorakhargosh_watchdog_pr726 +gorakhargosh_watchdog_pr727 +gorakhargosh_watchdog_pr733 +gorakhargosh_watchdog_pr734 +gorakhargosh_watchdog_pr742 +gorakhargosh_watchdog_pr750 +gorakhargosh_watchdog_pr760 +gorakhargosh_watchdog_pr783 +gorakhargosh_watchdog_pr786 +gorakhargosh_watchdog_pr796 +gorakhargosh_watchdog_pr799 +gorakhargosh_watchdog_pr807 +gorakhargosh_watchdog_pr810 +gorakhargosh_watchdog_pr814 +gorakhargosh_watchdog_pr815 +gorakhargosh_watchdog_pr831 +gorakhargosh_watchdog_pr836 +gorakhargosh_watchdog_pr861 +gorakhargosh_watchdog_pr869 +gorakhargosh_watchdog_pr872 +gorakhargosh_watchdog_pr886 +gorakhargosh_watchdog_pr887 +gorakhargosh_watchdog_pr895 +gorakhargosh_watchdog_pr896 +gorakhargosh_watchdog_pr897 +gorakhargosh_watchdog_pr908 +gorakhargosh_watchdog_pr940 +gorakhargosh_watchdog_pr946 +gorakhargosh_watchdog_pr959 +gorakhargosh_watchdog_pr968 +gorakhargosh_watchdog_pr969 +gorakhargosh_watchdog_pr986 +gorakhargosh_watchdog_pr989 +gotcha_ipdb_pr193 +gotcha_ipdb_pr213 +gotcha_ipdb_pr263 +grafana-toolbox_grafana-client_pr27 +grafana-toolbox_grafana-client_pr28 +grafana-toolbox_grafana-client_pr34 +grafana-toolbox_grafana-client_pr7 +grafana-toolbox_grafana-client_pr9 +graphql-python_graphql-server-core_pr37 +graphql-python_graphql-server_pr35 +gristlabs_asttokens_pr114 +gristlabs_asttokens_pr116 +gristlabs_asttokens_pr155 +gristlabs_asttokens_pr156 +gristlabs_asttokens_pr167 +growthbook_growthbook-python_pr19 +growthbook_growthbook-python_pr22 +growthbook_growthbook-python_pr30 +growthbook_growthbook-python_pr40 +growthbook_growthbook-python_pr41 +growthbook_growthbook-python_pr55 +growthbook_growthbook-python_pr64 +growthbook_growthbook-python_pr66 +growthbook_growthbook-python_pr77 +gruebel_pycep_pr109 +gruebel_pycep_pr120 +gruebel_pycep_pr137 +gruebel_pycep_pr151 +gruebel_pycep_pr180 +gruebel_pycep_pr181 +gruebel_pycep_pr320 +gruebel_pycep_pr321 +gruebel_pycep_pr322 +gruebel_pycep_pr323 +gruebel_pycep_pr326 +gruebel_pycep_pr327 +gruebel_pycep_pr328 +gruebel_pycep_pr33 +gruebel_pycep_pr41 +gruebel_pycep_pr52 +gruebel_pycep_pr64 +gtaylor_python-colormath_pr37 +guillermo-navas-palencia_optbinning_pr101 +guillermo-navas-palencia_optbinning_pr18 +guillermo-navas-palencia_optbinning_pr23 +guillermo-navas-palencia_optbinning_pr28 +guillermo-navas-palencia_optbinning_pr34 +guillermo-navas-palencia_optbinning_pr42 +guillermo-navas-palencia_optbinning_pr44 +guillermo-navas-palencia_optbinning_pr5 +guillermo-navas-palencia_optbinning_pr95 +guillermo-navas-palencia_optbinning_pr97 +guillp_jwskate_pr13 +guillp_jwskate_pr16 +guillp_jwskate_pr17 +guillp_jwskate_pr19 +guillp_jwskate_pr2 +guillp_jwskate_pr21 +guillp_jwskate_pr22 +guillp_jwskate_pr26 +guillp_jwskate_pr27 +guillp_jwskate_pr3 +guillp_jwskate_pr4 +guillp_jwskate_pr43 +guillp_jwskate_pr45 +guysalt_python-inquirer3_pr61 +guysalt_python-inquirer3_pr67 +guysalt_python-inquirer3_pr94 +h2oai_authn-py_pr13 +h2oai_authn-py_pr4 +h2oai_authn-py_pr5 +h2oai_cloud-discovery-py_pr13 +h2oai_cloud-discovery-py_pr18 +h2oai_cloud-discovery-py_pr19 +h2oai_cloud-discovery-py_pr20 +h2oai_cloud-discovery-py_pr21 +h2oai_cloud-discovery-py_pr8 +h5io_h5io_pr58 +h5netcdf_h5netcdf_pr102 +h5netcdf_h5netcdf_pr104 +h5netcdf_h5netcdf_pr107 +h5netcdf_h5netcdf_pr108 +h5netcdf_h5netcdf_pr109 +h5netcdf_h5netcdf_pr112 +h5netcdf_h5netcdf_pr117 +h5netcdf_h5netcdf_pr121 +h5netcdf_h5netcdf_pr125 +h5netcdf_h5netcdf_pr126 +h5netcdf_h5netcdf_pr127 +h5netcdf_h5netcdf_pr129 +h5netcdf_h5netcdf_pr135 +h5netcdf_h5netcdf_pr140 +h5netcdf_h5netcdf_pr150 +h5netcdf_h5netcdf_pr151 +h5netcdf_h5netcdf_pr155 +h5netcdf_h5netcdf_pr166 +h5netcdf_h5netcdf_pr168 +h5netcdf_h5netcdf_pr181 +h5netcdf_h5netcdf_pr183 +h5netcdf_h5netcdf_pr186 +h5netcdf_h5netcdf_pr194 +h5netcdf_h5netcdf_pr213 +h5netcdf_h5netcdf_pr218 +h5netcdf_h5netcdf_pr220 +h5netcdf_h5netcdf_pr238 +h5netcdf_h5netcdf_pr252 +h5netcdf_h5netcdf_pr256 +h5netcdf_h5netcdf_pr265 +h5netcdf_h5netcdf_pr270 +h5netcdf_h5netcdf_pr275 +h5netcdf_h5netcdf_pr285 +h5netcdf_h5netcdf_pr286 +h5netcdf_h5netcdf_pr288 +h5netcdf_h5netcdf_pr294 +h5netcdf_h5netcdf_pr297 +h5netcdf_h5netcdf_pr85 +h5netcdf_h5netcdf_pr95 +h5netcdf_h5netcdf_pr99 +hackebrot_jinja2-time_pr3 +hadialqattan_pycln_pr100 +hadialqattan_pycln_pr101 +hadialqattan_pycln_pr102 +hadialqattan_pycln_pr103 +hadialqattan_pycln_pr110 +hadialqattan_pycln_pr118 +hadialqattan_pycln_pr120 +hadialqattan_pycln_pr121 +hadialqattan_pycln_pr137 +hadialqattan_pycln_pr143 +hadialqattan_pycln_pr144 +hadialqattan_pycln_pr145 +hadialqattan_pycln_pr147 +hadialqattan_pycln_pr153 +hadialqattan_pycln_pr155 +hadialqattan_pycln_pr156 +hadialqattan_pycln_pr162 +hadialqattan_pycln_pr175 +hadialqattan_pycln_pr178 +hadialqattan_pycln_pr189 +hadialqattan_pycln_pr190 +hadialqattan_pycln_pr197 +hadialqattan_pycln_pr200 +hadialqattan_pycln_pr211 +hadialqattan_pycln_pr220 +hadialqattan_pycln_pr224 +hadialqattan_pycln_pr250 +hadialqattan_pycln_pr277 +hadialqattan_pycln_pr86 +hadialqattan_pycln_pr87 +hadialqattan_pycln_pr88 +hadialqattan_pycln_pr92 +hadialqattan_pycln_pr95 +hadialqattan_pycln_pr97 +hadialqattan_pycln_pr98 +hajimes_mmh3_pr79 +hakancelikdev_unimport_pr102 +hakancelikdev_unimport_pr105 +hakancelikdev_unimport_pr107 +hakancelikdev_unimport_pr108 +hakancelikdev_unimport_pr111 +hakancelikdev_unimport_pr112 +hakancelikdev_unimport_pr119 +hakancelikdev_unimport_pr125 +hakancelikdev_unimport_pr128 +hakancelikdev_unimport_pr130 +hakancelikdev_unimport_pr136 +hakancelikdev_unimport_pr138 +hakancelikdev_unimport_pr142 +hakancelikdev_unimport_pr145 +hakancelikdev_unimport_pr147 +hakancelikdev_unimport_pr149 +hakancelikdev_unimport_pr155 +hakancelikdev_unimport_pr157 +hakancelikdev_unimport_pr158 +hakancelikdev_unimport_pr159 +hakancelikdev_unimport_pr161 +hakancelikdev_unimport_pr172 +hakancelikdev_unimport_pr181 +hakancelikdev_unimport_pr185 +hakancelikdev_unimport_pr189 +hakancelikdev_unimport_pr191 +hakancelikdev_unimport_pr193 +hakancelikdev_unimport_pr208 +hakancelikdev_unimport_pr230 +hakancelikdev_unimport_pr234 +hakancelikdev_unimport_pr24 +hakancelikdev_unimport_pr241 +hakancelikdev_unimport_pr266 +hakancelikdev_unimport_pr279 +hakancelikdev_unimport_pr289 +hakancelikdev_unimport_pr29 +hakancelikdev_unimport_pr31 +hakancelikdev_unimport_pr34 +hakancelikdev_unimport_pr50 +hakancelikdev_unimport_pr53 +hakancelikdev_unimport_pr54 +hakancelikdev_unimport_pr55 +hakancelikdev_unimport_pr60 +hakancelikdev_unimport_pr61 +hakancelikdev_unimport_pr62 +hakancelikdev_unimport_pr64 +hakancelikdev_unimport_pr71 +hakancelikdev_unimport_pr81 +hakancelikdev_unimport_pr83 +hakancelikdev_unimport_pr86 +hakancelikdev_unimport_pr95 +hamdanal_rich-argparse_pr122 +hamdanal_rich-argparse_pr123 +hamdanal_rich-argparse_pr124 +hamdanal_rich-argparse_pr131 +hamdanal_rich-argparse_pr135 +hamdanal_rich-argparse_pr14 +hamdanal_rich-argparse_pr142 +hamdanal_rich-argparse_pr149 +hamdanal_rich-argparse_pr153 +hamdanal_rich-argparse_pr17 +hamdanal_rich-argparse_pr20 +hamdanal_rich-argparse_pr21 +hamdanal_rich-argparse_pr23 +hamdanal_rich-argparse_pr37 +hamdanal_rich-argparse_pr38 +hamdanal_rich-argparse_pr43 +hamdanal_rich-argparse_pr45 +hamdanal_rich-argparse_pr50 +hamdanal_rich-argparse_pr57 +hamdanal_rich-argparse_pr68 +hamdanal_rich-argparse_pr74 +hamdanal_rich-argparse_pr75 +hamdanal_rich-argparse_pr90 +hamdanal_rich-argparse_pr92 +hamdanal_rich-argparse_pr97 +hamdanal_rich-argparse_pr98 +hammem_monarchmoney_pr102 +hammem_monarchmoney_pr120 +hammem_monarchmoney_pr83 +hammem_monarchmoney_pr84 +hammem_monarchmoney_pr85 +hammem_monarchmoney_pr92 +hammem_monarchmoney_pr93 +harlowja_fasteners_pr13 +harlowja_fasteners_pr21 +harlowja_fasteners_pr23 +harlowja_fasteners_pr3 +harlowja_fasteners_pr73 +heremaps_flexible-polyline_pr1 +heremaps_flexible-polyline_pr24 +heroku_salesforce-bulk_pr42 +heroku_salesforce-bulk_pr49 +heroku_salesforce-bulk_pr86 +hetznercloud_hcloud-python_pr104 +hetznercloud_hcloud-python_pr106 +hetznercloud_hcloud-python_pr116 +hetznercloud_hcloud-python_pr134 +hetznercloud_hcloud-python_pr135 +hetznercloud_hcloud-python_pr137 +hetznercloud_hcloud-python_pr140 +hetznercloud_hcloud-python_pr144 +hetznercloud_hcloud-python_pr160 +hetznercloud_hcloud-python_pr185 +hetznercloud_hcloud-python_pr192 +hetznercloud_hcloud-python_pr199 +hetznercloud_hcloud-python_pr208 +hetznercloud_hcloud-python_pr222 +hetznercloud_hcloud-python_pr227 +hetznercloud_hcloud-python_pr228 +hetznercloud_hcloud-python_pr231 +hetznercloud_hcloud-python_pr240 +hetznercloud_hcloud-python_pr243 +hetznercloud_hcloud-python_pr246 +hetznercloud_hcloud-python_pr251 +hetznercloud_hcloud-python_pr252 +hetznercloud_hcloud-python_pr253 +hetznercloud_hcloud-python_pr256 +hetznercloud_hcloud-python_pr272 +hetznercloud_hcloud-python_pr276 +hetznercloud_hcloud-python_pr279 +hetznercloud_hcloud-python_pr297 +hetznercloud_hcloud-python_pr300 +hetznercloud_hcloud-python_pr318 +hetznercloud_hcloud-python_pr320 +hetznercloud_hcloud-python_pr331 +hetznercloud_hcloud-python_pr363 +hetznercloud_hcloud-python_pr373 +hetznercloud_hcloud-python_pr376 +hetznercloud_hcloud-python_pr403 +hetznercloud_hcloud-python_pr404 +hetznercloud_hcloud-python_pr412 +hetznercloud_hcloud-python_pr416 +hetznercloud_hcloud-python_pr417 +hetznercloud_hcloud-python_pr423 +hetznercloud_hcloud-python_pr426 +hetznercloud_hcloud-python_pr430 +hetznercloud_hcloud-python_pr481 +hetznercloud_hcloud-python_pr488 +hetznercloud_hcloud-python_pr496 +hetznercloud_hcloud-python_pr504 +hetznercloud_hcloud-python_pr510 +hetznercloud_hcloud-python_pr511 +hetznercloud_hcloud-python_pr536 +hetznercloud_hcloud-python_pr542 +hetznercloud_hcloud-python_pr544 +hetznercloud_hcloud-python_pr558 +hetznercloud_hcloud-python_pr564 +hetznercloud_hcloud-python_pr568 +hetznercloud_hcloud-python_pr578 +hetznercloud_hcloud-python_pr580 +hetznercloud_hcloud-python_pr588 +hetznercloud_hcloud-python_pr590 +hetznercloud_hcloud-python_pr597 +hh-h_aiohttp-swagger3_pr15 +hh-h_aiohttp-swagger3_pr18 +hh-h_aiohttp-swagger3_pr92 +hhatto_autopep8_pr266 +hhatto_autopep8_pr267 +hhatto_autopep8_pr285 +hhatto_autopep8_pr288 +hhatto_autopep8_pr295 +hhatto_autopep8_pr308 +hhatto_autopep8_pr309 +hhatto_autopep8_pr310 +hhatto_autopep8_pr312 +hhatto_autopep8_pr313 +hhatto_autopep8_pr321 +hhatto_autopep8_pr336 +hhatto_autopep8_pr341 +hhatto_autopep8_pr350 +hhatto_autopep8_pr352 +hhatto_autopep8_pr354 +hhatto_autopep8_pr358 +hhatto_autopep8_pr371 +hhatto_autopep8_pr376 +hhatto_autopep8_pr386 +hhatto_autopep8_pr390 +hhatto_autopep8_pr397 +hhatto_autopep8_pr418 +hhatto_autopep8_pr420 +hhatto_autopep8_pr421 +hhatto_autopep8_pr423 +hhatto_autopep8_pr425 +hhatto_autopep8_pr437 +hhatto_autopep8_pr442 +hhatto_autopep8_pr450 +hhatto_autopep8_pr461 +hhatto_autopep8_pr464 +hhatto_autopep8_pr466 +hhatto_autopep8_pr491 +hhatto_autopep8_pr493 +hhatto_autopep8_pr494 +hhatto_autopep8_pr496 +hhatto_autopep8_pr498 +hhatto_autopep8_pr510 +hhatto_autopep8_pr511 +hhatto_autopep8_pr525 +hhatto_autopep8_pr526 +hhatto_autopep8_pr530 +hhatto_autopep8_pr532 +hhatto_autopep8_pr533 +hhatto_autopep8_pr537 +hhatto_autopep8_pr541 +hhatto_autopep8_pr546 +hhatto_autopep8_pr557 +hhatto_autopep8_pr580 +hhatto_autopep8_pr595 +hhatto_autopep8_pr597 +hhatto_autopep8_pr604 +hhatto_autopep8_pr608 +hhatto_autopep8_pr609 +hhatto_autopep8_pr618 +hhatto_autopep8_pr627 +hhatto_autopep8_pr642 +hhatto_autopep8_pr643 +hhatto_autopep8_pr650 +hhatto_autopep8_pr653 +hhatto_autopep8_pr663 +hhatto_autopep8_pr677 +hhatto_autopep8_pr748 +hhatto_autopep8_pr749 +hhatto_autopep8_pr750 +hhatto_autopep8_pr752 +hhatto_autopep8_pr758 +hhatto_autopep8_pr776 +hhatto_autopep8_pr787 +hightouchio_airflow-provider-hightouch_pr8 +hinthornw_dydantic_pr3 +holoviz-dev_pyct_pr76 +holoviz-dev_pyct_pr98 +holoviz_param_pr425 +holoviz_param_pr531 +holoviz_param_pr542 +holoviz_param_pr598 +holoviz_param_pr655 +holoviz_param_pr691 +holoviz_param_pr722 +holoviz_param_pr725 +holoviz_param_pr729 +holoviz_param_pr733 +holoviz_param_pr738 +holoviz_param_pr741 +holoviz_param_pr742 +holoviz_param_pr751 +holoviz_param_pr753 +holoviz_param_pr765 +holoviz_param_pr766 +holoviz_param_pr769 +holoviz_param_pr771 +holoviz_param_pr774 +holoviz_param_pr775 +holoviz_param_pr777 +holoviz_param_pr778 +holoviz_param_pr783 +holoviz_param_pr786 +holoviz_param_pr789 +holoviz_param_pr791 +holoviz_param_pr794 +holoviz_param_pr795 +holoviz_param_pr797 +holoviz_param_pr799 +holoviz_param_pr800 +holoviz_param_pr801 +holoviz_param_pr802 +holoviz_param_pr808 +holoviz_param_pr812 +holoviz_param_pr813 +holoviz_param_pr814 +holoviz_param_pr817 +holoviz_param_pr820 +holoviz_param_pr824 +holoviz_param_pr826 +holoviz_param_pr831 +holoviz_param_pr833 +holoviz_param_pr834 +holoviz_param_pr838 +holoviz_param_pr840 +holoviz_param_pr843 +holoviz_param_pr844 +holoviz_param_pr854 +holoviz_param_pr856 +holoviz_param_pr859 +holoviz_param_pr873 +holoviz_param_pr874 +holoviz_param_pr876 +holoviz_param_pr884 +holoviz_param_pr886 +holoviz_param_pr893 +holoviz_param_pr894 +holoviz_param_pr903 +holoviz_param_pr906 +holoviz_param_pr908 +holoviz_param_pr917 +holoviz_param_pr918 +holoviz_param_pr919 +holoviz_param_pr921 +holoviz_param_pr929 +holoviz_param_pr938 +holoviz_param_pr946 +holoviz_param_pr949 +holoviz_param_pr962 +home-assistant-libs_python-supervisor-client_pr152 +home-assistant-libs_python-supervisor-client_pr167 +home-assistant-libs_voluptuous-openapi_pr13 +home-assistant-libs_voluptuous-openapi_pr21 +home-assistant-libs_voluptuous-openapi_pr23 +home-assistant-libs_voluptuous-openapi_pr24 +home-assistant-libs_voluptuous-openapi_pr41 +home-assistant-libs_voluptuous-openapi_pr66 +home-assistant-libs_voluptuous-openapi_pr8 +home-assistant-libs_voluptuous-serialize_pr12 +home-assistant-libs_voluptuous-serialize_pr152 +home-assistant-libs_voluptuous-serialize_pr155 +home-assistant-libs_voluptuous-serialize_pr159 +honeybadger-io_honeybadger-python_pr163 +honeybadger-io_honeybadger-python_pr166 +honeybadger-io_honeybadger-python_pr170 +honeybadger-io_honeybadger-python_pr189 +honeybadger-io_honeybadger-python_pr196 +honeybadger-io_honeybadger-python_pr203 +honeybadger-io_honeybadger-python_pr207 +honeybadger-io_honeybadger-python_pr218 +honeybadger-io_honeybadger-python_pr225 +honeybadger-io_honeybadger-python_pr25 +honeybadger-io_honeybadger-python_pr28 +honeybadger-io_honeybadger-python_pr38 +honeybadger-io_honeybadger-python_pr50 +honeybadger-io_honeybadger-python_pr58 +honeybadger-io_honeybadger-python_pr63 +honeybadger-io_honeybadger-python_pr66 +honeybadger-io_honeybadger-python_pr67 +honeybadger-io_honeybadger-python_pr81 +honeycombio_libhoney-py_pr111 +honeycombio_libhoney-py_pr117 +honeycombio_libhoney-py_pr121 +honeycombio_libhoney-py_pr69 +honeycombio_libhoney-py_pr88 +honeycombio_libhoney-py_pr97 +horejsek_python-fastjsonschema_pr11 +horejsek_python-fastjsonschema_pr110 +horejsek_python-fastjsonschema_pr130 +horejsek_python-fastjsonschema_pr14 +horejsek_python-fastjsonschema_pr145 +horejsek_python-fastjsonschema_pr176 +horejsek_python-fastjsonschema_pr24 +horejsek_python-fastjsonschema_pr27 +horejsek_python-fastjsonschema_pr3 +horejsek_python-fastjsonschema_pr34 +horejsek_python-fastjsonschema_pr52 +horejsek_python-fastjsonschema_pr77 +horejsek_python-fastjsonschema_pr80 +horejsek_python-fastjsonschema_pr82 +houfu_redlines_pr19 +houfu_redlines_pr23 +houfu_redlines_pr28 +houfu_redlines_pr4 +houfu_redlines_pr63 +houfu_redlines_pr70 +houfu_redlines_pr72 +houfu_redlines_pr74 +hplt-project_sacremoses_pr14 +hplt-project_sacremoses_pr22 +hplt-project_sacremoses_pr29 +hplt-project_sacremoses_pr31 +hplt-project_sacremoses_pr39 +hplt-project_sacremoses_pr45 +hplt-project_sacremoses_pr47 +hplt-project_sacremoses_pr54 +hplt-project_sacremoses_pr56 +hplt-project_sacremoses_pr59 +hplt-project_sacremoses_pr63 +hplt-project_sacremoses_pr72 +hplt-project_sacremoses_pr9 +huggingface_kernels_pr167 +huggingface_kernels_pr178 +huggingface_setfit_pr1 +huggingface_setfit_pr12 +huggingface_setfit_pr14 +huggingface_setfit_pr17 +huggingface_setfit_pr18 +huggingface_setfit_pr23 +huggingface_setfit_pr25 +hugovk_pypistats_pr12 +hugovk_pypistats_pr13 +hugovk_pypistats_pr14 +hugovk_pypistats_pr15 +hugovk_pypistats_pr16 +hugovk_pypistats_pr18 +hugovk_pypistats_pr19 +hugovk_pypistats_pr2 +hugovk_pypistats_pr22 +hugovk_pypistats_pr23 +hugovk_pypistats_pr26 +hugovk_pypistats_pr27 +hugovk_pypistats_pr30 +hugovk_pypistats_pr38 +hugovk_pypistats_pr39 +hugovk_pypistats_pr41 +hugovk_pypistats_pr42 +hugovk_pypistats_pr46 +hugovk_pypistats_pr47 +hugovk_pypistats_pr5 +hugovk_pypistats_pr73 +hugovk_pypistats_pr79 +hugovk_pypistats_pr81 +hukkin_tomli-w_pr15 +hukkin_tomli-w_pr17 +hukkin_tomli-w_pr26 +hukkin_tomli-w_pr49 +hukkin_tomli-w_pr63 +hukkin_tomli-w_pr66 +hukkin_tomli-w_pr7 +hussein-awala_spark-on-k8s_pr1 +hussein-awala_spark-on-k8s_pr103 +hussein-awala_spark-on-k8s_pr109 +hussein-awala_spark-on-k8s_pr11 +hussein-awala_spark-on-k8s_pr117 +hussein-awala_spark-on-k8s_pr119 +hussein-awala_spark-on-k8s_pr12 +hussein-awala_spark-on-k8s_pr13 +hussein-awala_spark-on-k8s_pr133 +hussein-awala_spark-on-k8s_pr138 +hussein-awala_spark-on-k8s_pr17 +hussein-awala_spark-on-k8s_pr29 +hussein-awala_spark-on-k8s_pr36 +hussein-awala_spark-on-k8s_pr42 +hussein-awala_spark-on-k8s_pr57 +hussein-awala_spark-on-k8s_pr74 +hussein-awala_spark-on-k8s_pr75 +hussein-awala_spark-on-k8s_pr77 +hynek_environ-config_pr100 +hynek_environ-config_pr5 +hynek_environ-config_pr59 +hynek_environ-config_pr7 +hynek_environ-config_pr83 +hynek_pem_pr29 +hynek_pem_pr34 +hynek_pem_pr39 +hynek_pem_pr46 +hynek_pem_pr49 +hynek_pem_pr50 +hynek_prometheus-async_pr85 +hynek_svcs_pr139 +hynek_svcs_pr19 +hynek_svcs_pr4 +hynek_svcs_pr53 +hynek_svcs_pr83 +hynek_svcs_pr92 +i2mint_dol_pr57 +i2mint_i2_pr71 +ialbert_plac_pr51 +iamdual_ua-generator_pr2 +iamdual_ua-generator_pr28 +iamdual_ua-generator_pr29 +iamdual_ua-generator_pr4 +iamdual_ua-generator_pr41 +iamdual_ua-generator_pr5 +iamdual_ua-generator_pr52 +iamdual_ua-generator_pr8 +iamjackg_md2cf_pr42 +ianare_exif-py_pr225 +ianlini_flatten-dict_pr35 +ianlini_flatten-dict_pr44 +ianlini_flatten-dict_pr49 +ianlini_flatten-dict_pr55 +icgood_proxy-protocol_pr53 +ihmwg_python-ihm_pr109 +ihmwg_python-ihm_pr49 +ikalnytskyi_picobox_pr100 +ikalnytskyi_picobox_pr14 +ikalnytskyi_picobox_pr16 +ikalnytskyi_picobox_pr17 +ikalnytskyi_picobox_pr23 +ikalnytskyi_picobox_pr26 +ikalnytskyi_picobox_pr33 +ikalnytskyi_picobox_pr37 +ikalnytskyi_picobox_pr39 +ikalnytskyi_picobox_pr49 +ikalnytskyi_picobox_pr66 +ikalnytskyi_picobox_pr69 +ikalnytskyi_picobox_pr79 +ikalnytskyi_picobox_pr83 +ikalnytskyi_picobox_pr84 +ikalnytskyi_picobox_pr85 +ikalnytskyi_picobox_pr90 +ikalnytskyi_picobox_pr91 +ikalnytskyi_picobox_pr93 +ikalnytskyi_picobox_pr96 +ikalnytskyi_picobox_pr97 +ikalnytskyi_picobox_pr99 +ikegami-yukino_jaconv_pr15 +imageio_imageio_pr141 +imageio_imageio_pr149 +imageio_imageio_pr162 +imageio_imageio_pr45 +influxdb_influxdb-python_pr18 +influxdb_influxdb-python_pr265 +influxdb_influxdb-python_pr266 +influxdb_influxdb-python_pr267 +influxdb_influxdb-python_pr271 +influxdb_influxdb-python_pr276 +influxdb_influxdb-python_pr277 +influxdb_influxdb-python_pr279 +influxdb_influxdb-python_pr281 +influxdb_influxdb-python_pr287 +influxdb_influxdb-python_pr289 +influxdb_influxdb-python_pr294 +influxdb_influxdb-python_pr301 +influxdb_influxdb-python_pr304 +influxdb_influxdb-python_pr306 +influxdb_influxdb-python_pr31 +influxdb_influxdb-python_pr321 +influxdb_influxdb-python_pr33 +influxdb_influxdb-python_pr330 +influxdb_influxdb-python_pr331 +influxdb_influxdb-python_pr36 +influxdb_influxdb-python_pr38 +influxdb_influxdb-python_pr402 +influxdb_influxdb-python_pr409 +influxdb_influxdb-python_pr43 +influxdb_influxdb-python_pr439 +influxdb_influxdb-python_pr465 +influxdb_influxdb-python_pr477 +influxdb_influxdb-python_pr495 +influxdb_influxdb-python_pr503 +influxdb_influxdb-python_pr508 +influxdb_influxdb-python_pr511 +influxdb_influxdb-python_pr518 +influxdb_influxdb-python_pr534 +influxdb_influxdb-python_pr536 +influxdb_influxdb-python_pr537 +influxdb_influxdb-python_pr542 +influxdb_influxdb-python_pr556 +influxdb_influxdb-python_pr557 +influxdb_influxdb-python_pr584 +influxdb_influxdb-python_pr606 +influxdb_influxdb-python_pr617 +influxdb_influxdb-python_pr648 +influxdb_influxdb-python_pr664 +influxdb_influxdb-python_pr678 +influxdb_influxdb-python_pr681 +influxdb_influxdb-python_pr684 +influxdb_influxdb-python_pr69 +influxdb_influxdb-python_pr702 +influxdb_influxdb-python_pr710 +influxdb_influxdb-python_pr716 +influxdb_influxdb-python_pr719 +influxdb_influxdb-python_pr72 +influxdb_influxdb-python_pr723 +influxdb_influxdb-python_pr732 +influxdb_influxdb-python_pr746 +influxdb_influxdb-python_pr753 +influxdb_influxdb-python_pr756 +influxdb_influxdb-python_pr766 +influxdb_influxdb-python_pr772 +influxdb_influxdb-python_pr778 +influxdb_influxdb-python_pr790 +influxdb_influxdb-python_pr806 +influxdb_influxdb-python_pr807 +influxdb_influxdb-python_pr808 +influxdb_influxdb-python_pr810 +influxdb_influxdb-python_pr811 +influxdb_influxdb-python_pr812 +influxdb_influxdb-python_pr813 +influxdb_influxdb-python_pr816 +influxdb_influxdb-python_pr827 +influxdb_influxdb-python_pr84 +influxdb_influxdb-python_pr851 +influxdb_influxdb-python_pr890 +influxdb_influxdb-python_pr926 +infobloxopen_infoblox-client_pr102 +infobloxopen_infoblox-client_pr105 +infobloxopen_infoblox-client_pr12 +infobloxopen_infoblox-client_pr120 +infobloxopen_infoblox-client_pr126 +infobloxopen_infoblox-client_pr128 +infobloxopen_infoblox-client_pr129 +infobloxopen_infoblox-client_pr13 +infobloxopen_infoblox-client_pr131 +infobloxopen_infoblox-client_pr135 +infobloxopen_infoblox-client_pr138 +infobloxopen_infoblox-client_pr14 +infobloxopen_infoblox-client_pr140 +infobloxopen_infoblox-client_pr143 +infobloxopen_infoblox-client_pr148 +infobloxopen_infoblox-client_pr153 +infobloxopen_infoblox-client_pr162 +infobloxopen_infoblox-client_pr165 +infobloxopen_infoblox-client_pr167 +infobloxopen_infoblox-client_pr174 +infobloxopen_infoblox-client_pr19 +infobloxopen_infoblox-client_pr201 +infobloxopen_infoblox-client_pr212 +infobloxopen_infoblox-client_pr213 +infobloxopen_infoblox-client_pr214 +infobloxopen_infoblox-client_pr227 +infobloxopen_infoblox-client_pr232 +infobloxopen_infoblox-client_pr234 +infobloxopen_infoblox-client_pr238 +infobloxopen_infoblox-client_pr258 +infobloxopen_infoblox-client_pr26 +infobloxopen_infoblox-client_pr262 +infobloxopen_infoblox-client_pr27 +infobloxopen_infoblox-client_pr276 +infobloxopen_infoblox-client_pr278 +infobloxopen_infoblox-client_pr28 +infobloxopen_infoblox-client_pr287 +infobloxopen_infoblox-client_pr288 +infobloxopen_infoblox-client_pr289 +infobloxopen_infoblox-client_pr29 +infobloxopen_infoblox-client_pr292 +infobloxopen_infoblox-client_pr295 +infobloxopen_infoblox-client_pr3 +infobloxopen_infoblox-client_pr31 +infobloxopen_infoblox-client_pr318 +infobloxopen_infoblox-client_pr32 +infobloxopen_infoblox-client_pr330 +infobloxopen_infoblox-client_pr331 +infobloxopen_infoblox-client_pr338 +infobloxopen_infoblox-client_pr339 +infobloxopen_infoblox-client_pr34 +infobloxopen_infoblox-client_pr345 +infobloxopen_infoblox-client_pr368 +infobloxopen_infoblox-client_pr384 +infobloxopen_infoblox-client_pr387 +infobloxopen_infoblox-client_pr42 +infobloxopen_infoblox-client_pr51 +infobloxopen_infoblox-client_pr53 +infobloxopen_infoblox-client_pr54 +infobloxopen_infoblox-client_pr59 +infobloxopen_infoblox-client_pr6 +infobloxopen_infoblox-client_pr60 +infobloxopen_infoblox-client_pr61 +infobloxopen_infoblox-client_pr66 +infobloxopen_infoblox-client_pr8 +infobloxopen_infoblox-client_pr81 +infobloxopen_infoblox-client_pr86 +infobloxopen_infoblox-client_pr95 +infobloxopen_infoblox-client_pr97 +infobloxopen_infoblox-client_pr99 +ionelmc_python-manhole_pr3 +ioxiocom_pyjwt-key-fetcher_pr19 +ioxiocom_pyjwt-key-fetcher_pr21 +ipython_ipython_pr13483 +ipython_ipython_pr13501 +ipython_ipython_pr13528 +ipython_ipython_pr13535 +ipython_ipython_pr13559 +ipython_ipython_pr13560 +ipython_ipython_pr13566 +ipython_ipython_pr13588 +ipython_ipython_pr13600 +ipython_ipython_pr13603 +ipython_ipython_pr13625 +ipython_ipython_pr13671 +ipython_ipython_pr13675 +ipython_ipython_pr13680 +ipython_ipython_pr13701 +ipython_ipython_pr13706 +ipython_ipython_pr13708 +ipython_ipython_pr13713 +ipython_ipython_pr13719 +ipython_ipython_pr13743 +ipython_ipython_pr13745 +ipython_ipython_pr13768 +ipython_ipython_pr13773 +ipython_ipython_pr13788 +ipython_ipython_pr13817 +ipython_ipython_pr13825 +ipython_ipython_pr13852 +ipython_ipython_pr13861 +ipython_ipython_pr13863 +ipython_ipython_pr13888 +ipython_ipython_pr13889 +ipython_ipython_pr13903 +ipython_ipython_pr13914 +ipython_ipython_pr13925 +ipython_ipython_pr13932 +ipython_ipython_pr13940 +ipython_ipython_pr13957 +ipython_ipython_pr13962 +ipython_ipython_pr13964 +ipython_ipython_pr13968 +ipython_ipython_pr13975 +ipython_ipython_pr13990 +ipython_ipython_pr13991 +ipython_ipython_pr14026 +ipython_ipython_pr14029 +ipython_ipython_pr14033 +ipython_ipython_pr14039 +ipython_ipython_pr14052 +ipython_ipython_pr14056 +ipython_ipython_pr14076 +ipython_ipython_pr14080 +ipython_ipython_pr14100 +ipython_ipython_pr14108 +ipython_ipython_pr14119 +ipython_ipython_pr14133 +ipython_ipython_pr14139 +ipython_ipython_pr14146 +ipython_ipython_pr14153 +ipython_ipython_pr14185 +ipython_ipython_pr14189 +ipython_ipython_pr14198 +ipython_ipython_pr14219 +ipython_ipython_pr14223 +ipython_ipython_pr14228 +ipython_ipython_pr14231 +ipython_ipython_pr14241 +ipython_ipython_pr14254 +ipython_ipython_pr14256 +ipython_ipython_pr14274 +ipython_ipython_pr14284 +ipython_ipython_pr14287 +ipython_ipython_pr14291 +ipython_ipython_pr14305 +ipython_ipython_pr14312 +ipython_ipython_pr14324 +ipython_ipython_pr14342 +ipython_ipython_pr14356 +ipython_traitlets_pr10 +ipython_traitlets_pr100 +ipython_traitlets_pr107 +ipython_traitlets_pr109 +ipython_traitlets_pr114 +ipython_traitlets_pr119 +ipython_traitlets_pr121 +ipython_traitlets_pr125 +ipython_traitlets_pr127 +ipython_traitlets_pr129 +ipython_traitlets_pr137 +ipython_traitlets_pr14 +ipython_traitlets_pr140 +ipython_traitlets_pr149 +ipython_traitlets_pr152 +ipython_traitlets_pr155 +ipython_traitlets_pr156 +ipython_traitlets_pr168 +ipython_traitlets_pr175 +ipython_traitlets_pr177 +ipython_traitlets_pr185 +ipython_traitlets_pr186 +ipython_traitlets_pr21 +ipython_traitlets_pr22 +ipython_traitlets_pr250 +ipython_traitlets_pr262 +ipython_traitlets_pr264 +ipython_traitlets_pr269 +ipython_traitlets_pr27 +ipython_traitlets_pr274 +ipython_traitlets_pr282 +ipython_traitlets_pr289 +ipython_traitlets_pr293 +ipython_traitlets_pr306 +ipython_traitlets_pr31 +ipython_traitlets_pr322 +ipython_traitlets_pr33 +ipython_traitlets_pr332 +ipython_traitlets_pr333 +ipython_traitlets_pr339 +ipython_traitlets_pr34 +ipython_traitlets_pr340 +ipython_traitlets_pr341 +ipython_traitlets_pr35 +ipython_traitlets_pr353 +ipython_traitlets_pr355 +ipython_traitlets_pr360 +ipython_traitlets_pr362 +ipython_traitlets_pr365 +ipython_traitlets_pr376 +ipython_traitlets_pr377 +ipython_traitlets_pr38 +ipython_traitlets_pr380 +ipython_traitlets_pr384 +ipython_traitlets_pr385 +ipython_traitlets_pr39 +ipython_traitlets_pr393 +ipython_traitlets_pr394 +ipython_traitlets_pr40 +ipython_traitlets_pr402 +ipython_traitlets_pr404 +ipython_traitlets_pr407 +ipython_traitlets_pr413 +ipython_traitlets_pr415 +ipython_traitlets_pr416 +ipython_traitlets_pr42 +ipython_traitlets_pr426 +ipython_traitlets_pr43 +ipython_traitlets_pr430 +ipython_traitlets_pr436 +ipython_traitlets_pr437 +ipython_traitlets_pr438 +ipython_traitlets_pr44 +ipython_traitlets_pr45 +ipython_traitlets_pr458 +ipython_traitlets_pr482 +ipython_traitlets_pr501 +ipython_traitlets_pr509 +ipython_traitlets_pr51 +ipython_traitlets_pr515 +ipython_traitlets_pr517 +ipython_traitlets_pr522 +ipython_traitlets_pr525 +ipython_traitlets_pr53 +ipython_traitlets_pr535 +ipython_traitlets_pr558 +ipython_traitlets_pr56 +ipython_traitlets_pr574 +ipython_traitlets_pr582 +ipython_traitlets_pr600 +ipython_traitlets_pr611 +ipython_traitlets_pr613 +ipython_traitlets_pr615 +ipython_traitlets_pr616 +ipython_traitlets_pr619 +ipython_traitlets_pr629 +ipython_traitlets_pr630 +ipython_traitlets_pr632 +ipython_traitlets_pr67 +ipython_traitlets_pr670 +ipython_traitlets_pr673 +ipython_traitlets_pr68 +ipython_traitlets_pr698 +ipython_traitlets_pr72 +ipython_traitlets_pr73 +ipython_traitlets_pr77 +ipython_traitlets_pr79 +ipython_traitlets_pr88 +ipython_traitlets_pr91 +itamarst_crochet_pr114 +itamarst_crochet_pr116 +itamarst_crochet_pr30 +itamarst_crochet_pr54 +itamarst_crochet_pr83 +itamarst_eliot_pr118 +itamarst_eliot_pr127 +itamarst_eliot_pr139 +itamarst_eliot_pr145 +itamarst_eliot_pr148 +itamarst_eliot_pr154 +itamarst_eliot_pr156 +itamarst_eliot_pr174 +itamarst_eliot_pr175 +itamarst_eliot_pr182 +itamarst_eliot_pr189 +itamarst_eliot_pr195 +itamarst_eliot_pr198 +itamarst_eliot_pr200 +itamarst_eliot_pr323 +itamarst_eliot_pr348 +itamarst_eliot_pr352 +itamarst_eliot_pr356 +itamarst_eliot_pr36 +itamarst_eliot_pr360 +itamarst_eliot_pr37 +itamarst_eliot_pr379 +itamarst_eliot_pr380 +itamarst_eliot_pr381 +itamarst_eliot_pr390 +itamarst_eliot_pr397 +itamarst_eliot_pr40 +itamarst_eliot_pr414 +itamarst_eliot_pr421 +itamarst_eliot_pr43 +itamarst_eliot_pr430 +itamarst_eliot_pr431 +itamarst_eliot_pr46 +itamarst_eliot_pr473 +itamarst_eliot_pr513 +itamarst_eliot_pr70 +iterative_dvc-data_pr103 +iterative_dvc-data_pr104 +iterative_dvc-data_pr105 +iterative_dvc-data_pr115 +iterative_dvc-data_pr118 +iterative_dvc-data_pr120 +iterative_dvc-data_pr142 +iterative_dvc-data_pr164 +iterative_dvc-data_pr196 +iterative_dvc-data_pr206 +iterative_dvc-data_pr211 +iterative_dvc-data_pr214 +iterative_dvc-data_pr79 +iterative_dvc-data_pr80 +iterative_dvc-data_pr82 +iterative_dvc-data_pr95 +iterative_dvc-data_pr96 +iterative_dvc-objects_pr147 +iterative_dvc-objects_pr149 +iterative_dvc-objects_pr160 +iterative_dvc-objects_pr161 +iterative_dvc-objects_pr169 +iterative_dvc-objects_pr218 +iterative_dvc-objects_pr221 +iterative_dvc-objects_pr229 +iterative_dvc-objects_pr237 +iterative_dvc-objects_pr245 +iterative_dvc-objects_pr262 +iterative_dvc-objects_pr265 +iterative_dvc-objects_pr30 +iterative_dvc-render_pr107 +iterative_dvc-render_pr111 +iterative_dvc-render_pr113 +iterative_dvc-render_pr124 +iterative_dvc-render_pr125 +iterative_dvc-render_pr127 +iterative_dvc-render_pr129 +iterative_dvc-render_pr130 +iterative_dvc-render_pr131 +iterative_dvc-render_pr133 +iterative_dvc-render_pr134 +iterative_dvc-render_pr142 +iterative_dvc-render_pr145 +iterative_dvc-render_pr146 +iterative_dvc-render_pr150 +iterative_dvc-render_pr151 +iterative_dvc-render_pr24 +iterative_dvc-render_pr39 +iterative_dvc-render_pr40 +iterative_dvc-render_pr45 +iterative_dvc-render_pr69 +iterative_dvc-render_pr73 +iterative_dvc-render_pr81 +iterative_dvc-render_pr96 +iterative_dvc-render_pr99 +iterative_gto_pr101 +iterative_gto_pr106 +iterative_gto_pr109 +iterative_gto_pr110 +iterative_gto_pr117 +iterative_gto_pr118 +iterative_gto_pr120 +iterative_gto_pr128 +iterative_gto_pr148 +iterative_gto_pr153 +iterative_gto_pr160 +iterative_gto_pr161 +iterative_gto_pr162 +iterative_gto_pr163 +iterative_gto_pr165 +iterative_gto_pr166 +iterative_gto_pr168 +iterative_gto_pr174 +iterative_gto_pr183 +iterative_gto_pr187 +iterative_gto_pr201 +iterative_gto_pr205 +iterative_gto_pr213 +iterative_gto_pr219 +iterative_gto_pr221 +iterative_gto_pr238 +iterative_gto_pr244 +iterative_gto_pr249 +iterative_gto_pr257 +iterative_gto_pr269 +iterative_gto_pr276 +iterative_gto_pr281 +iterative_gto_pr292 +iterative_gto_pr295 +iterative_gto_pr299 +iterative_gto_pr309 +iterative_gto_pr310 +iterative_gto_pr315 +iterative_gto_pr316 +iterative_gto_pr319 +iterative_gto_pr324 +iterative_gto_pr346 +iterative_gto_pr352 +iterative_gto_pr353 +iterative_gto_pr356 +iterative_gto_pr372 +iterative_gto_pr382 +iterative_gto_pr413 +iterative_gto_pr417 +iterative_gto_pr420 +iterative_gto_pr425 +iterative_gto_pr94 +iterative_gto_pr96 +iterative_gto_pr99 +iterative_morefs_pr14 +iterative_scmrepo_pr10 +iterative_scmrepo_pr101 +iterative_scmrepo_pr138 +iterative_scmrepo_pr145 +iterative_scmrepo_pr149 +iterative_scmrepo_pr150 +iterative_scmrepo_pr155 +iterative_scmrepo_pr159 +iterative_scmrepo_pr169 +iterative_scmrepo_pr188 +iterative_scmrepo_pr191 +iterative_scmrepo_pr2 +iterative_scmrepo_pr209 +iterative_scmrepo_pr213 +iterative_scmrepo_pr214 +iterative_scmrepo_pr216 +iterative_scmrepo_pr219 +iterative_scmrepo_pr220 +iterative_scmrepo_pr222 +iterative_scmrepo_pr224 +iterative_scmrepo_pr226 +iterative_scmrepo_pr229 +iterative_scmrepo_pr231 +iterative_scmrepo_pr235 +iterative_scmrepo_pr24 +iterative_scmrepo_pr244 +iterative_scmrepo_pr246 +iterative_scmrepo_pr25 +iterative_scmrepo_pr255 +iterative_scmrepo_pr261 +iterative_scmrepo_pr268 +iterative_scmrepo_pr269 +iterative_scmrepo_pr279 +iterative_scmrepo_pr281 +iterative_scmrepo_pr282 +iterative_scmrepo_pr32 +iterative_scmrepo_pr39 +iterative_scmrepo_pr46 +iterative_scmrepo_pr51 +iterative_scmrepo_pr53 +iterative_scmrepo_pr55 +iterative_scmrepo_pr59 +iterative_scmrepo_pr62 +iterative_scmrepo_pr67 +iterative_scmrepo_pr69 +iterative_scmrepo_pr75 +iterative_scmrepo_pr84 +ivankorobkov_python-inject_pr20 +ivankorobkov_python-inject_pr22 +ivankorobkov_python-inject_pr24 +ivankorobkov_python-inject_pr26 +ivankorobkov_python-inject_pr37 +ivankorobkov_python-inject_pr43 +ivankorobkov_python-inject_pr54 +ivankorobkov_python-inject_pr6 +ivankorobkov_python-inject_pr60 +ivankorobkov_python-inject_pr71 +ivankorobkov_python-inject_pr8 +izimobil_django-rest-framework-datatables_pr112 +izimobil_django-rest-framework-datatables_pr149 +izimobil_django-rest-framework-datatables_pr91 +izimobil_django-rest-framework-datatables_pr94 +jacebrowning_yorm_pr41 +jackdewinter_pymarkdown_pr1020 +jackdewinter_pymarkdown_pr1025 +jackdewinter_pymarkdown_pr1040 +jackdewinter_pymarkdown_pr1042 +jackdewinter_pymarkdown_pr1050 +jackdewinter_pymarkdown_pr1094 +jackdewinter_pymarkdown_pr1100 +jackdewinter_pymarkdown_pr1104 +jackdewinter_pymarkdown_pr1105 +jackdewinter_pymarkdown_pr1128 +jackdewinter_pymarkdown_pr1129 +jackdewinter_pymarkdown_pr116 +jackdewinter_pymarkdown_pr1195 +jackdewinter_pymarkdown_pr1211 +jackdewinter_pymarkdown_pr1216 +jackdewinter_pymarkdown_pr1246 +jackdewinter_pymarkdown_pr1248 +jackdewinter_pymarkdown_pr1251 +jackdewinter_pymarkdown_pr1253 +jackdewinter_pymarkdown_pr1271 +jackdewinter_pymarkdown_pr1279 +jackdewinter_pymarkdown_pr1315 +jackdewinter_pymarkdown_pr1335 +jackdewinter_pymarkdown_pr1353 +jackdewinter_pymarkdown_pr1365 +jackdewinter_pymarkdown_pr1367 +jackdewinter_pymarkdown_pr139 +jackdewinter_pymarkdown_pr1412 +jackdewinter_pymarkdown_pr1413 +jackdewinter_pymarkdown_pr1414 +jackdewinter_pymarkdown_pr1434 +jackdewinter_pymarkdown_pr1440 +jackdewinter_pymarkdown_pr1456 +jackdewinter_pymarkdown_pr1457 +jackdewinter_pymarkdown_pr1465 +jackdewinter_pymarkdown_pr183 +jackdewinter_pymarkdown_pr279 +jackdewinter_pymarkdown_pr280 +jackdewinter_pymarkdown_pr281 +jackdewinter_pymarkdown_pr291 +jackdewinter_pymarkdown_pr384 +jackdewinter_pymarkdown_pr390 +jackdewinter_pymarkdown_pr391 +jackdewinter_pymarkdown_pr425 +jackdewinter_pymarkdown_pr426 +jackdewinter_pymarkdown_pr428 +jackdewinter_pymarkdown_pr433 +jackdewinter_pymarkdown_pr451 +jackdewinter_pymarkdown_pr455 +jackdewinter_pymarkdown_pr466 +jackdewinter_pymarkdown_pr477 +jackdewinter_pymarkdown_pr481 +jackdewinter_pymarkdown_pr487 +jackdewinter_pymarkdown_pr497 +jackdewinter_pymarkdown_pr511 +jackdewinter_pymarkdown_pr515 +jackdewinter_pymarkdown_pr518 +jackdewinter_pymarkdown_pr533 +jackdewinter_pymarkdown_pr559 +jackdewinter_pymarkdown_pr575 +jackdewinter_pymarkdown_pr595 +jackdewinter_pymarkdown_pr597 +jackdewinter_pymarkdown_pr636 +jackdewinter_pymarkdown_pr638 +jackdewinter_pymarkdown_pr645 +jackdewinter_pymarkdown_pr674 +jackdewinter_pymarkdown_pr75 +jackdewinter_pymarkdown_pr792 +jackdewinter_pymarkdown_pr794 +jackdewinter_pymarkdown_pr795 +jackdewinter_pymarkdown_pr80 +jackdewinter_pymarkdown_pr81 +jackdewinter_pymarkdown_pr844 +jackdewinter_pymarkdown_pr853 +jackdewinter_pymarkdown_pr862 +jackdewinter_pymarkdown_pr863 +jackdewinter_pymarkdown_pr864 +jackdewinter_pymarkdown_pr866 +jackdewinter_pymarkdown_pr868 +jackdewinter_pymarkdown_pr869 +jackdewinter_pymarkdown_pr872 +jackdewinter_pymarkdown_pr881 +jackdewinter_pymarkdown_pr884 +jackdewinter_pymarkdown_pr886 +jackdewinter_pymarkdown_pr890 +jackdewinter_pymarkdown_pr893 +jackdewinter_pymarkdown_pr900 +jackdewinter_pymarkdown_pr903 +jackdewinter_pymarkdown_pr915 +jackdewinter_pymarkdown_pr916 +jackdewinter_pymarkdown_pr917 +jackdewinter_pymarkdown_pr918 +jackdewinter_pymarkdown_pr919 +jackdewinter_pymarkdown_pr920 +jackdewinter_pymarkdown_pr921 +jackdewinter_pymarkdown_pr922 +jackdewinter_pymarkdown_pr923 +jackdewinter_pymarkdown_pr927 +jackdewinter_pymarkdown_pr932 +jackdewinter_pymarkdown_pr942 +jackdewinter_pymarkdown_pr967 +jackdewinter_pymarkdown_pr987 +jackdewinter_pymarkdown_pr996 +jacksmith15_json-ref-dict_pr1 +jacksmith15_json-ref-dict_pr13 +jacksmith15_json-ref-dict_pr16 +jacksmith15_json-ref-dict_pr18 +jacksmith15_json-ref-dict_pr2 +jacksmith15_json-ref-dict_pr4 +jacksmith15_json-ref-dict_pr6 +jacksmith15_json-ref-dict_pr9 +jackz314_eeglabio_pr11 +jacobschaer_python-doipclient_pr30 +jacobschaer_python-doipclient_pr7 +jacobschaer_python-doipclient_pr9 +jadchaar_sec-edgar-downloader_pr123 +jawah_h2_pr4 +jawah_urllib3.future_pr20 +jawah_urllib3.future_pr22 +jawah_urllib3.future_pr23 +jawah_urllib3.future_pr35 +jawah_urllib3.future_pr40 +jawah_urllib3.future_pr42 +jawah_urllib3.future_pr44 +jawah_urllib3.future_pr45 +jawah_urllib3.future_pr47 +jawah_urllib3.future_pr7 +jazzband_dj-database-url_pr100 +jazzband_dj-database-url_pr116 +jazzband_dj-database-url_pr145 +jazzband_dj-database-url_pr150 +jazzband_dj-database-url_pr181 +jazzband_dj-database-url_pr183 +jazzband_dj-database-url_pr185 +jazzband_dj-database-url_pr196 +jazzband_dj-database-url_pr199 +jazzband_dj-database-url_pr21 +jazzband_dj-database-url_pr215 +jazzband_dj-database-url_pr225 +jazzband_dj-database-url_pr231 +jazzband_dj-database-url_pr235 +jazzband_dj-database-url_pr243 +jazzband_dj-database-url_pr257 +jazzband_dj-database-url_pr29 +jazzband_dj-database-url_pr51 +jazzband_dj-database-url_pr59 +jazzband_dj-database-url_pr64 +jazzband_dj-database-url_pr69 +jazzband_dj-database-url_pr76 +jazzband_dj-database-url_pr78 +jazzband_dj-database-url_pr80 +jazzband_dj-database-url_pr86 +jazzband_django-analytical_pr126 +jazzband_django-analytical_pr130 +jazzband_django-analytical_pr164 +jazzband_django-axes_pr1033 +jazzband_django-axes_pr1069 +jazzband_django-axes_pr1138 +jazzband_django-axes_pr1198 +jazzband_django-axes_pr1305 +jazzband_django-axes_pr1306 +jazzband_django-axes_pr1330 +jazzband_django-axes_pr652 +jazzband_django-axes_pr670 +jazzband_django-axes_pr716 +jazzband_django-axes_pr738 +jazzband_django-axes_pr747 +jazzband_django-axes_pr765 +jazzband_django-axes_pr783 +jazzband_django-axes_pr785 +jazzband_django-axes_pr789 +jazzband_django-axes_pr862 +jazzband_django-axes_pr865 +jazzband_django-axes_pr870 +jazzband_django-axes_pr871 +jazzband_django-axes_pr922 +jazzband_django-fsm-log_pr143 +jazzband_django-fsm-log_pr169 +jazzband_django-fsm-log_pr212 +jazzband_django-fsm-log_pr58 +jazzband_django-redshift-backend_pr105 +jazzband_django-redshift-backend_pr155 +jazzband_django-redshift-backend_pr162 +jazzband_django-redshift-backend_pr163 +jazzband_django-redshift-backend_pr90 +jazzband_django-redshift-backend_pr93 +jazzband_django-smart-selects_pr273 +jazzband_django-smart-selects_pr291 +jazzband_django-smart-selects_pr297 +jazzband_docopt-ng_pr28 +jazzband_geojson_pr131 +jazzband_geojson_pr177 +jazzband_geojson_pr215 +jazzband_icalevents_pr133 +jazzband_icalevents_pr138 +jazzband_icalevents_pr139 +jazzband_icalevents_pr14 +jazzband_icalevents_pr140 +jazzband_icalevents_pr23 +jazzband_icalevents_pr27 +jazzband_icalevents_pr29 +jazzband_icalevents_pr30 +jazzband_icalevents_pr34 +jazzband_icalevents_pr49 +jazzband_icalevents_pr52 +jazzband_icalevents_pr57 +jazzband_icalevents_pr66 +jazzband_icalevents_pr75 +jazzband_icalevents_pr79 +jazzband_icalevents_pr80 +jazzband_icalevents_pr88 +jazzband_icalevents_pr91 +jazzband_icalevents_pr92 +jazzband_icalevents_pr95 +jazzband_icalevents_pr97 +jazzband_tablib_pr259 +jazzband_tablib_pr272 +jazzband_tablib_pr307 +jazzband_tablib_pr332 +jazzband_tablib_pr333 +jazzband_tablib_pr336 +jazzband_tablib_pr337 +jazzband_tablib_pr348 +jazzband_tablib_pr374 +jazzband_tablib_pr384 +jazzband_tablib_pr385 +jazzband_tablib_pr386 +jazzband_tablib_pr392 +jazzband_tablib_pr393 +jazzband_tablib_pr433 +jazzband_tablib_pr437 +jazzband_tablib_pr441 +jazzband_tablib_pr449 +jazzband_tablib_pr454 +jazzband_tablib_pr456 +jazzband_tablib_pr466 +jazzband_tablib_pr470 +jazzband_tablib_pr483 +jazzband_tablib_pr484 +jazzband_tablib_pr490 +jazzband_tablib_pr494 +jazzband_tablib_pr497 +jazzband_tablib_pr510 +jazzband_tablib_pr516 +jazzband_tablib_pr518 +jazzband_tablib_pr528 +jazzband_tablib_pr534 +jazzband_tablib_pr535 +jazzband_tablib_pr539 +jazzband_tablib_pr540 +jazzband_tablib_pr541 +jazzband_tablib_pr542 +jazzband_tablib_pr547 +jazzband_tablib_pr550 +jazzband_tablib_pr555 +jazzband_tablib_pr557 +jazzband_tablib_pr563 +jazzband_tablib_pr566 +jazzband_tablib_pr568 +jazzband_tablib_pr573 +jazzband_tablib_pr579 +jazzband_tablib_pr584 +jazzband_tablib_pr594 +jazzband_tablib_pr595 +jazzband_tablib_pr596 +jazzband_tablib_pr613 +jazzband_tablib_pr614 +jazzband_tablib_pr619 +jazzband_tablib_pr620 +jazzband_tablib_pr624 +jazzband_tablib_pr627 +jbkahn_flake8-debugger_pr13 +jbkahn_flake8-debugger_pr23 +jborean93_pypsexec_pr22 +jborean93_pypsrp_pr124 +jborean93_pypsrp_pr135 +jborean93_pypsrp_pr136 +jborean93_requests-credssp_pr24 +jborean93_smbprotocol_pr102 +jborean93_smbprotocol_pr125 +jborean93_smbprotocol_pr13 +jborean93_smbprotocol_pr138 +jborean93_smbprotocol_pr147 +jborean93_smbprotocol_pr149 +jborean93_smbprotocol_pr15 +jborean93_smbprotocol_pr151 +jborean93_smbprotocol_pr153 +jborean93_smbprotocol_pr184 +jborean93_smbprotocol_pr190 +jborean93_smbprotocol_pr2 +jborean93_smbprotocol_pr22 +jborean93_smbprotocol_pr224 +jborean93_smbprotocol_pr226 +jborean93_smbprotocol_pr227 +jborean93_smbprotocol_pr234 +jborean93_smbprotocol_pr245 +jborean93_smbprotocol_pr252 +jborean93_smbprotocol_pr264 +jborean93_smbprotocol_pr293 +jborean93_smbprotocol_pr317 +jborean93_smbprotocol_pr327 +jborean93_smbprotocol_pr39 +jborean93_smbprotocol_pr46 +jborean93_smbprotocol_pr49 +jborean93_smbprotocol_pr69 +jborean93_smbprotocol_pr76 +jborean93_smbprotocol_pr9 +jborean93_smbprotocol_pr93 +jborean93_smbprotocol_pr99 +jcmgray_autoray_pr15 +jerry-git_pytest-split_pr18 +jerry-git_pytest-split_pr29 +jerry-git_pytest-split_pr42 +jfhbrook_pyee_pr107 +jfhbrook_pyee_pr122 +jfhbrook_pyee_pr123 +jfhbrook_pyee_pr135 +jfhbrook_pyee_pr138 +jfhbrook_pyee_pr38 +jfhbrook_pyee_pr40 +jfhbrook_pyee_pr74 +jfhbrook_pyee_pr75 +jfhbrook_pyee_pr77 +jfhbrook_pyee_pr99 +jg-rp_liquid_pr109 +jg-rp_liquid_pr115 +jg-rp_liquid_pr121 +jg-rp_liquid_pr143 +jg-rp_liquid_pr149 +jg-rp_liquid_pr163 +jg-rp_liquid_pr165 +jg-rp_liquid_pr166 +jg-rp_liquid_pr167 +jg-rp_liquid_pr65 +jg-rp_liquid_pr75 +jg-rp_liquid_pr80 +jg-rp_liquid_pr88 +jg-rp_liquid_pr91 +jg-rp_liquid_pr99 +jg-rp_python-jsonpath_pr10 +jg-rp_python-jsonpath_pr13 +jg-rp_python-jsonpath_pr14 +jg-rp_python-jsonpath_pr15 +jg-rp_python-jsonpath_pr22 +jg-rp_python-jsonpath_pr28 +jg-rp_python-jsonpath_pr6 +jkimbo_graphql-sync-dataloaders_pr2 +jmccrohan_pysolarmanv5_pr38 +jmccrohan_pysolarmanv5_pr61 +jmccrohan_pysolarmanv5_pr65 +jmccrohan_pysolarmanv5_pr82 +jmccrohan_pysolarmanv5_pr84 +jmccrohan_pysolarmanv5_pr94 +joblib_joblib-spark_pr35 +joblib_joblib-spark_pr36 +joblib_joblib-spark_pr37 +joblib_joblib-spark_pr38 +joblib_joblib_pr1149 +joblib_joblib_pr1393 +joblib_joblib_pr444 +joblib_joblib_pr449 +joblib_joblib_pr541 +joblib_threadpoolctl_pr101 +joblib_threadpoolctl_pr102 +joblib_threadpoolctl_pr112 +joblib_threadpoolctl_pr114 +joblib_threadpoolctl_pr138 +joblib_threadpoolctl_pr160 +joblib_threadpoolctl_pr163 +joblib_threadpoolctl_pr169 +joblib_threadpoolctl_pr175 +joblib_threadpoolctl_pr185 +joblib_threadpoolctl_pr2 +joblib_threadpoolctl_pr29 +joblib_threadpoolctl_pr30 +joblib_threadpoolctl_pr32 +joblib_threadpoolctl_pr34 +joblib_threadpoolctl_pr42 +joblib_threadpoolctl_pr5 +joblib_threadpoolctl_pr52 +joblib_threadpoolctl_pr82 +jodal_biip_pr102 +jodal_biip_pr11 +jodal_biip_pr118 +jodal_biip_pr126 +jodal_biip_pr127 +jodal_biip_pr129 +jodal_biip_pr13 +jodal_biip_pr130 +jodal_biip_pr132 +jodal_biip_pr143 +jodal_biip_pr149 +jodal_biip_pr156 +jodal_biip_pr16 +jodal_biip_pr165 +jodal_biip_pr169 +jodal_biip_pr173 +jodal_biip_pr174 +jodal_biip_pr184 +jodal_biip_pr186 +jodal_biip_pr19 +jodal_biip_pr21 +jodal_biip_pr23 +jodal_biip_pr26 +jodal_biip_pr28 +jodal_biip_pr292 +jodal_biip_pr30 +jodal_biip_pr300 +jodal_biip_pr301 +jodal_biip_pr304 +jodal_biip_pr31 +jodal_biip_pr327 +jodal_biip_pr372 +jodal_biip_pr6 +jodal_biip_pr7 +jodal_biip_pr95 +jodal_biip_pr96 +jodal_biip_pr97 +jodal_biip_pr99 +jodal_pykka_pr193 +jodal_pykka_pr226 +jodal_pykka_pr229 +jodal_pykka_pr233 +joerick_pyinstrument_pr45 +joerick_pyinstrument_pr46 +joerick_pyinstrument_pr49 +johnnoone_json-spec_pr2 +johnnoone_json-spec_pr8 +joke2k_faker_pr1011 +joke2k_faker_pr1019 +joke2k_faker_pr1022 +joke2k_faker_pr1029 +joke2k_faker_pr1033 +joke2k_faker_pr1034 +joke2k_faker_pr1037 +joke2k_faker_pr1043 +joke2k_faker_pr1045 +joke2k_faker_pr1046 +joke2k_faker_pr1049 +joke2k_faker_pr1052 +joke2k_faker_pr1054 +joke2k_faker_pr1062 +joke2k_faker_pr1069 +joke2k_faker_pr1072 +joke2k_faker_pr1073 +joke2k_faker_pr1075 +joke2k_faker_pr1102 +joke2k_faker_pr1103 +joke2k_faker_pr1104 +joke2k_faker_pr1110 +joke2k_faker_pr1116 +joke2k_faker_pr1117 +joke2k_faker_pr1119 +joke2k_faker_pr1122 +joke2k_faker_pr1136 +joke2k_faker_pr1140 +joke2k_faker_pr1143 +joke2k_faker_pr1144 +joke2k_faker_pr1145 +joke2k_faker_pr1146 +joke2k_faker_pr1150 +joke2k_faker_pr1164 +joke2k_faker_pr1166 +joke2k_faker_pr1170 +joke2k_faker_pr589 +joke2k_faker_pr596 +joke2k_faker_pr600 +joke2k_faker_pr614 +joke2k_faker_pr615 +joke2k_faker_pr620 +joke2k_faker_pr962 +joke2k_faker_pr964 +joke2k_faker_pr965 +joke2k_faker_pr983 +joke2k_faker_pr985 +joke2k_faker_pr995 +jonathf_chaospy_pr173 +jonathf_chaospy_pr177 +jonathf_chaospy_pr186 +jonathf_chaospy_pr199 +jonathf_chaospy_pr201 +jonathf_chaospy_pr220 +jonathf_chaospy_pr221 +jonathf_chaospy_pr249 +jonathf_chaospy_pr259 +jonathf_chaospy_pr264 +jonathf_chaospy_pr271 +jonathf_chaospy_pr272 +jonathf_chaospy_pr273 +jonathf_chaospy_pr274 +jonathf_chaospy_pr275 +jonathf_chaospy_pr276 +jonathf_chaospy_pr283 +jonathf_chaospy_pr286 +jonathf_chaospy_pr288 +jonathf_chaospy_pr305 +jonathf_chaospy_pr310 +jonathf_chaospy_pr315 +jonathf_chaospy_pr322 +jonathf_chaospy_pr325 +jonathf_chaospy_pr330 +jonathf_chaospy_pr344 +jonathf_chaospy_pr351 +jonathf_chaospy_pr359 +jonathf_numpoly_pr15 +jonathf_numpoly_pr17 +jonathf_numpoly_pr19 +jonathf_numpoly_pr20 +jonathf_numpoly_pr21 +jonathf_numpoly_pr22 +jonathf_numpoly_pr23 +jonathf_numpoly_pr27 +jonathf_numpoly_pr29 +jonathf_numpoly_pr33 +jonathf_numpoly_pr34 +jonathf_numpoly_pr36 +jonathf_numpoly_pr37 +jonathf_numpoly_pr38 +jonathf_numpoly_pr42 +jonathf_numpoly_pr43 +jonathf_numpoly_pr44 +jonathf_numpoly_pr51 +jonathf_numpoly_pr52 +jonathf_numpoly_pr57 +jonathf_numpoly_pr63 +jonathf_numpoly_pr65 +jonathf_numpoly_pr66 +jonathf_numpoly_pr67 +jonathf_numpoly_pr7 +jonathf_numpoly_pr71 +jonathf_numpoly_pr72 +jonathf_numpoly_pr78 +jonathf_numpoly_pr79 +jonathf_numpoly_pr8 +jonathf_numpoly_pr9 +jonghwanhyeon_python-ffmpeg_pr25 +jonghwanhyeon_python-ffmpeg_pr44 +jongracecox_anybadge_pr19 +jongracecox_anybadge_pr26 +jongracecox_anybadge_pr37 +jongracecox_anybadge_pr38 +jongracecox_anybadge_pr39 +jongracecox_anybadge_pr40 +jongracecox_anybadge_pr50 +jongracecox_anybadge_pr59 +joseph-roitman_pytest-snapshot_pr10 +joseph-roitman_pytest-snapshot_pr13 +joseph-roitman_pytest-snapshot_pr30 +joseph-roitman_pytest-snapshot_pr32 +joseph-roitman_pytest-snapshot_pr34 +joseph-roitman_pytest-snapshot_pr36 +joseph-roitman_pytest-snapshot_pr55 +joseph-roitman_pytest-snapshot_pr56 +josheppinette_python-logfmter_pr55 +joshtemple_lkml_pr10 +joshtemple_lkml_pr68 +joshtemple_lkml_pr85 +joshtemple_lkml_pr97 +jpadilla_pyjwt_pr1001 +jpadilla_pyjwt_pr1005 +jpadilla_pyjwt_pr1041 +jpadilla_pyjwt_pr1045 +jpadilla_pyjwt_pr280 +jpadilla_pyjwt_pr454 +jpadilla_pyjwt_pr455 +jpadilla_pyjwt_pr457 +jpadilla_pyjwt_pr498 +jpadilla_pyjwt_pr513 +jpadilla_pyjwt_pr552 +jpadilla_pyjwt_pr557 +jpadilla_pyjwt_pr559 +jpadilla_pyjwt_pr563 +jpadilla_pyjwt_pr564 +jpadilla_pyjwt_pr578 +jpadilla_pyjwt_pr598 +jpadilla_pyjwt_pr608 +jpadilla_pyjwt_pr611 +jpadilla_pyjwt_pr623 +jpadilla_pyjwt_pr624 +jpadilla_pyjwt_pr629 +jpadilla_pyjwt_pr657 +jpadilla_pyjwt_pr668 +jpadilla_pyjwt_pr670 +jpadilla_pyjwt_pr673 +jpadilla_pyjwt_pr690 +jpadilla_pyjwt_pr694 +jpadilla_pyjwt_pr701 +jpadilla_pyjwt_pr702 +jpadilla_pyjwt_pr723 +jpadilla_pyjwt_pr725 +jpadilla_pyjwt_pr742 +jpadilla_pyjwt_pr747 +jpadilla_pyjwt_pr753 +jpadilla_pyjwt_pr762 +jpadilla_pyjwt_pr773 +jpadilla_pyjwt_pr775 +jpadilla_pyjwt_pr781 +jpadilla_pyjwt_pr782 +jpadilla_pyjwt_pr786 +jpadilla_pyjwt_pr794 +jpadilla_pyjwt_pr829 +jpadilla_pyjwt_pr830 +jpadilla_pyjwt_pr832 +jpadilla_pyjwt_pr843 +jpadilla_pyjwt_pr845 +jpadilla_pyjwt_pr846 +jpadilla_pyjwt_pr847 +jpadilla_pyjwt_pr875 +jpadilla_pyjwt_pr876 +jpadilla_pyjwt_pr881 +jpadilla_pyjwt_pr886 +jpadilla_pyjwt_pr891 +jpadilla_pyjwt_pr902 +jpadilla_pyjwt_pr913 +jpadilla_pyjwt_pr940 +jpadilla_pyjwt_pr963 +jpadilla_pyjwt_pr979 +jpadilla_pyjwt_pr985 +jrief_django-sass-processor_pr147 +jschneier_django-storages_pr1000 +jschneier_django-storages_pr1060 +jschneier_django-storages_pr1061 +jschneier_django-storages_pr1063 +jschneier_django-storages_pr1069 +jschneier_django-storages_pr1071 +jschneier_django-storages_pr1076 +jschneier_django-storages_pr1083 +jschneier_django-storages_pr1085 +jschneier_django-storages_pr1087 +jschneier_django-storages_pr1112 +jschneier_django-storages_pr1132 +jschneier_django-storages_pr1134 +jschneier_django-storages_pr1154 +jschneier_django-storages_pr1156 +jschneier_django-storages_pr1158 +jschneier_django-storages_pr1159 +jschneier_django-storages_pr1167 +jschneier_django-storages_pr1172 +jschneier_django-storages_pr1194 +jschneier_django-storages_pr1200 +jschneier_django-storages_pr1201 +jschneier_django-storages_pr1203 +jschneier_django-storages_pr1249 +jschneier_django-storages_pr1250 +jschneier_django-storages_pr1251 +jschneier_django-storages_pr1274 +jschneier_django-storages_pr1278 +jschneier_django-storages_pr1279 +jschneier_django-storages_pr1280 +jschneier_django-storages_pr1281 +jschneier_django-storages_pr320 +jschneier_django-storages_pr336 +jschneier_django-storages_pr339 +jschneier_django-storages_pr341 +jschneier_django-storages_pr342 +jschneier_django-storages_pr348 +jschneier_django-storages_pr349 +jschneier_django-storages_pr357 +jschneier_django-storages_pr358 +jschneier_django-storages_pr375 +jschneier_django-storages_pr379 +jschneier_django-storages_pr41 +jschneier_django-storages_pr45 +jschneier_django-storages_pr460 +jschneier_django-storages_pr464 +jschneier_django-storages_pr504 +jschneier_django-storages_pr505 +jschneier_django-storages_pr516 +jschneier_django-storages_pr520 +jschneier_django-storages_pr535 +jschneier_django-storages_pr551 +jschneier_django-storages_pr553 +jschneier_django-storages_pr60 +jschneier_django-storages_pr938 +jschneier_django-storages_pr980 +jschneier_django-storages_pr994 +jsh9_pydoclint_pr120 +jsh9_pydoclint_pr123 +jsh9_pydoclint_pr129 +jsh9_pydoclint_pr130 +jsh9_pydoclint_pr132 +jsh9_pydoclint_pr133 +jsh9_pydoclint_pr145 +jsh9_pydoclint_pr146 +jsh9_pydoclint_pr153 +jsh9_pydoclint_pr154 +jsh9_pydoclint_pr155 +jsh9_pydoclint_pr168 +jsh9_pydoclint_pr181 +jsh9_pydoclint_pr185 +jsh9_pydoclint_pr188 +jsh9_pydoclint_pr192 +jsh9_pydoclint_pr194 +jsh9_pydoclint_pr199 +jsh9_pydoclint_pr205 +jsh9_pydoclint_pr206 +jsh9_pydoclint_pr207 +jsh9_pydoclint_pr215 +jsh9_pydoclint_pr218 +jsh9_pydoclint_pr225 +jsh9_pydoclint_pr227 +jsh9_pydoclint_pr230 +jsh9_pydoclint_pr249 +jsh9_pydoclint_pr259 +jsh9_pydoclint_pr260 +jsh9_pydoclint_pr261 +jsh9_pydoclint_pr267 +jsh9_pydoclint_pr271 +jsh9_pydoclint_pr275 +jsh9_pydoclint_pr277 +jsh9_pydoclint_pr80 +jsh9_pydoclint_pr83 +jsh9_pydoclint_pr86 +jsh9_pydoclint_pr89 +jsh9_pydoclint_pr94 +jsonpickle_jsonpickle_pr400 +jsonpickle_jsonpickle_pr403 +jsonpickle_jsonpickle_pr418 +jsonpickle_jsonpickle_pr433 +jsonpickle_jsonpickle_pr434 +jsonpickle_jsonpickle_pr446 +jsonpickle_jsonpickle_pr455 +jsonpickle_jsonpickle_pr473 +jsonpickle_jsonpickle_pr494 +jsonpickle_jsonpickle_pr501 +jsonpickle_jsonpickle_pr514 +jsonpickle_jsonpickle_pr57 +jsonpickle_jsonpickle_pr58 +juftin_hatch-pip-compile_pr60 +jupyter-server_jupyter-scheduler_pr448 +jupyter-server_jupyter-scheduler_pr450 +jupyter-server_jupyter-scheduler_pr463 +jupyter-server_jupyter-scheduler_pr510 +jupyter-widgets_ipywidgets_pr1823 +jupyter-widgets_ipywidgets_pr2021 +jupyter-widgets_ipywidgets_pr2193 +jupyter-widgets_ipywidgets_pr2283 +jupyter-widgets_ipywidgets_pr2376 +jupyter-widgets_ipywidgets_pr2489 +jupyter-widgets_ipywidgets_pr2516 +jupyter-widgets_ipywidgets_pr2525 +jupyter-widgets_ipywidgets_pr2528 +jupyter-widgets_ipywidgets_pr2558 +jupyter-widgets_ipywidgets_pr2566 +jupyter-widgets_ipywidgets_pr2570 +jupyter-widgets_ipywidgets_pr2572 +jupyter-widgets_ipywidgets_pr2640 +jupyter-widgets_ipywidgets_pr2654 +jupyter-widgets_ipywidgets_pr2664 +jupyter-widgets_ipywidgets_pr2666 +jupyter-widgets_ipywidgets_pr2678 +jupyter-widgets_ipywidgets_pr2679 +jupyter-widgets_ipywidgets_pr2680 +jupyter-widgets_ipywidgets_pr2683 +jupyter-widgets_ipywidgets_pr2685 +jupyter-widgets_ipywidgets_pr2692 +jupyter-widgets_ipywidgets_pr2710 +jupyter-widgets_ipywidgets_pr2712 +jupyter-widgets_ipywidgets_pr2715 +jupyter-widgets_ipywidgets_pr2723 +jupyter-widgets_ipywidgets_pr2724 +jupyter-widgets_ipywidgets_pr2728 +jupyter-widgets_ipywidgets_pr2746 +jupyter-widgets_ipywidgets_pr2752 +jupyter-widgets_ipywidgets_pr2757 +jupyter-widgets_ipywidgets_pr2816 +jupyter-widgets_ipywidgets_pr2827 +jupyter-widgets_ipywidgets_pr2834 +jupyter-widgets_ipywidgets_pr3091 +jupyter-widgets_ipywidgets_pr3118 +jupyter-widgets_ipywidgets_pr3122 +jupyter-widgets_ipywidgets_pr3124 +jupyter-widgets_ipywidgets_pr3142 +jupyter-widgets_ipywidgets_pr3146 +jupyter-widgets_ipywidgets_pr3172 +jupyter-widgets_ipywidgets_pr3173 +jupyter-widgets_ipywidgets_pr3199 +jupyter-widgets_ipywidgets_pr3216 +jupyter-widgets_ipywidgets_pr3269 +jupyter-widgets_ipywidgets_pr3271 +jupyter-widgets_ipywidgets_pr3280 +jupyter-widgets_ipywidgets_pr3283 +jupyter-widgets_ipywidgets_pr3286 +jupyter-widgets_ipywidgets_pr3394 +jupyter-widgets_ipywidgets_pr3533 +jupyter-widgets_ipywidgets_pr3567 +jupyter-widgets_ipywidgets_pr3569 +jupyter-widgets_ipywidgets_pr3780 +jupyter-widgets_ipywidgets_pr3796 +jupyter-widgets_ipywidgets_pr3908 +jupyter_nbclassic_pr141 +jupyter_nbclassic_pr165 +jupyter_nbclassic_pr166 +jupyter_nbclassic_pr172 +jupyter_nbclassic_pr212 +jupyter_nbclassic_pr216 +jupyter_nbclassic_pr267 +jupyter_nbclassic_pr269 +jupyter_nbclassic_pr310 +jupyter_nbclassic_pr317 +jupyter_nbclassic_pr375 +jupyter_nbclassic_pr93 +jupyter_nbclient_pr37 +jupyter_nbclient_pr64 +jupyter_nbclient_pr77 +jupyterhub_oauthenticator_pr358 +jupyterhub_oauthenticator_pr363 +jupyterhub_oauthenticator_pr366 +jupyterhub_oauthenticator_pr386 +jupyterhub_oauthenticator_pr389 +jupyterhub_oauthenticator_pr393 +jupyterhub_oauthenticator_pr395 +jupyterhub_oauthenticator_pr404 +jupyterhub_oauthenticator_pr410 +jupyterhub_oauthenticator_pr415 +jupyterhub_oauthenticator_pr420 +jupyterhub_oauthenticator_pr437 +jupyterhub_oauthenticator_pr439 +jupyterhub_oauthenticator_pr441 +jupyterhub_oauthenticator_pr442 +jupyterhub_oauthenticator_pr449 +jupyterhub_oauthenticator_pr484 +jupyterhub_oauthenticator_pr517 +jupyterhub_oauthenticator_pr518 +jupyterhub_oauthenticator_pr526 +jupyterhub_oauthenticator_pr534 +jupyterhub_oauthenticator_pr537 +jupyterhub_oauthenticator_pr542 +jupyterhub_oauthenticator_pr575 +jupyterhub_oauthenticator_pr578 +justindujardin_pathy_pr108 +jwbargsten_pytest-archon_pr10 +jwbargsten_pytest-archon_pr11 +jwbargsten_pytest-archon_pr12 +jwbargsten_pytest-archon_pr16 +jwbargsten_pytest-archon_pr2 +jwbargsten_pytest-archon_pr20 +jwbargsten_pytest-archon_pr25 +jwbargsten_pytest-archon_pr28 +jwbargsten_pytest-archon_pr4 +jwbargsten_pytest-archon_pr8 +jwodder_click-loglevel_pr11 +jwodder_versioningit_pr118 +jwodder_versioningit_pr77 +jwodder_versioningit_pr79 +jxtech_wechatpy_pr100 +jxtech_wechatpy_pr103 +jxtech_wechatpy_pr106 +jxtech_wechatpy_pr139 +jxtech_wechatpy_pr144 +jxtech_wechatpy_pr145 +jxtech_wechatpy_pr156 +jxtech_wechatpy_pr162 +jxtech_wechatpy_pr165 +jxtech_wechatpy_pr166 +jxtech_wechatpy_pr167 +jxtech_wechatpy_pr170 +jxtech_wechatpy_pr194 +jxtech_wechatpy_pr195 +jxtech_wechatpy_pr199 +jxtech_wechatpy_pr211 +jxtech_wechatpy_pr216 +jxtech_wechatpy_pr217 +jxtech_wechatpy_pr228 +jxtech_wechatpy_pr238 +jxtech_wechatpy_pr240 +jxtech_wechatpy_pr241 +jxtech_wechatpy_pr247 +jxtech_wechatpy_pr248 +jxtech_wechatpy_pr249 +jxtech_wechatpy_pr255 +jxtech_wechatpy_pr270 +jxtech_wechatpy_pr279 +jxtech_wechatpy_pr288 +jxtech_wechatpy_pr296 +jxtech_wechatpy_pr300 +jxtech_wechatpy_pr301 +jxtech_wechatpy_pr306 +jxtech_wechatpy_pr315 +jxtech_wechatpy_pr318 +jxtech_wechatpy_pr325 +jxtech_wechatpy_pr328 +jxtech_wechatpy_pr333 +jxtech_wechatpy_pr345 +jxtech_wechatpy_pr346 +jxtech_wechatpy_pr349 +jxtech_wechatpy_pr364 +jxtech_wechatpy_pr365 +jxtech_wechatpy_pr373 +jxtech_wechatpy_pr376 +jxtech_wechatpy_pr381 +jxtech_wechatpy_pr397 +jxtech_wechatpy_pr403 +jxtech_wechatpy_pr404 +jxtech_wechatpy_pr408 +jxtech_wechatpy_pr412 +jxtech_wechatpy_pr413 +jxtech_wechatpy_pr419 +jxtech_wechatpy_pr422 +jxtech_wechatpy_pr429 +jxtech_wechatpy_pr447 +jxtech_wechatpy_pr45 +jxtech_wechatpy_pr450 +jxtech_wechatpy_pr456 +jxtech_wechatpy_pr463 +jxtech_wechatpy_pr470 +jxtech_wechatpy_pr487 +jxtech_wechatpy_pr499 +jxtech_wechatpy_pr503 +jxtech_wechatpy_pr508 +jxtech_wechatpy_pr509 +jxtech_wechatpy_pr518 +jxtech_wechatpy_pr521 +jxtech_wechatpy_pr523 +jxtech_wechatpy_pr526 +jxtech_wechatpy_pr527 +jxtech_wechatpy_pr535 +jxtech_wechatpy_pr537 +jxtech_wechatpy_pr550 +jxtech_wechatpy_pr560 +jxtech_wechatpy_pr569 +jxtech_wechatpy_pr579 +jxtech_wechatpy_pr581 +jxtech_wechatpy_pr66 +jxtech_wechatpy_pr69 +jxtech_wechatpy_pr74 +jxtech_wechatpy_pr75 +jxtech_wechatpy_pr81 +jxtech_wechatpy_pr86 +jxtech_wechatpy_pr87 +jxtech_wechatpy_pr91 +jxtech_wechatpy_pr94 +k2-fsa_sherpa-onnx_pr1003 +k2-fsa_sherpa-onnx_pr1009 +k2-fsa_sherpa-onnx_pr1010 +k2-fsa_sherpa-onnx_pr1020 +k2-fsa_sherpa-onnx_pr1029 +k2-fsa_sherpa-onnx_pr1036 +k2-fsa_sherpa-onnx_pr1046 +k2-fsa_sherpa-onnx_pr1049 +k2-fsa_sherpa-onnx_pr1052 +k2-fsa_sherpa-onnx_pr1055 +k2-fsa_sherpa-onnx_pr1072 +k2-fsa_sherpa-onnx_pr1079 +k2-fsa_sherpa-onnx_pr1092 +k2-fsa_sherpa-onnx_pr1105 +k2-fsa_sherpa-onnx_pr1113 +k2-fsa_sherpa-onnx_pr1114 +k2-fsa_sherpa-onnx_pr1120 +k2-fsa_sherpa-onnx_pr1124 +k2-fsa_sherpa-onnx_pr1126 +k2-fsa_sherpa-onnx_pr1129 +k2-fsa_sherpa-onnx_pr1132 +k2-fsa_sherpa-onnx_pr1134 +k2-fsa_sherpa-onnx_pr1141 +k2-fsa_sherpa-onnx_pr1144 +k2-fsa_sherpa-onnx_pr1148 +k2-fsa_sherpa-onnx_pr1151 +k2-fsa_sherpa-onnx_pr1154 +k2-fsa_sherpa-onnx_pr1156 +k2-fsa_sherpa-onnx_pr1159 +k2-fsa_sherpa-onnx_pr1162 +k2-fsa_sherpa-onnx_pr1164 +k2-fsa_sherpa-onnx_pr1180 +k2-fsa_sherpa-onnx_pr1182 +k2-fsa_sherpa-onnx_pr1191 +k2-fsa_sherpa-onnx_pr1194 +k2-fsa_sherpa-onnx_pr1203 +k2-fsa_sherpa-onnx_pr1223 +k2-fsa_sherpa-onnx_pr1226 +k2-fsa_sherpa-onnx_pr1230 +k2-fsa_sherpa-onnx_pr1243 +k2-fsa_sherpa-onnx_pr1247 +k2-fsa_sherpa-onnx_pr1270 +k2-fsa_sherpa-onnx_pr1271 +k2-fsa_sherpa-onnx_pr1276 +k2-fsa_sherpa-onnx_pr1277 +k2-fsa_sherpa-onnx_pr1286 +k2-fsa_sherpa-onnx_pr1287 +k2-fsa_sherpa-onnx_pr1291 +k2-fsa_sherpa-onnx_pr1293 +k2-fsa_sherpa-onnx_pr1294 +k2-fsa_sherpa-onnx_pr1307 +k2-fsa_sherpa-onnx_pr1324 +k2-fsa_sherpa-onnx_pr1355 +k2-fsa_sherpa-onnx_pr1358 +k2-fsa_sherpa-onnx_pr1381 +k2-fsa_sherpa-onnx_pr192 +k2-fsa_sherpa-onnx_pr193 +k2-fsa_sherpa-onnx_pr195 +k2-fsa_sherpa-onnx_pr201 +k2-fsa_sherpa-onnx_pr213 +k2-fsa_sherpa-onnx_pr216 +k2-fsa_sherpa-onnx_pr217 +k2-fsa_sherpa-onnx_pr220 +k2-fsa_sherpa-onnx_pr227 +k2-fsa_sherpa-onnx_pr229 +k2-fsa_sherpa-onnx_pr239 +k2-fsa_sherpa-onnx_pr247 +k2-fsa_sherpa-onnx_pr257 +k2-fsa_sherpa-onnx_pr264 +k2-fsa_sherpa-onnx_pr268 +k2-fsa_sherpa-onnx_pr269 +k2-fsa_sherpa-onnx_pr303 +k2-fsa_sherpa-onnx_pr304 +k2-fsa_sherpa-onnx_pr308 +k2-fsa_sherpa-onnx_pr318 +k2-fsa_sherpa-onnx_pr326 +k2-fsa_sherpa-onnx_pr331 +k2-fsa_sherpa-onnx_pr344 +k2-fsa_sherpa-onnx_pr353 +k2-fsa_sherpa-onnx_pr355 +k2-fsa_sherpa-onnx_pr356 +k2-fsa_sherpa-onnx_pr360 +k2-fsa_sherpa-onnx_pr362 +k2-fsa_sherpa-onnx_pr363 +k2-fsa_sherpa-onnx_pr365 +k2-fsa_sherpa-onnx_pr367 +k2-fsa_sherpa-onnx_pr383 +k2-fsa_sherpa-onnx_pr400 +k2-fsa_sherpa-onnx_pr401 +k2-fsa_sherpa-onnx_pr402 +k2-fsa_sherpa-onnx_pr403 +k2-fsa_sherpa-onnx_pr413 +k2-fsa_sherpa-onnx_pr428 +k2-fsa_sherpa-onnx_pr434 +k2-fsa_sherpa-onnx_pr450 +k2-fsa_sherpa-onnx_pr451 +k2-fsa_sherpa-onnx_pr452 +k2-fsa_sherpa-onnx_pr457 +k2-fsa_sherpa-onnx_pr462 +k2-fsa_sherpa-onnx_pr471 +k2-fsa_sherpa-onnx_pr473 +k2-fsa_sherpa-onnx_pr478 +k2-fsa_sherpa-onnx_pr482 +k2-fsa_sherpa-onnx_pr484 +k2-fsa_sherpa-onnx_pr485 +k2-fsa_sherpa-onnx_pr486 +k2-fsa_sherpa-onnx_pr494 +k2-fsa_sherpa-onnx_pr496 +k2-fsa_sherpa-onnx_pr505 +k2-fsa_sherpa-onnx_pr508 +k2-fsa_sherpa-onnx_pr509 +k2-fsa_sherpa-onnx_pr522 +k2-fsa_sherpa-onnx_pr530 +k2-fsa_sherpa-onnx_pr533 +k2-fsa_sherpa-onnx_pr542 +k2-fsa_sherpa-onnx_pr553 +k2-fsa_sherpa-onnx_pr557 +k2-fsa_sherpa-onnx_pr561 +k2-fsa_sherpa-onnx_pr568 +k2-fsa_sherpa-onnx_pr571 +k2-fsa_sherpa-onnx_pr577 +k2-fsa_sherpa-onnx_pr584 +k2-fsa_sherpa-onnx_pr586 +k2-fsa_sherpa-onnx_pr591 +k2-fsa_sherpa-onnx_pr593 +k2-fsa_sherpa-onnx_pr605 +k2-fsa_sherpa-onnx_pr609 +k2-fsa_sherpa-onnx_pr626 +k2-fsa_sherpa-onnx_pr635 +k2-fsa_sherpa-onnx_pr636 +k2-fsa_sherpa-onnx_pr637 +k2-fsa_sherpa-onnx_pr642 +k2-fsa_sherpa-onnx_pr643 +k2-fsa_sherpa-onnx_pr646 +k2-fsa_sherpa-onnx_pr676 +k2-fsa_sherpa-onnx_pr679 +k2-fsa_sherpa-onnx_pr688 +k2-fsa_sherpa-onnx_pr693 +k2-fsa_sherpa-onnx_pr696 +k2-fsa_sherpa-onnx_pr699 +k2-fsa_sherpa-onnx_pr707 +k2-fsa_sherpa-onnx_pr709 +k2-fsa_sherpa-onnx_pr710 +k2-fsa_sherpa-onnx_pr742 +k2-fsa_sherpa-onnx_pr747 +k2-fsa_sherpa-onnx_pr749 +k2-fsa_sherpa-onnx_pr802 +k2-fsa_sherpa-onnx_pr809 +k2-fsa_sherpa-onnx_pr810 +k2-fsa_sherpa-onnx_pr811 +k2-fsa_sherpa-onnx_pr812 +k2-fsa_sherpa-onnx_pr817 +k2-fsa_sherpa-onnx_pr818 +k2-fsa_sherpa-onnx_pr822 +k2-fsa_sherpa-onnx_pr836 +k2-fsa_sherpa-onnx_pr838 +k2-fsa_sherpa-onnx_pr841 +k2-fsa_sherpa-onnx_pr843 +k2-fsa_sherpa-onnx_pr844 +k2-fsa_sherpa-onnx_pr857 +k2-fsa_sherpa-onnx_pr861 +k2-fsa_sherpa-onnx_pr862 +k2-fsa_sherpa-onnx_pr876 +k2-fsa_sherpa-onnx_pr877 +k2-fsa_sherpa-onnx_pr894 +k2-fsa_sherpa-onnx_pr904 +k2-fsa_sherpa-onnx_pr907 +k2-fsa_sherpa-onnx_pr915 +k2-fsa_sherpa-onnx_pr928 +k2-fsa_sherpa-onnx_pr930 +k2-fsa_sherpa-onnx_pr932 +k2-fsa_sherpa-onnx_pr933 +k2-fsa_sherpa-onnx_pr945 +k2-fsa_sherpa-onnx_pr951 +k2-fsa_sherpa-onnx_pr961 +k2-fsa_sherpa-onnx_pr963 +k2-fsa_sherpa-onnx_pr978 +k2-fsa_sherpa-onnx_pr990 +k2-fsa_sherpa-onnx_pr991 +kaiko-ai_typedspark_pr133 +kaiko-ai_typedspark_pr136 +kaiko-ai_typedspark_pr139 +kaiko-ai_typedspark_pr146 +kaiko-ai_typedspark_pr172 +kaiko-ai_typedspark_pr184 +kaiko-ai_typedspark_pr212 +kaiko-ai_typedspark_pr216 +kaiko-ai_typedspark_pr224 +kaiko-ai_typedspark_pr315 +kaiko-ai_typedspark_pr355 +karask_python-bitcoin-utils_pr106 +karask_python-bitcoin-utils_pr113 +karask_python-bitcoin-utils_pr116 +karask_python-bitcoin-utils_pr127 +karask_python-bitcoin-utils_pr141 +karask_python-bitcoin-utils_pr157 +karask_python-bitcoin-utils_pr64 +karask_python-bitcoin-utils_pr74 +karask_python-bitcoin-utils_pr75 +karask_python-bitcoin-utils_pr77 +karask_python-bitcoin-utils_pr83 +karask_python-bitcoin-utils_pr85 +karpetrosyan_hishel_pr104 +karpetrosyan_hishel_pr111 +karpetrosyan_hishel_pr117 +karpetrosyan_hishel_pr119 +karpetrosyan_hishel_pr130 +karpetrosyan_hishel_pr138 +karpetrosyan_hishel_pr146 +karpetrosyan_hishel_pr147 +karpetrosyan_hishel_pr164 +karpetrosyan_hishel_pr169 +karpetrosyan_hishel_pr181 +karpetrosyan_hishel_pr182 +karpetrosyan_hishel_pr186 +karpetrosyan_hishel_pr204 +karpetrosyan_hishel_pr220 +karpetrosyan_hishel_pr240 +karpetrosyan_hishel_pr241 +karpetrosyan_hishel_pr242 +karpetrosyan_hishel_pr248 +karpetrosyan_hishel_pr251 +karpetrosyan_hishel_pr269 +karpetrosyan_hishel_pr273 +karpetrosyan_hishel_pr275 +karpetrosyan_hishel_pr28 +karpetrosyan_hishel_pr318 +karpetrosyan_hishel_pr320 +karpetrosyan_hishel_pr334 +karpetrosyan_hishel_pr336 +karpetrosyan_hishel_pr353 +karpetrosyan_hishel_pr42 +karpetrosyan_hishel_pr56 +karpetrosyan_hishel_pr7 +karpetrosyan_hishel_pr8 +karpetrosyan_hishel_pr83 +karpetrosyan_hishel_pr86 +karpetrosyan_hishel_pr90 +karpetrosyan_hishel_pr95 +keboola_python-component_pr20 +keboola_python-component_pr39 +keboola_python-component_pr4 +keboola_python-component_pr44 +keboola_python-component_pr47 +keboola_python-component_pr51 +keboola_python-component_pr60 +keboola_python-component_pr63 +keis_base58_pr43 +keis_base58_pr46 +keis_base58_pr50 +keis_base58_pr56 +keis_base58_pr58 +keis_base58_pr63 +keleshev_schema_pr127 +keleshev_schema_pr128 +keleshev_schema_pr141 +keleshev_schema_pr170 +keleshev_schema_pr174 +keleshev_schema_pr178 +keleshev_schema_pr181 +keleshev_schema_pr182 +keleshev_schema_pr184 +keleshev_schema_pr186 +keleshev_schema_pr206 +keleshev_schema_pr210 +keleshev_schema_pr212 +keleshev_schema_pr214 +keleshev_schema_pr217 +keleshev_schema_pr218 +keleshev_schema_pr220 +keleshev_schema_pr234 +keleshev_schema_pr244 +keleshev_schema_pr26 +keleshev_schema_pr268 +keleshev_schema_pr306 +keleshev_schema_pr319 +keleshev_schema_pr32 +keleshev_schema_pr332 +keleshev_schema_pr337 +keleshev_schema_pr52 +keleshev_schema_pr72 +keleshev_schema_pr85 +keleshev_schema_pr91 +keleshev_schema_pr97 +kelproject_pykube_pr103 +kelproject_pykube_pr115 +kelproject_pykube_pr128 +kelproject_pykube_pr15 +kelproject_pykube_pr17 +kelproject_pykube_pr21 +kelproject_pykube_pr26 +kelproject_pykube_pr46 +kelproject_pykube_pr67 +kelproject_pykube_pr68 +kelproject_pykube_pr78 +kelproject_pykube_pr83 +kelproject_pykube_pr89 +kelproject_pykube_pr92 +kelproject_pykube_pr93 +kelsin_mysql-mimic_pr11 +kelsin_mysql-mimic_pr13 +kelsin_mysql-mimic_pr15 +kelsin_mysql-mimic_pr4 +kelsin_mysql-mimic_pr69 +kenkundert_inform_pr3 +kensho-technologies_pyctcdecode_pr102 +kensho-technologies_pyctcdecode_pr106 +kensho-technologies_pyctcdecode_pr32 +kensho-technologies_pyctcdecode_pr35 +kensho-technologies_pyctcdecode_pr43 +kensho-technologies_pyctcdecode_pr52 +kensho-technologies_pyctcdecode_pr67 +kensho-technologies_pyctcdecode_pr68 +kensho-technologies_pyctcdecode_pr7 +kensho-technologies_pyctcdecode_pr78 +kiorky_croniter_pr163 +kiorky_croniter_pr169 +kiorky_croniter_pr170 +kiorky_croniter_pr177 +kiorky_croniter_pr181 +kiorky_croniter_pr43 +kiorky_croniter_pr71 +kiorky_croniter_pr78 +kiorky_croniter_pr81 +kiorky_croniter_pr82 +kipe_pycron_pr41 +kipe_pycron_pr5 +kivy_buildozer_pr1230 +kivy_buildozer_pr1435 +kivy_buildozer_pr1450 +kivy_buildozer_pr1525 +kivy_buildozer_pr1548 +kivy_buildozer_pr1575 +kivy_buildozer_pr1628 +kivy_buildozer_pr1639 +kivy_buildozer_pr1648 +kivy_buildozer_pr1667 +kivy_buildozer_pr1686 +kivy_buildozer_pr1689 +kivy_buildozer_pr1690 +kivy_buildozer_pr1692 +kivy_buildozer_pr1694 +kivy_buildozer_pr1888 +kivy_buildozer_pr1894 +kivy_buildozer_pr787 +kivy_buildozer_pr805 +kivy_buildozer_pr806 +kivy_buildozer_pr821 +kivy_buildozer_pr852 +kivy_buildozer_pr970 +kivy_plyer_pr410 +kivy_plyer_pr422 +kivy_plyer_pr423 +kivy_plyer_pr431 +kivy_plyer_pr438 +kivy_plyer_pr442 +kivy_plyer_pr455 +kivy_plyer_pr457 +kivy_plyer_pr473 +kivy_plyer_pr474 +kivy_plyer_pr476 +kivy_plyer_pr483 +kivy_plyer_pr488 +kivy_plyer_pr519 +kivy_plyer_pr542 +kivy_plyer_pr544 +kivy_plyer_pr590 +kivy_plyer_pr624 +kivy_plyer_pr630 +kivy_plyer_pr634 +kivy_plyer_pr639 +kivy_plyer_pr665 +kivy_plyer_pr669 +kivy_plyer_pr680 +kivy_plyer_pr712 +kivy_plyer_pr732 +kivy_plyer_pr742 +kivy_plyer_pr750 +kivy_plyer_pr756 +kivy_plyer_pr781 +kivy_plyer_pr813 +kivy_plyer_pr828 +kiwicom_structlog-sentry_pr74 +kjd_idna_pr111 +kjd_idna_pr112 +kjd_idna_pr120 +kjd_idna_pr145 +kjd_idna_pr153 +kjd_idna_pr154 +kjd_idna_pr24 +kjd_idna_pr33 +kjd_idna_pr41 +kodemore_kink_pr12 +kodemore_kink_pr14 +kodemore_kink_pr25 +kodemore_kink_pr26 +kodemore_kink_pr3 +kodemore_kink_pr54 +kodemore_kink_pr7 +kodemore_kink_pr71 +kolonialno_django-api-decorator_pr13 +kolonialno_django-api-decorator_pr18 +kolonialno_django-api-decorator_pr21 +kolonialno_django-api-decorator_pr27 +kolonialno_django-api-decorator_pr30 +kolonialno_django-api-decorator_pr33 +kolonialno_django-api-decorator_pr38 +kolonialno_django-api-decorator_pr41 +kolonialno_troncos_pr13 +kolonialno_troncos_pr5 +kolonialno_troncos_pr8 +kuimono_openapi-schema-pydantic_pr11 +kurtbrose_pyjks_pr18 +kurtbrose_pyjks_pr19 +kurtbrose_pyjks_pr22 +kurtbrose_pyjks_pr26 +kvesteri_sqlalchemy-continuum_pr370 +kyleking_mdformat-mkdocs_pr11 +kyleking_mdformat-mkdocs_pr26 +kyleking_mdformat-mkdocs_pr38 +kyleking_mdformat-mkdocs_pr41 +kyleking_mdformat-mkdocs_pr43 +kyleking_mdformat-mkdocs_pr52 +kyleking_mdformat-mkdocs_pr55 +kyleking_mdformat-mkdocs_pr62 +lancedb_lancedb_pr123 +lancedb_lancedb_pr174 +lancedb_lancedb_pr217 +lancedb_lancedb_pr232 +lancedb_lancedb_pr233 +lancedb_lancedb_pr241 +lancedb_lancedb_pr254 +lancedb_lancedb_pr26 +lancedb_lancedb_pr260 +lancedb_lancedb_pr274 +lancedb_lancedb_pr304 +lancedb_lancedb_pr316 +lancedb_lancedb_pr34 +lancedb_lancedb_pr35 +lancedb_lancedb_pr47 +landscapeio_requirements-detector_pr50 +landscapeio_requirements-detector_pr51 +langchain-ai_langchain-aws_pr5 +lasp_cdflib_pr106 +lasp_cdflib_pr140 +lasp_cdflib_pr144 +lasp_cdflib_pr156 +lasp_cdflib_pr159 +lasp_cdflib_pr162 +lasp_cdflib_pr187 +lasp_cdflib_pr199 +lasp_cdflib_pr200 +lasp_cdflib_pr201 +lasp_cdflib_pr203 +lasp_cdflib_pr205 +lasp_cdflib_pr206 +lasp_cdflib_pr209 +lasp_cdflib_pr217 +lasp_cdflib_pr227 +lasp_cdflib_pr251 +lasp_cdflib_pr252 +lasp_cdflib_pr253 +lasp_cdflib_pr255 +lasp_cdflib_pr256 +lasp_cdflib_pr257 +lasp_cdflib_pr284 +lasp_cdflib_pr287 +lasp_cdflib_pr38 +lasp_cdflib_pr46 +lasp_cdflib_pr49 +lasp_cdflib_pr51 +lasp_cdflib_pr54 +lasp_cdflib_pr57 +lasp_cdflib_pr79 +lasp_cdflib_pr97 +lasselindqvist_robotframework-imaplibrary2_pr17 +lasselindqvist_robotframework-imaplibrary2_pr32 +lasselindqvist_robotframework-imaplibrary2_pr33 +lasselindqvist_robotframework-imaplibrary2_pr35 +lasselindqvist_robotframework-imaplibrary2_pr38 +lasselindqvist_robotframework-imaplibrary2_pr40 +lepture_flask-oauthlib_pr202 +lepture_flask-oauthlib_pr290 +lepture_flask-oauthlib_pr340 +lepture_flask-oauthlib_pr358 +lepture_flask-oauthlib_pr385 +lepture_mistune_pr283 +lepture_mistune_pr295 +lepture_mistune_pr337 +lepture_mistune_pr375 +lepture_mistune_pr384 +lepture_mistune_pr395 +lesscpy_lesscpy_pr117 +lesscpy_lesscpy_pr118 +lextudio_pysmi_pr11 +linkml_prefixmaps_pr14 +linkml_prefixmaps_pr17 +linkml_prefixmaps_pr37 +linkml_prefixmaps_pr5 +liormizr_s3path_pr116 +liormizr_s3path_pr118 +liormizr_s3path_pr121 +liormizr_s3path_pr124 +liormizr_s3path_pr129 +liormizr_s3path_pr132 +liormizr_s3path_pr139 +liormizr_s3path_pr152 +liormizr_s3path_pr163 +liormizr_s3path_pr171 +liormizr_s3path_pr173 +liormizr_s3path_pr177 +liormizr_s3path_pr181 +liormizr_s3path_pr196 +liran-funaro_sphinx-markdown-builder_pr20 +litl_backoff_pr161 +litl_rauth_pr147 +lmas_opensimplex_pr31 +lmfit_asteval_pr85 +lmmentel_mendeleev_pr43 +lmmentel_mendeleev_pr53 +lmmentel_mendeleev_pr76 +loadsmart_django-jaiminho_pr18 +loadsmart_django-jaiminho_pr181 +loadsmart_django-jaiminho_pr19 +loadsmart_django-jaiminho_pr20 +loadsmart_django-jaiminho_pr23 +loadsmart_django-jaiminho_pr24 +loadsmart_django-jaiminho_pr27 +loadsmart_django-jaiminho_pr29 +loadsmart_django-jaiminho_pr30 +loadsmart_django-jaiminho_pr36 +loadsmart_django-jaiminho_pr38 +loadsmart_django-jaiminho_pr39 +loadsmart_django-jaiminho_pr40 +loadsmart_django-jaiminho_pr44 +loadsmart_django-jaiminho_pr7 +loadsmart_django-jaiminho_pr8 +loadsmart_django-jaiminho_pr82 +loadsmart_django-jaiminho_pr91 +loadsmart_django-jaiminho_pr99 +localstack_plux_pr10 +localstack_plux_pr17 +localstack_plux_pr18 +localstack_plux_pr19 +localstack_plux_pr20 +localstack_plux_pr21 +localstack_plux_pr22 +localstack_plux_pr24 +localstack_plux_pr28 +localstack_plux_pr33 +localstack_plux_pr5 +localstack_plux_pr7 +localstack_plux_pr9 +logandk_serverless-wsgi_pr100 +logandk_serverless-wsgi_pr101 +logandk_serverless-wsgi_pr146 +logandk_serverless-wsgi_pr149 +logandk_serverless-wsgi_pr167 +logandk_serverless-wsgi_pr189 +logandk_serverless-wsgi_pr193 +logandk_serverless-wsgi_pr195 +logandk_serverless-wsgi_pr199 +logandk_serverless-wsgi_pr222 +logandk_serverless-wsgi_pr224 +logandk_serverless-wsgi_pr23 +logandk_serverless-wsgi_pr232 +logandk_serverless-wsgi_pr248 +logandk_serverless-wsgi_pr25 +logandk_serverless-wsgi_pr273 +logandk_serverless-wsgi_pr28 +logandk_serverless-wsgi_pr61 +logandk_serverless-wsgi_pr87 +logdna_python_pr100 +logdna_python_pr104 +logdna_python_pr107 +logdna_python_pr75 +logdna_python_pr87 +logdna_python_pr93 +logdna_python_pr96 +lovesegfault_beautysh_pr36 +ludeeus_awesomeversion_pr107 +ludeeus_awesomeversion_pr122 +ludeeus_awesomeversion_pr123 +ludeeus_awesomeversion_pr133 +ludeeus_awesomeversion_pr149 +ludeeus_awesomeversion_pr150 +ludeeus_awesomeversion_pr156 +ludeeus_awesomeversion_pr159 +ludeeus_awesomeversion_pr162 +ludeeus_awesomeversion_pr165 +ludeeus_awesomeversion_pr170 +ludeeus_awesomeversion_pr173 +ludeeus_awesomeversion_pr174 +ludeeus_awesomeversion_pr184 +ludeeus_awesomeversion_pr185 +ludeeus_awesomeversion_pr195 +ludeeus_awesomeversion_pr219 +ludeeus_awesomeversion_pr224 +ludeeus_awesomeversion_pr233 +ludeeus_awesomeversion_pr264 +ludeeus_awesomeversion_pr28 +ludeeus_awesomeversion_pr290 +ludeeus_awesomeversion_pr302 +ludeeus_awesomeversion_pr304 +ludeeus_awesomeversion_pr33 +ludeeus_awesomeversion_pr335 +ludeeus_awesomeversion_pr35 +ludeeus_awesomeversion_pr36 +ludeeus_awesomeversion_pr37 +ludeeus_awesomeversion_pr38 +ludeeus_awesomeversion_pr389 +ludeeus_awesomeversion_pr41 +ludeeus_awesomeversion_pr42 +ludeeus_awesomeversion_pr421 +ludeeus_awesomeversion_pr423 +ludeeus_awesomeversion_pr44 +ludeeus_awesomeversion_pr46 +ludeeus_awesomeversion_pr47 +ludeeus_awesomeversion_pr50 +ludeeus_awesomeversion_pr69 +ludeeus_awesomeversion_pr76 +ludeeus_awesomeversion_pr78 +ludeeus_awesomeversion_pr92 +ludeeus_awesomeversion_pr95 +ludeeus_awesomeversion_pr97 +ludeeus_awesomeversion_pr98 +luolingchun_flask-openapi3_pr115 +luolingchun_flask-openapi3_pr130 +luolingchun_flask-openapi3_pr141 +luolingchun_flask-openapi3_pr149 +luolingchun_flask-openapi3_pr180 +luolingchun_flask-openapi3_pr184 +luolingchun_flask-openapi3_pr189 +luolingchun_flask-openapi3_pr197 +luolingchun_flask-openapi3_pr199 +luolingchun_flask-openapi3_pr201 +luolingchun_flask-openapi3_pr215 +luolingchun_flask-openapi3_pr221 +luolingchun_flask-openapi3_pr224 +luolingchun_flask-openapi3_pr227 +luolingchun_flask-openapi3_pr232 +luolingchun_flask-openapi3_pr241 +luolingchun_flask-openapi3_pr243 +luolingchun_flask-openapi3_pr37 +luolingchun_flask-openapi3_pr38 +luolingchun_flask-openapi3_pr49 +luolingchun_flask-openapi3_pr68 +luolingchun_flask-openapi3_pr75 +luolingchun_flask-openapi3_pr83 +luolingchun_flask-openapi3_pr84 +luolingchun_flask-openapi3_pr98 +m-burst_flake8-pytest-style_pr125 +m-burst_flake8-pytest-style_pr129 +m-burst_flake8-pytest-style_pr280 +m-burst_flake8-pytest-style_pr3 +m-burst_flake8-pytest-style_pr323 +m-burst_flake8-pytest-style_pr98 +m-burst_flake8-pytest-style_pr99 +madpah_requirements-parser_pr101 +madpah_requirements-parser_pr103 +madpah_requirements-parser_pr105 +madpah_requirements-parser_pr98 +madpah_serializable_pr138 +madpah_serializable_pr177 +madpah_serializable_pr178 +madpah_serializable_pr25 +madpah_serializable_pr26 +madpah_serializable_pr4 +madpah_serializable_pr47 +madpah_serializable_pr5 +madpah_serializable_pr90 +magmax_python-inquirer_pr123 +magmax_python-inquirer_pr154 +magmax_python-inquirer_pr167 +magmax_python-inquirer_pr227 +magmax_python-inquirer_pr232 +magmax_python-inquirer_pr256 +magmax_python-inquirer_pr259 +magmax_python-inquirer_pr275 +magmax_python-inquirer_pr526 +magmax_python-inquirer_pr587 +magmax_python-inquirer_pr687 +mahmoudimus_nose-timer_pr29 +mahmoudimus_nose-timer_pr30 +mahmoudimus_nose-timer_pr37 +mahmoudimus_nose-timer_pr39 +mahmoudimus_nose-timer_pr40 +mahmoudimus_nose-timer_pr42 +makinacorpus_django-safedelete_pr138 +makinacorpus_django-safedelete_pr144 +makinacorpus_django-safedelete_pr145 +makinacorpus_django-safedelete_pr147 +makinacorpus_django-safedelete_pr160 +makinacorpus_django-safedelete_pr179 +makinacorpus_django-safedelete_pr183 +makinacorpus_django-safedelete_pr197 +makinacorpus_django-safedelete_pr204 +makinacorpus_django-safedelete_pr209 +makinacorpus_django-safedelete_pr228 +makinacorpus_django-safedelete_pr236 +makinacorpus_django-safedelete_pr243 +malwarefrank_dnfile_pr29 +malwarefrank_dnfile_pr48 +malwarefrank_dnfile_pr50 +malwarefrank_dnfile_pr74 +malwarefrank_dnfile_pr86 +malwarefrank_dnfile_pr88 +manchenkoff_openapi3-parser_pr39 +manchenkoff_openapi3-parser_pr44 +manchenkoff_openapi3-parser_pr49 +manchenkoff_openapi3-parser_pr62 +manchenkoff_openapi3-parser_pr77 +manuzhang_mkdocs-htmlproofer-plugin_pr49 +manuzhang_mkdocs-htmlproofer-plugin_pr51 +manuzhang_mkdocs-htmlproofer-plugin_pr53 +manuzhang_mkdocs-htmlproofer-plugin_pr55 +manuzhang_mkdocs-htmlproofer-plugin_pr61 +manuzhang_mkdocs-htmlproofer-plugin_pr62 +manuzhang_mkdocs-htmlproofer-plugin_pr68 +manuzhang_mkdocs-htmlproofer-plugin_pr72 +manuzhang_mkdocs-htmlproofer-plugin_pr75 +manuzhang_mkdocs-htmlproofer-plugin_pr79 +manuzhang_mkdocs-htmlproofer-plugin_pr80 +manuzhang_mkdocs-htmlproofer-plugin_pr82 +manuzhang_mkdocs-htmlproofer-plugin_pr91 +mapado_haversine_pr20 +mapado_haversine_pr78 +mapbox_mapbox-sdk-py_pr101 +mapbox_mapbox-sdk-py_pr118 +mapbox_mapbox-sdk-py_pr126 +mapbox_mapbox-sdk-py_pr133 +mapbox_mapbox-sdk-py_pr135 +mapbox_mapbox-sdk-py_pr137 +mapbox_mapbox-sdk-py_pr139 +mapbox_mapbox-sdk-py_pr62 +mapbox_mapbox-sdk-py_pr67 +mapbox_mapbox-sdk-py_pr76 +mapbox_mapbox-sdk-py_pr83 +mapbox_mapbox-sdk-py_pr85 +mapbox_mapbox-sdk-py_pr86 +mapbox_mapbox-sdk-py_pr87 +mapbox_mapbox-sdk-py_pr91 +mapbox_mapbox-sdk-py_pr92 +mapbox_mapbox-sdk-py_pr96 +mapbox_mapbox-sdk-py_pr97 +mapbox_mercantile_pr101 +mapbox_mercantile_pr107 +mapbox_mercantile_pr111 +mapbox_mercantile_pr124 +mapbox_mercantile_pr128 +mapbox_mercantile_pr129 +mapbox_mercantile_pr130 +mapbox_mercantile_pr49 +mapbox_mercantile_pr51 +mapbox_mercantile_pr57 +mapbox_mercantile_pr60 +mapbox_mercantile_pr62 +mapbox_mercantile_pr65 +marcharper_python-ternary_pr145 +marcosschroh_dataclasses-avroschema_pr12 +marcosschroh_dataclasses-avroschema_pr16 +marcosschroh_dataclasses-avroschema_pr163 +marcosschroh_dataclasses-avroschema_pr170 +marcosschroh_dataclasses-avroschema_pr172 +marcosschroh_dataclasses-avroschema_pr176 +marcosschroh_dataclasses-avroschema_pr180 +marcosschroh_dataclasses-avroschema_pr181 +marcosschroh_dataclasses-avroschema_pr197 +marcosschroh_dataclasses-avroschema_pr2 +marcosschroh_dataclasses-avroschema_pr201 +marcosschroh_dataclasses-avroschema_pr205 +marcosschroh_dataclasses-avroschema_pr214 +marcosschroh_dataclasses-avroschema_pr215 +marcosschroh_dataclasses-avroschema_pr218 +marcosschroh_dataclasses-avroschema_pr227 +marcosschroh_dataclasses-avroschema_pr228 +marcosschroh_dataclasses-avroschema_pr230 +marcosschroh_dataclasses-avroschema_pr231 +marcosschroh_dataclasses-avroschema_pr235 +marcosschroh_dataclasses-avroschema_pr236 +marcosschroh_dataclasses-avroschema_pr237 +marcosschroh_dataclasses-avroschema_pr243 +marcosschroh_dataclasses-avroschema_pr244 +marcosschroh_dataclasses-avroschema_pr245 +marcosschroh_dataclasses-avroschema_pr247 +marcosschroh_dataclasses-avroschema_pr253 +marcosschroh_dataclasses-avroschema_pr255 +marcosschroh_dataclasses-avroschema_pr275 +marcosschroh_dataclasses-avroschema_pr282 +marcosschroh_dataclasses-avroschema_pr296 +marcosschroh_dataclasses-avroschema_pr3 +marcosschroh_dataclasses-avroschema_pr4 +marcosschroh_dataclasses-avroschema_pr481 +marcosschroh_dataclasses-avroschema_pr488 +marcosschroh_dataclasses-avroschema_pr5 +marcosschroh_dataclasses-avroschema_pr513 +marcosschroh_dataclasses-avroschema_pr528 +marcosschroh_dataclasses-avroschema_pr545 +marcosschroh_dataclasses-avroschema_pr569 +marcosschroh_dataclasses-avroschema_pr570 +marcosschroh_dataclasses-avroschema_pr571 +marcosschroh_dataclasses-avroschema_pr583 +marcosschroh_dataclasses-avroschema_pr599 +marcosschroh_dataclasses-avroschema_pr608 +marcosschroh_dataclasses-avroschema_pr63 +marcosschroh_dataclasses-avroschema_pr639 +marcosschroh_dataclasses-avroschema_pr643 +marcosschroh_dataclasses-avroschema_pr65 +marcosschroh_dataclasses-avroschema_pr654 +marcosschroh_dataclasses-avroschema_pr66 +marcosschroh_dataclasses-avroschema_pr68 +marcosschroh_dataclasses-avroschema_pr682 +marcosschroh_dataclasses-avroschema_pr690 +marcosschroh_dataclasses-avroschema_pr7 +marcosschroh_dataclasses-avroschema_pr723 +marcosschroh_dataclasses-avroschema_pr724 +marcosschroh_dataclasses-avroschema_pr744 +marcosschroh_dataclasses-avroschema_pr751 +marcosschroh_dataclasses-avroschema_pr770 +marcosschroh_dataclasses-avroschema_pr776 +marcosschroh_dataclasses-avroschema_pr777 +marcosschroh_dataclasses-avroschema_pr778 +marcosschroh_dataclasses-avroschema_pr780 +marcosschroh_dataclasses-avroschema_pr783 +marcosschroh_dataclasses-avroschema_pr795 +marcosschroh_dataclasses-avroschema_pr796 +marcosschroh_dataclasses-avroschema_pr810 +marcosschroh_dataclasses-avroschema_pr815 +marcosschroh_dataclasses-avroschema_pr817 +marcosschroh_dataclasses-avroschema_pr843 +marcosschroh_dataclasses-avroschema_pr853 +marcosschroh_dataclasses-avroschema_pr870 +marcosschroh_dataclasses-avroschema_pr891 +marcosschroh_dataclasses-avroschema_pr9 +marksparkza_jschon_pr47 +marksparkza_jschon_pr55 +marksparkza_jschon_pr80 +marshallward_f90nml_pr120 +marshallward_f90nml_pr123 +marshallward_f90nml_pr180 +marshallward_f90nml_pr70 +marshallward_f90nml_pr71 +marshmallow-code_marshmallow-oneofschema_pr111 +marshmallow-code_marshmallow-oneofschema_pr212 +marshmallow-code_marshmallow-oneofschema_pr5 +marshmallow-code_marshmallow-oneofschema_pr6 +martinblech_xmltodict_pr120 +martinblech_xmltodict_pr132 +martinblech_xmltodict_pr16 +martinblech_xmltodict_pr180 +martinblech_xmltodict_pr211 +martinblech_xmltodict_pr212 +martinblech_xmltodict_pr213 +martinblech_xmltodict_pr222 +martinblech_xmltodict_pr295 +martinblech_xmltodict_pr346 +martinblech_xmltodict_pr35 +martinblech_xmltodict_pr394 +martinblech_xmltodict_pr395 +martinblech_xmltodict_pr40 +martinblech_xmltodict_pr92 +masaccio_compact-json_pr11 +masaccio_compact-json_pr16 +masaccio_compact-json_pr22 +masaccio_compact-json_pr23 +masaccio_compact-json_pr6 +masaccio_compact-json_pr8 +masci_banks_pr11 +masci_banks_pr16 +masci_banks_pr20 +masci_banks_pr26 +masci_banks_pr30 +masci_banks_pr32 +masci_banks_pr33 +masci_banks_pr37 +masci_banks_pr38 +masci_banks_pr39 +masci_banks_pr41 +masci_banks_pr44 +masci_banks_pr47 +masci_banks_pr55 +masci_banks_pr57 +masci_banks_pr60 +masci_banks_pr8 +matan1008_pykdebugparser_pr10 +matan1008_pykdebugparser_pr12 +matan1008_pykdebugparser_pr17 +matan1008_pykdebugparser_pr5 +matan1008_pykdebugparser_pr6 +materialsproject_custodian_pr277 +materialsvirtuallab_monty_pr146 +materialsvirtuallab_monty_pr152 +materialsvirtuallab_monty_pr18 +materialsvirtuallab_monty_pr185 +materialsvirtuallab_monty_pr21 +materialsvirtuallab_monty_pr225 +materialsvirtuallab_monty_pr23 +materialsvirtuallab_monty_pr239 +materialsvirtuallab_monty_pr251 +materialsvirtuallab_monty_pr267 +materialsvirtuallab_monty_pr272 +materialsvirtuallab_monty_pr280 +materialsvirtuallab_monty_pr3 +materialsvirtuallab_monty_pr35 +materialsvirtuallab_monty_pr350 +materialsvirtuallab_monty_pr363 +materialsvirtuallab_monty_pr379 +materialsvirtuallab_monty_pr4 +materialsvirtuallab_monty_pr400 +materialsvirtuallab_monty_pr42 +materialsvirtuallab_monty_pr43 +materialsvirtuallab_monty_pr444 +materialsvirtuallab_monty_pr446 +materialsvirtuallab_monty_pr45 +materialsvirtuallab_monty_pr46 +materialsvirtuallab_monty_pr465 +materialsvirtuallab_monty_pr47 +materialsvirtuallab_monty_pr536 +materialsvirtuallab_monty_pr537 +materialsvirtuallab_monty_pr548 +materialsvirtuallab_monty_pr55 +materialsvirtuallab_monty_pr580 +materialsvirtuallab_monty_pr597 +materialsvirtuallab_monty_pr6 +materialsvirtuallab_monty_pr602 +materialsvirtuallab_monty_pr611 +materialsvirtuallab_monty_pr618 +materialsvirtuallab_monty_pr628 +materialsvirtuallab_monty_pr635 +materialsvirtuallab_monty_pr638 +materialsvirtuallab_monty_pr642 +materialsvirtuallab_monty_pr646 +materialsvirtuallab_monty_pr654 +materialsvirtuallab_monty_pr657 +materialsvirtuallab_monty_pr660 +materialsvirtuallab_monty_pr671 +materialsvirtuallab_monty_pr676 +materialsvirtuallab_monty_pr678 +materialsvirtuallab_monty_pr682 +materialsvirtuallab_monty_pr688 +materialsvirtuallab_monty_pr689 +materialsvirtuallab_monty_pr691 +materialsvirtuallab_monty_pr698 +materialsvirtuallab_monty_pr699 +materialsvirtuallab_monty_pr703 +materialsvirtuallab_monty_pr712 +materialsvirtuallab_monty_pr716 +materialsvirtuallab_monty_pr722 +materialsvirtuallab_monty_pr728 +materialsvirtuallab_monty_pr73 +materialsvirtuallab_monty_pr730 +materialsvirtuallab_monty_pr732 +materialsvirtuallab_monty_pr733 +materialsvirtuallab_monty_pr734 +materialsvirtuallab_monty_pr742 +materialsvirtuallab_monty_pr752 +materialsvirtuallab_monty_pr755 +materialsvirtuallab_monty_pr761 +matiasb_python-unidiff_pr100 +matiasb_python-unidiff_pr106 +matiasb_python-unidiff_pr11 +matiasb_python-unidiff_pr110 +matiasb_python-unidiff_pr28 +matiasb_python-unidiff_pr4 +matiasb_python-unidiff_pr45 +matiasb_python-unidiff_pr46 +matiasb_python-unidiff_pr5 +matiasb_python-unidiff_pr59 +matiasb_python-unidiff_pr66 +matiasb_python-unidiff_pr68 +matiasb_python-unidiff_pr70 +matiasb_python-unidiff_pr75 +matiasb_python-unidiff_pr79 +matiasb_python-unidiff_pr86 +matiasb_python-unidiff_pr90 +matiasb_python-unidiff_pr95 +matplotlib_cmocean_pr106 +matplotlib_cmocean_pr86 +matplotlib_cycler_pr100 +matplotlib_cycler_pr52 +matplotlib_cycler_pr72 +matrix-org_matrix-python-common_pr29 +matrix-org_matrix-python-sdk_pr101 +matrix-org_matrix-python-sdk_pr104 +matrix-org_matrix-python-sdk_pr105 +matrix-org_matrix-python-sdk_pr160 +matrix-org_matrix-python-sdk_pr162 +matrix-org_matrix-python-sdk_pr174 +matrix-org_matrix-python-sdk_pr212 +matrix-org_matrix-python-sdk_pr22 +matrix-org_matrix-python-sdk_pr229 +matrix-org_matrix-python-sdk_pr235 +matrix-org_matrix-python-sdk_pr249 +matrix-org_matrix-python-sdk_pr254 +matrix-org_matrix-python-sdk_pr260 +matrix-org_matrix-python-sdk_pr274 +matrix-org_matrix-python-sdk_pr28 +matrix-org_matrix-python-sdk_pr289 +matrix-org_matrix-python-sdk_pr321 +matrix-org_matrix-python-sdk_pr34 +matrix-org_matrix-python-sdk_pr39 +matrix-org_matrix-python-sdk_pr44 +matrix-org_matrix-python-sdk_pr53 +matrix-org_matrix-python-sdk_pr55 +matrix-org_matrix-python-sdk_pr58 +matrix-org_matrix-python-sdk_pr59 +matrix-org_matrix-python-sdk_pr62 +matrix-org_matrix-python-sdk_pr66 +matrix-org_matrix-python-sdk_pr77 +matrix-org_matrix-python-sdk_pr78 +matrix-org_matrix-python-sdk_pr81 +matrix-org_matrix-python-sdk_pr86 +matrix-org_matrix-python-sdk_pr89 +matrix-org_matrix-python-sdk_pr90 +matrix-org_matrix-python-sdk_pr95 +matrix-org_matrix-python-sdk_pr97 +matrix-org_matrix-python-sdk_pr98 +matrix-org_python-canonicaljson_pr34 +matrix-org_python-canonicaljson_pr49 +matrix-org_python-canonicaljson_pr9 +matthew-brett_delocate_pr167 +matthew-brett_delocate_pr183 +matthew-brett_delocate_pr186 +matthew-brett_delocate_pr187 +matthewdeanmartin_openmock_pr15 +matthewdeanmartin_openmock_pr23 +matthewdeanmartin_openmock_pr4 +matthewdeanmartin_openmock_pr7 +matthewwardrop_formulaic_pr100 +matthewwardrop_formulaic_pr101 +matthewwardrop_formulaic_pr103 +matthewwardrop_formulaic_pr11 +matthewwardrop_formulaic_pr110 +matthewwardrop_formulaic_pr111 +matthewwardrop_formulaic_pr113 +matthewwardrop_formulaic_pr117 +matthewwardrop_formulaic_pr123 +matthewwardrop_formulaic_pr139 +matthewwardrop_formulaic_pr141 +matthewwardrop_formulaic_pr145 +matthewwardrop_formulaic_pr147 +matthewwardrop_formulaic_pr15 +matthewwardrop_formulaic_pr154 +matthewwardrop_formulaic_pr155 +matthewwardrop_formulaic_pr16 +matthewwardrop_formulaic_pr166 +matthewwardrop_formulaic_pr167 +matthewwardrop_formulaic_pr197 +matthewwardrop_formulaic_pr200 +matthewwardrop_formulaic_pr201 +matthewwardrop_formulaic_pr203 +matthewwardrop_formulaic_pr204 +matthewwardrop_formulaic_pr205 +matthewwardrop_formulaic_pr207 +matthewwardrop_formulaic_pr208 +matthewwardrop_formulaic_pr209 +matthewwardrop_formulaic_pr21 +matthewwardrop_formulaic_pr214 +matthewwardrop_formulaic_pr216 +matthewwardrop_formulaic_pr218 +matthewwardrop_formulaic_pr22 +matthewwardrop_formulaic_pr220 +matthewwardrop_formulaic_pr221 +matthewwardrop_formulaic_pr222 +matthewwardrop_formulaic_pr223 +matthewwardrop_formulaic_pr225 +matthewwardrop_formulaic_pr234 +matthewwardrop_formulaic_pr236 +matthewwardrop_formulaic_pr27 +matthewwardrop_formulaic_pr41 +matthewwardrop_formulaic_pr43 +matthewwardrop_formulaic_pr44 +matthewwardrop_formulaic_pr6 +matthewwardrop_formulaic_pr63 +matthewwardrop_formulaic_pr70 +matthewwardrop_formulaic_pr72 +matthewwardrop_formulaic_pr83 +matthewwardrop_formulaic_pr86 +matthewwardrop_formulaic_pr99 +mattijn_topojson_pr100 +mattijn_topojson_pr105 +mattijn_topojson_pr107 +mattijn_topojson_pr108 +mattijn_topojson_pr112 +mattijn_topojson_pr114 +mattijn_topojson_pr128 +mattijn_topojson_pr129 +mattijn_topojson_pr130 +mattijn_topojson_pr139 +mattijn_topojson_pr141 +mattijn_topojson_pr150 +mattijn_topojson_pr154 +mattijn_topojson_pr157 +mattijn_topojson_pr158 +mattijn_topojson_pr165 +mattijn_topojson_pr166 +mattijn_topojson_pr168 +mattijn_topojson_pr175 +mattijn_topojson_pr179 +mattijn_topojson_pr182 +mattijn_topojson_pr185 +mattijn_topojson_pr192 +mattijn_topojson_pr196 +mattijn_topojson_pr202 +mattijn_topojson_pr204 +mattijn_topojson_pr210 +mattijn_topojson_pr211 +mattijn_topojson_pr228 +mattijn_topojson_pr23 +mattijn_topojson_pr25 +mattijn_topojson_pr26 +mattijn_topojson_pr31 +mattijn_topojson_pr32 +mattijn_topojson_pr33 +mattijn_topojson_pr34 +mattijn_topojson_pr35 +mattijn_topojson_pr36 +mattijn_topojson_pr38 +mattijn_topojson_pr42 +mattijn_topojson_pr43 +mattijn_topojson_pr51 +mattijn_topojson_pr52 +mattijn_topojson_pr71 +mattijn_topojson_pr72 +mattijn_topojson_pr78 +mattijn_topojson_pr80 +mattijn_topojson_pr83 +mattijn_topojson_pr86 +mattijn_topojson_pr87 +mattijn_topojson_pr92 +mattijn_topojson_pr93 +mattijn_topojson_pr95 +mattijn_topojson_pr97 +mattrobenolt_jinja2-cli_pr118 +mattrobenolt_jinja2-cli_pr28 +matyasrichter_fastapi-injector_pr25 +maurerle_eralchemy2_pr12 +maurerle_eralchemy2_pr20 +maurerle_eralchemy2_pr31 +maurerle_eralchemy2_pr34 +maurerle_eralchemy2_pr35 +maurerle_eralchemy2_pr40 +maxb2_typer-config_pr15 +maxb2_typer-config_pr17 +maxb2_typer-config_pr23 +maxb2_typer-config_pr6 +maxcountryman_flask-login_pr288 +maxcountryman_flask-login_pr291 +maxcountryman_flask-login_pr316 +maxcountryman_flask-login_pr330 +maxcountryman_flask-login_pr334 +maxcountryman_flask-login_pr359 +maxcountryman_flask-login_pr361 +maxcountryman_flask-login_pr370 +maxcountryman_flask-login_pr371 +maxcountryman_flask-login_pr378 +maxcountryman_flask-login_pr403 +maxcountryman_flask-login_pr410 +maxcountryman_flask-login_pr414 +maxcountryman_flask-login_pr464 +maxcountryman_flask-login_pr470 +maxcountryman_flask-login_pr472 +maxcountryman_flask-login_pr595 +maxfischer2781_asyncstdlib_pr100 +maxfischer2781_asyncstdlib_pr103 +maxfischer2781_asyncstdlib_pr108 +maxfischer2781_asyncstdlib_pr109 +maxfischer2781_asyncstdlib_pr115 +maxfischer2781_asyncstdlib_pr145 +maxfischer2781_asyncstdlib_pr150 +maxfischer2781_asyncstdlib_pr154 +maxfischer2781_asyncstdlib_pr16 +maxfischer2781_asyncstdlib_pr160 +maxfischer2781_asyncstdlib_pr171 +maxfischer2781_asyncstdlib_pr178 +maxfischer2781_asyncstdlib_pr19 +maxfischer2781_asyncstdlib_pr24 +maxfischer2781_asyncstdlib_pr25 +maxfischer2781_asyncstdlib_pr29 +maxfischer2781_asyncstdlib_pr34 +maxfischer2781_asyncstdlib_pr4 +maxfischer2781_asyncstdlib_pr44 +maxfischer2781_asyncstdlib_pr6 +maxfischer2781_asyncstdlib_pr60 +maxfischer2781_asyncstdlib_pr69 +maxfischer2781_asyncstdlib_pr72 +maxfischer2781_asyncstdlib_pr75 +maximkulkin_lollipop-jsonschema_pr11 +maximkulkin_lollipop-jsonschema_pr3 +maximtrp_scikit-posthocs_pr44 +maxpmaxp_pdfreader_pr13 +maxpmaxp_pdfreader_pr19 +maxpmaxp_pdfreader_pr24 +maxpmaxp_pdfreader_pr6 +maxpmaxp_pdfreader_pr7 +maxpmaxp_pdfreader_pr8 +mbr_tinyrpc_pr6 +mbr_tinyrpc_pr64 +mbr_tinyrpc_pr84 +mbr_tinyrpc_pr91 +mbr_tinyrpc_pr94 +mcu-tools_mcuboot_pr1007 +mcu-tools_mcuboot_pr1009 +mcu-tools_mcuboot_pr1015 +mcu-tools_mcuboot_pr1042 +mcu-tools_mcuboot_pr1053 +mcu-tools_mcuboot_pr1067 +mcu-tools_mcuboot_pr1071 +mcu-tools_mcuboot_pr1073 +mcu-tools_mcuboot_pr1080 +mcu-tools_mcuboot_pr1081 +mcu-tools_mcuboot_pr1101 +mcu-tools_mcuboot_pr1115 +mcu-tools_mcuboot_pr1137 +mcu-tools_mcuboot_pr1149 +mcu-tools_mcuboot_pr1155 +mcu-tools_mcuboot_pr1162 +mcu-tools_mcuboot_pr1163 +mcu-tools_mcuboot_pr1175 +mcu-tools_mcuboot_pr1184 +mcu-tools_mcuboot_pr1186 +mcu-tools_mcuboot_pr1190 +mcu-tools_mcuboot_pr1199 +mcu-tools_mcuboot_pr1206 +mcu-tools_mcuboot_pr1207 +mcu-tools_mcuboot_pr1208 +mcu-tools_mcuboot_pr1221 +mcu-tools_mcuboot_pr1222 +mcu-tools_mcuboot_pr1235 +mcu-tools_mcuboot_pr1237 +mcu-tools_mcuboot_pr1246 +mcu-tools_mcuboot_pr1249 +mcu-tools_mcuboot_pr1252 +mcu-tools_mcuboot_pr1254 +mcu-tools_mcuboot_pr1255 +mcu-tools_mcuboot_pr1261 +mcu-tools_mcuboot_pr1280 +mcu-tools_mcuboot_pr1284 +mcu-tools_mcuboot_pr1289 +mcu-tools_mcuboot_pr1298 +mcu-tools_mcuboot_pr1299 +mcu-tools_mcuboot_pr1311 +mcu-tools_mcuboot_pr1322 +mcu-tools_mcuboot_pr1325 +mcu-tools_mcuboot_pr1326 +mcu-tools_mcuboot_pr1327 +mcu-tools_mcuboot_pr1329 +mcu-tools_mcuboot_pr1333 +mcu-tools_mcuboot_pr1335 +mcu-tools_mcuboot_pr1336 +mcu-tools_mcuboot_pr1341 +mcu-tools_mcuboot_pr1346 +mcu-tools_mcuboot_pr1349 +mcu-tools_mcuboot_pr1352 +mcu-tools_mcuboot_pr1359 +mcu-tools_mcuboot_pr1362 +mcu-tools_mcuboot_pr1363 +mcu-tools_mcuboot_pr1379 +mcu-tools_mcuboot_pr1382 +mcu-tools_mcuboot_pr1388 +mcu-tools_mcuboot_pr1412 +mcu-tools_mcuboot_pr1416 +mcu-tools_mcuboot_pr1419 +mcu-tools_mcuboot_pr1424 +mcu-tools_mcuboot_pr1431 +mcu-tools_mcuboot_pr1434 +mcu-tools_mcuboot_pr1435 +mcu-tools_mcuboot_pr1451 +mcu-tools_mcuboot_pr1455 +mcu-tools_mcuboot_pr1458 +mcu-tools_mcuboot_pr1461 +mcu-tools_mcuboot_pr1483 +mcu-tools_mcuboot_pr1484 +mcu-tools_mcuboot_pr1505 +mcu-tools_mcuboot_pr1507 +mcu-tools_mcuboot_pr1509 +mcu-tools_mcuboot_pr1522 +mcu-tools_mcuboot_pr1533 +mcu-tools_mcuboot_pr1536 +mcu-tools_mcuboot_pr1546 +mcu-tools_mcuboot_pr1564 +mcu-tools_mcuboot_pr1570 +mcu-tools_mcuboot_pr1571 +mcu-tools_mcuboot_pr1589 +mcu-tools_mcuboot_pr1597 +mcu-tools_mcuboot_pr1600 +mcu-tools_mcuboot_pr1601 +mcu-tools_mcuboot_pr1610 +mcu-tools_mcuboot_pr1614 +mcu-tools_mcuboot_pr1626 +mcu-tools_mcuboot_pr1629 +mcu-tools_mcuboot_pr1633 +mcu-tools_mcuboot_pr1636 +mcu-tools_mcuboot_pr1640 +mcu-tools_mcuboot_pr1644 +mcu-tools_mcuboot_pr1649 +mcu-tools_mcuboot_pr1651 +mcu-tools_mcuboot_pr1682 +mcu-tools_mcuboot_pr1684 +mcu-tools_mcuboot_pr1751 +mcu-tools_mcuboot_pr1756 +mcu-tools_mcuboot_pr1763 +mcu-tools_mcuboot_pr195 +mcu-tools_mcuboot_pr197 +mcu-tools_mcuboot_pr244 +mcu-tools_mcuboot_pr251 +mcu-tools_mcuboot_pr254 +mcu-tools_mcuboot_pr259 +mcu-tools_mcuboot_pr275 +mcu-tools_mcuboot_pr281 +mcu-tools_mcuboot_pr293 +mcu-tools_mcuboot_pr300 +mcu-tools_mcuboot_pr301 +mcu-tools_mcuboot_pr311 +mcu-tools_mcuboot_pr315 +mcu-tools_mcuboot_pr322 +mcu-tools_mcuboot_pr323 +mcu-tools_mcuboot_pr327 +mcu-tools_mcuboot_pr345 +mcu-tools_mcuboot_pr359 +mcu-tools_mcuboot_pr360 +mcu-tools_mcuboot_pr377 +mcu-tools_mcuboot_pr381 +mcu-tools_mcuboot_pr404 +mcu-tools_mcuboot_pr405 +mcu-tools_mcuboot_pr407 +mcu-tools_mcuboot_pr414 +mcu-tools_mcuboot_pr425 +mcu-tools_mcuboot_pr437 +mcu-tools_mcuboot_pr440 +mcu-tools_mcuboot_pr443 +mcu-tools_mcuboot_pr460 +mcu-tools_mcuboot_pr467 +mcu-tools_mcuboot_pr475 +mcu-tools_mcuboot_pr514 +mcu-tools_mcuboot_pr517 +mcu-tools_mcuboot_pr524 +mcu-tools_mcuboot_pr532 +mcu-tools_mcuboot_pr540 +mcu-tools_mcuboot_pr554 +mcu-tools_mcuboot_pr585 +mcu-tools_mcuboot_pr589 +mcu-tools_mcuboot_pr592 +mcu-tools_mcuboot_pr593 +mcu-tools_mcuboot_pr604 +mcu-tools_mcuboot_pr608 +mcu-tools_mcuboot_pr610 +mcu-tools_mcuboot_pr613 +mcu-tools_mcuboot_pr617 +mcu-tools_mcuboot_pr704 +mcu-tools_mcuboot_pr718 +mcu-tools_mcuboot_pr719 +mcu-tools_mcuboot_pr729 +mcu-tools_mcuboot_pr734 +mcu-tools_mcuboot_pr741 +mcu-tools_mcuboot_pr744 +mcu-tools_mcuboot_pr749 +mcu-tools_mcuboot_pr757 +mcu-tools_mcuboot_pr760 +mcu-tools_mcuboot_pr764 +mcu-tools_mcuboot_pr767 +mcu-tools_mcuboot_pr776 +mcu-tools_mcuboot_pr780 +mcu-tools_mcuboot_pr781 +mcu-tools_mcuboot_pr784 +mcu-tools_mcuboot_pr787 +mcu-tools_mcuboot_pr818 +mcu-tools_mcuboot_pr825 +mcu-tools_mcuboot_pr840 +mcu-tools_mcuboot_pr854 +mcu-tools_mcuboot_pr865 +mcu-tools_mcuboot_pr882 +mcu-tools_mcuboot_pr884 +mcu-tools_mcuboot_pr894 +mcu-tools_mcuboot_pr899 +mcu-tools_mcuboot_pr901 +mcu-tools_mcuboot_pr904 +mcu-tools_mcuboot_pr910 +mcu-tools_mcuboot_pr931 +mcu-tools_mcuboot_pr935 +mcu-tools_mcuboot_pr939 +mcu-tools_mcuboot_pr947 +mdapena_pyventus_pr9 +mdomke_schwifty_pr136 +mdomke_schwifty_pr154 +mdomke_schwifty_pr162 +mdomke_schwifty_pr165 +mdomke_schwifty_pr166 +mdomke_schwifty_pr191 +mdomke_schwifty_pr195 +mdomke_schwifty_pr201 +mdomke_schwifty_pr209 +mdomke_schwifty_pr218 +mdomke_schwifty_pr252 +mdomke_schwifty_pr26 +mdomke_schwifty_pr40 +mdomke_schwifty_pr44 +mdomke_schwifty_pr45 +mdomke_schwifty_pr47 +mdomke_schwifty_pr50 +mdomke_schwifty_pr51 +mdomke_schwifty_pr60 +mdomke_schwifty_pr80 +mdomke_schwifty_pr85 +mdowds_mock-firestore_pr11 +mdowds_mock-firestore_pr13 +mdowds_mock-firestore_pr14 +mdowds_mock-firestore_pr19 +mdowds_mock-firestore_pr23 +mdowds_mock-firestore_pr30 +mdowds_mock-firestore_pr32 +mdowds_mock-firestore_pr34 +mdowds_mock-firestore_pr36 +mdowds_mock-firestore_pr37 +mdowds_mock-firestore_pr44 +mdowds_mock-firestore_pr49 +mdowds_mock-firestore_pr56 +mdowds_mock-firestore_pr6 +meadsteve_lagom_pr100 +meadsteve_lagom_pr111 +meadsteve_lagom_pr113 +meadsteve_lagom_pr115 +meadsteve_lagom_pr127 +meadsteve_lagom_pr132 +meadsteve_lagom_pr136 +meadsteve_lagom_pr148 +meadsteve_lagom_pr152 +meadsteve_lagom_pr162 +meadsteve_lagom_pr167 +meadsteve_lagom_pr170 +meadsteve_lagom_pr177 +meadsteve_lagom_pr181 +meadsteve_lagom_pr196 +meadsteve_lagom_pr20 +meadsteve_lagom_pr211 +meadsteve_lagom_pr23 +meadsteve_lagom_pr231 +meadsteve_lagom_pr235 +meadsteve_lagom_pr244 +meadsteve_lagom_pr266 +meadsteve_lagom_pr267 +meadsteve_lagom_pr269 +meadsteve_lagom_pr33 +meadsteve_lagom_pr34 +meadsteve_lagom_pr37 +meadsteve_lagom_pr6 +meadsteve_lagom_pr83 +meadsteve_lagom_pr88 +meadsteve_lagom_pr90 +meadsteve_lagom_pr92 +medialab_ipysigma_pr199 +mediawiki-utilities_python-mwxml_pr13 +meeb_whoisit_pr18 +meeb_whoisit_pr2 +meeb_whoisit_pr33 +meeb_whoisit_pr38 +meeb_whoisit_pr6 +meeb_whoisit_pr7 +meeb_whoisit_pr8 +meerk40t_svgelements_pr100 +meerk40t_svgelements_pr106 +meerk40t_svgelements_pr108 +meerk40t_svgelements_pr110 +meerk40t_svgelements_pr113 +meerk40t_svgelements_pr117 +meerk40t_svgelements_pr123 +meerk40t_svgelements_pr131 +meerk40t_svgelements_pr132 +meerk40t_svgelements_pr134 +meerk40t_svgelements_pr151 +meerk40t_svgelements_pr158 +meerk40t_svgelements_pr160 +meerk40t_svgelements_pr165 +meerk40t_svgelements_pr166 +meerk40t_svgelements_pr168 +meerk40t_svgelements_pr176 +meerk40t_svgelements_pr183 +meerk40t_svgelements_pr184 +meerk40t_svgelements_pr187 +meerk40t_svgelements_pr189 +meerk40t_svgelements_pr193 +meerk40t_svgelements_pr195 +meerk40t_svgelements_pr198 +meerk40t_svgelements_pr209 +meerk40t_svgelements_pr216 +meerk40t_svgelements_pr218 +meerk40t_svgelements_pr22 +meerk40t_svgelements_pr221 +meerk40t_svgelements_pr229 +meerk40t_svgelements_pr230 +meerk40t_svgelements_pr231 +meerk40t_svgelements_pr233 +meerk40t_svgelements_pr240 +meerk40t_svgelements_pr26 +meerk40t_svgelements_pr28 +meerk40t_svgelements_pr29 +meerk40t_svgelements_pr30 +meerk40t_svgelements_pr42 +meerk40t_svgelements_pr46 +meerk40t_svgelements_pr48 +meerk40t_svgelements_pr61 +meerk40t_svgelements_pr69 +meerk40t_svgelements_pr71 +meerk40t_svgelements_pr88 +meerk40t_svgelements_pr93 +meerk40t_svgelements_pr96 +meerk40t_svgelements_pr98 +megalus_django-google-sso_pr25 +megalus_django-google-sso_pr32 +megalus_django-google-sso_pr53 +megvii-research_megfile_pr350 +megvii-research_megfile_pr352 +megvii-research_megfile_pr353 +megvii-research_megfile_pr359 +megvii-research_megfile_pr361 +megvii-research_megfile_pr367 +megvii-research_megfile_pr370 +megvii-research_megfile_pr371 +megvii-research_megfile_pr377 +megvii-research_megfile_pr378 +megvii-research_megfile_pr379 +megvii-research_megfile_pr381 +megvii-research_megfile_pr383 +megvii-research_megfile_pr400 +megvii-research_megfile_pr406 +megvii-research_megfile_pr407 +megvii-research_megfile_pr416 +megvii-research_megfile_pr420 +megvii-research_megfile_pr423 +megvii-research_megfile_pr426 +megvii-research_megfile_pr432 +megvii-research_megfile_pr442 +megvii-research_megfile_pr444 +megvii-research_megfile_pr446 +megvii-research_megfile_pr447 +megvii-research_megfile_pr449 +megvii-research_megfile_pr451 +megvii-research_megfile_pr453 +megvii-research_megfile_pr458 +megvii-research_megfile_pr464 +megvii-research_megfile_pr466 +megvii-research_megfile_pr471 +megvii-research_megfile_pr472 +megvii-research_megfile_pr474 +megvii-research_megfile_pr475 +megvii-research_megfile_pr491 +megvii-research_megfile_pr501 +megvii-research_megfile_pr504 +megvii-research_megfile_pr507 +megvii-research_megfile_pr509 +megvii-research_megfile_pr516 +megvii-research_megfile_pr519 +megvii-research_megfile_pr522 +megvii-research_megfile_pr523 +megvii-research_megfile_pr531 +megvii-research_megfile_pr536 +megvii-research_megfile_pr538 +megvii-research_megfile_pr539 +megvii-research_megfile_pr543 +megvii-research_megfile_pr544 +megvii-research_megfile_pr548 +megvii-research_megfile_pr552 +megvii-research_megfile_pr558 +mehcode_python-xmlsec_pr100 +mehcode_python-xmlsec_pr132 +mehcode_python-xmlsec_pr148 +mehcode_python-xmlsec_pr212 +mehcode_python-xmlsec_pr291 +mehcode_python-xmlsec_pr293 +mehcode_python-xmlsec_pr303 +mehcode_python-xmlsec_pr304 +mehcode_python-xmlsec_pr306 +mehcode_python-xmlsec_pr313 +mehcode_python-xmlsec_pr353 +mehcode_python-xmlsec_pr354 +mehcode_python-xmlsec_pr67 +mehcode_python-xmlsec_pr68 +mehcode_python-xmlsec_pr69 +meltano_sdk_pr2526 +meltano_sdk_pr2603 +mercedes-benz_odxtools_pr10 +mercedes-benz_odxtools_pr104 +mercedes-benz_odxtools_pr108 +mercedes-benz_odxtools_pr109 +mercedes-benz_odxtools_pr111 +mercedes-benz_odxtools_pr113 +mercedes-benz_odxtools_pr116 +mercedes-benz_odxtools_pr117 +mercedes-benz_odxtools_pr118 +mercedes-benz_odxtools_pr126 +mercedes-benz_odxtools_pr13 +mercedes-benz_odxtools_pr131 +mercedes-benz_odxtools_pr133 +mercedes-benz_odxtools_pr134 +mercedes-benz_odxtools_pr135 +mercedes-benz_odxtools_pr136 +mercedes-benz_odxtools_pr14 +mercedes-benz_odxtools_pr141 +mercedes-benz_odxtools_pr145 +mercedes-benz_odxtools_pr147 +mercedes-benz_odxtools_pr148 +mercedes-benz_odxtools_pr159 +mercedes-benz_odxtools_pr161 +mercedes-benz_odxtools_pr162 +mercedes-benz_odxtools_pr163 +mercedes-benz_odxtools_pr164 +mercedes-benz_odxtools_pr165 +mercedes-benz_odxtools_pr168 +mercedes-benz_odxtools_pr17 +mercedes-benz_odxtools_pr170 +mercedes-benz_odxtools_pr171 +mercedes-benz_odxtools_pr173 +mercedes-benz_odxtools_pr176 +mercedes-benz_odxtools_pr177 +mercedes-benz_odxtools_pr19 +mercedes-benz_odxtools_pr21 +mercedes-benz_odxtools_pr22 +mercedes-benz_odxtools_pr28 +mercedes-benz_odxtools_pr30 +mercedes-benz_odxtools_pr38 +mercedes-benz_odxtools_pr44 +mercedes-benz_odxtools_pr45 +mercedes-benz_odxtools_pr50 +mercedes-benz_odxtools_pr52 +mercedes-benz_odxtools_pr54 +mercedes-benz_odxtools_pr55 +mercedes-benz_odxtools_pr59 +mercedes-benz_odxtools_pr64 +mercedes-benz_odxtools_pr65 +mercedes-benz_odxtools_pr66 +mercedes-benz_odxtools_pr68 +mercedes-benz_odxtools_pr71 +mercedes-benz_odxtools_pr77 +mercedes-benz_odxtools_pr78 +mercedes-benz_odxtools_pr79 +mercedes-benz_odxtools_pr8 +mercedes-benz_odxtools_pr86 +mercedes-benz_odxtools_pr87 +mercedes-benz_odxtools_pr90 +mercedes-benz_odxtools_pr93 +mercedes-benz_odxtools_pr94 +mesonbuild_meson-python_pr110 +mesonbuild_meson-python_pr126 +mesonbuild_meson-python_pr130 +mesonbuild_meson-python_pr134 +mesonbuild_meson-python_pr143 +mesonbuild_meson-python_pr144 +mesonbuild_meson-python_pr145 +mesonbuild_meson-python_pr161 +mesonbuild_meson-python_pr163 +mesonbuild_meson-python_pr167 +mesonbuild_meson-python_pr175 +mesonbuild_meson-python_pr177 +mesonbuild_meson-python_pr185 +mesonbuild_meson-python_pr209 +mesonbuild_meson-python_pr21 +mesonbuild_meson-python_pr214 +mesonbuild_meson-python_pr215 +mesonbuild_meson-python_pr219 +mesonbuild_meson-python_pr22 +mesonbuild_meson-python_pr227 +mesonbuild_meson-python_pr231 +mesonbuild_meson-python_pr241 +mesonbuild_meson-python_pr251 +mesonbuild_meson-python_pr255 +mesonbuild_meson-python_pr288 +mesonbuild_meson-python_pr304 +mesonbuild_meson-python_pr336 +mesonbuild_meson-python_pr345 +mesonbuild_meson-python_pr364 +mesonbuild_meson-python_pr377 +mesonbuild_meson-python_pr407 +mesonbuild_meson-python_pr455 +mesonbuild_meson-python_pr467 +mesonbuild_meson-python_pr472 +mesonbuild_meson-python_pr483 +mesonbuild_meson-python_pr486 +mesonbuild_meson-python_pr489 +mesonbuild_meson-python_pr491 +mesonbuild_meson-python_pr494 +mesonbuild_meson-python_pr520 +mesonbuild_meson-python_pr569 +mesonbuild_meson-python_pr594 +mesonbuild_meson-python_pr613 +mesonbuild_meson-python_pr626 +mesonbuild_meson-python_pr627 +mesonbuild_meson-python_pr631 +mesonbuild_meson-python_pr665 +mesonbuild_meson-python_pr702 +mesonbuild_meson-python_pr71 +mesonbuild_meson-python_pr72 +mesonbuild_meson-python_pr731 +mesonbuild_meson-python_pr745 +mesonbuild_meson-python_pr96 +meteostat_meteostat-python_pr207 +meteostat_meteostat-python_pr51 +meteostat_meteostat-python_pr66 +mewwts_addict_pr102 +mewwts_addict_pr128 +mewwts_addict_pr18 +mewwts_addict_pr30 +mewwts_addict_pr35 +mewwts_addict_pr71 +mewwts_addict_pr76 +mfogel_django-timezone-field_pr123 +mfogel_django-timezone-field_pr137 +mgeier_sphinx-last-updated-by-git_pr23 +mgeier_sphinx-last-updated-by-git_pr25 +mhe_pynrrd_pr125 +mhe_pynrrd_pr128 +mhe_pynrrd_pr165 +mhe_pynrrd_pr32 +mhe_pynrrd_pr35 +mhe_pynrrd_pr38 +mhe_pynrrd_pr40 +mhe_pynrrd_pr47 +mhe_pynrrd_pr54 +mhe_pynrrd_pr57 +mhe_pynrrd_pr59 +mhe_pynrrd_pr65 +mhe_pynrrd_pr68 +mhe_pynrrd_pr69 +mhe_pynrrd_pr74 +mhe_pynrrd_pr77 +mhe_pynrrd_pr79 +mhe_pynrrd_pr80 +mhe_pynrrd_pr85 +mhe_pynrrd_pr90 +mhostetter_galois_pr101 +mhostetter_galois_pr105 +mhostetter_galois_pr108 +mhostetter_galois_pr109 +mhostetter_galois_pr114 +mhostetter_galois_pr115 +mhostetter_galois_pr129 +mhostetter_galois_pr132 +mhostetter_galois_pr63 +mhostetter_galois_pr92 +mhostetter_galois_pr94 +mhostetter_galois_pr99 +microsoft_fabric-cicd_pr108 +microsoft_fabric-cicd_pr109 +microsoft_fabric-cicd_pr119 +microsoft_fabric-cicd_pr139 +microsoft_fabric-cicd_pr161 +microsoft_fabric-cicd_pr181 +microsoft_fabric-cicd_pr188 +microsoft_fabric-cicd_pr195 +microsoft_fabric-cicd_pr196 +microsoft_fabric-cicd_pr197 +microsoft_fabric-cicd_pr208 +microsoft_fabric-cicd_pr210 +microsoft_fabric-cicd_pr219 +microsoft_fabric-cicd_pr225 +microsoft_fabric-cicd_pr243 +microsoft_fabric-cicd_pr247 +microsoft_fabric-cicd_pr256 +microsoft_fabric-cicd_pr258 +microsoft_fabric-cicd_pr262 +microsoft_fabric-cicd_pr268 +microsoft_fabric-cicd_pr275 +microsoft_fabric-cicd_pr280 +microsoft_fabric-cicd_pr296 +microsoft_fabric-cicd_pr308 +microsoft_fabric-cicd_pr312 +microsoft_fabric-cicd_pr316 +microsoft_fabric-cicd_pr353 +microsoft_fabric-cicd_pr386 +microsoft_fabric-cicd_pr394 +microsoft_fabric-cicd_pr395 +microsoft_fabric-cicd_pr401 +microsoft_fabric-cicd_pr413 +microsoft_fabric-cicd_pr424 +microsoft_fabric-cicd_pr426 +microsoft_fabric-cicd_pr430 +microsoft_fabric-cicd_pr435 +microsoft_fabric-cicd_pr443 +microsoft_fabric-cicd_pr451 +microsoft_fabric-cicd_pr465 +microsoft_fabric-cicd_pr478 +microsoft_fabric-cicd_pr483 +microsoft_fabric-cicd_pr500 +microsoft_fabric-cicd_pr505 +microsoft_fabric-cicd_pr510 +microsoft_fabric-cicd_pr521 +microsoft_fabric-cicd_pr527 +microsoft_fabric-cicd_pr530 +microsoft_fabric-cicd_pr532 +microsoft_fabric-cicd_pr546 +microsoft_fabric-cicd_pr550 +microsoft_fabric-cicd_pr570 +microsoft_fabric-cicd_pr571 +microsoft_fabric-cicd_pr578 +microsoft_fabric-cicd_pr589 +microsoft_fabric-cicd_pr603 +microsoft_fabric-cicd_pr613 +microsoft_fabric-cicd_pr621 +microsoft_fabric-cicd_pr632 +microsoft_fabric-cicd_pr93 +microsoft_fabric-cicd_pr97 +microsoft_knack_pr108 +microsoft_knack_pr111 +microsoft_knack_pr115 +microsoft_knack_pr124 +microsoft_knack_pr125 +microsoft_knack_pr145 +microsoft_knack_pr146 +microsoft_knack_pr148 +microsoft_knack_pr153 +microsoft_knack_pr159 +microsoft_knack_pr161 +microsoft_knack_pr167 +microsoft_knack_pr176 +microsoft_knack_pr177 +microsoft_knack_pr181 +microsoft_knack_pr199 +microsoft_knack_pr201 +microsoft_knack_pr209 +microsoft_knack_pr213 +microsoft_knack_pr216 +microsoft_knack_pr217 +microsoft_knack_pr220 +microsoft_knack_pr221 +microsoft_knack_pr223 +microsoft_knack_pr227 +microsoft_knack_pr88 +microsoft_knack_pr96 +microsoft_lsprotocol_pr106 +microsoft_lsprotocol_pr107 +microsoft_lsprotocol_pr118 +microsoft_lsprotocol_pr121 +microsoft_lsprotocol_pr135 +microsoft_lsprotocol_pr146 +microsoft_lsprotocol_pr165 +microsoft_lsprotocol_pr166 +microsoft_lsprotocol_pr185 +microsoft_lsprotocol_pr211 +microsoft_lsprotocol_pr213 +microsoft_lsprotocol_pr219 +microsoft_lsprotocol_pr222 +microsoft_lsprotocol_pr224 +microsoft_lsprotocol_pr226 +microsoft_lsprotocol_pr229 +microsoft_lsprotocol_pr230 +microsoft_lsprotocol_pr239 +microsoft_lsprotocol_pr260 +microsoft_lsprotocol_pr271 +microsoft_lsprotocol_pr273 +microsoft_lsprotocol_pr275 +microsoft_lsprotocol_pr285 +microsoft_lsprotocol_pr286 +microsoft_lsprotocol_pr311 +microsoft_lsprotocol_pr328 +microsoft_lsprotocol_pr359 +microsoft_lsprotocol_pr368 +microsoft_lsprotocol_pr401 +microsoft_lsprotocol_pr415 +microsoft_lsprotocol_pr416 +microsoft_lsprotocol_pr433 +microsoft_lsprotocol_pr59 +microsoft_lsprotocol_pr70 +microsoft_lsprotocol_pr75 +microsoft_lsprotocol_pr87 +microsoft_lsprotocol_pr88 +microsoft_lsprotocol_pr98 +microsoft_sarif-tools_pr15 +microsoft_sarif-tools_pr16 +microsoft_sarif-tools_pr23 +microsoft_sarif-tools_pr24 +microsoft_sarif-tools_pr34 +microsoft_sarif-tools_pr52 +microsoft_sarif-tools_pr59 +microsoft_sarif-tools_pr62 +microsoft_sarif-tools_pr69 +microsoft_sarif-tools_pr70 +microsoft_sarif-tools_pr74 +microsoft_sarif-tools_pr81 +microsoftgraph_msgraph-sdk-python-core_pr626 +microsoftgraph_msgraph-sdk-python-core_pr689 +microsoftgraph_msgraph-sdk-python-core_pr773 +microsoftgraph_msgraph-sdk-python-core_pr804 +microsoftgraph_msgraph-sdk-python-core_pr821 +microsoftgraph_msgraph-sdk-python-core_pr848 +mido_mido_pr117 +mido_mido_pr161 +mido_mido_pr201 +mido_mido_pr202 +mido_mido_pr255 +mido_mido_pr264 +mido_mido_pr281 +mido_mido_pr299 +mido_mido_pr408 +mido_mido_pr449 +mido_mido_pr454 +mido_mido_pr455 +mido_mido_pr465 +mido_mido_pr470 +mido_mido_pr474 +mido_mido_pr565 +mido_mido_pr571 +mido_mido_pr624 +midstar_pycstruct_pr18 +midstar_pycstruct_pr24 +midstar_pycstruct_pr28 +midstar_pycstruct_pr41 +miguelgrinberg_flask-httpauth_pr126 +miguelgrinberg_flask-httpauth_pr74 +miguelgrinberg_flask-migrate_pr523 +miguelgrinberg_python-engineio_pr108 +miguelgrinberg_python-engineio_pr175 +miguelgrinberg_python-engineio_pr286 +miketheman_pytest-socket_pr227 +mill1000_midea-msmart_pr117 +mill1000_midea-msmart_pr132 +mill1000_midea-msmart_pr144 +mill1000_midea-msmart_pr157 +mill1000_midea-msmart_pr163 +mill1000_midea-msmart_pr165 +mill1000_midea-msmart_pr169 +mill1000_midea-msmart_pr172 +mill1000_midea-msmart_pr185 +mill1000_midea-msmart_pr187 +mill1000_midea-msmart_pr188 +mill1000_midea-msmart_pr228 +mill1000_midea-msmart_pr230 +mill1000_midea-msmart_pr240 +mindee_mindee-api-python_pr100 +mindee_mindee-api-python_pr45 +mindee_mindee-api-python_pr48 +mindee_mindee-api-python_pr49 +mindee_mindee-api-python_pr57 +mindee_mindee-api-python_pr61 +mindee_mindee-api-python_pr63 +mindee_mindee-api-python_pr67 +mindee_mindee-api-python_pr69 +mindee_mindee-api-python_pr70 +mindee_mindee-api-python_pr72 +mindee_mindee-api-python_pr88 +mindee_mindee-api-python_pr93 +mindee_mindee-api-python_pr97 +mindee_mindee-api-python_pr98 +mindee_mindee-api-python_pr99 +mirumee_ariadne-codegen_pr106 +mirumee_ariadne-codegen_pr109 +mirumee_ariadne-codegen_pr110 +mirumee_ariadne-codegen_pr112 +mirumee_ariadne-codegen_pr116 +mirumee_ariadne-codegen_pr126 +mirumee_ariadne-codegen_pr128 +mirumee_ariadne-codegen_pr129 +mirumee_ariadne-codegen_pr133 +mirumee_ariadne-codegen_pr143 +mirumee_ariadne-codegen_pr147 +mirumee_ariadne-codegen_pr148 +mirumee_ariadne-codegen_pr154 +mirumee_ariadne-codegen_pr158 +mirumee_ariadne-codegen_pr159 +mirumee_ariadne-codegen_pr164 +mirumee_ariadne-codegen_pr166 +mirumee_ariadne-codegen_pr169 +mirumee_ariadne-codegen_pr188 +mirumee_ariadne-codegen_pr189 +mirumee_ariadne-codegen_pr195 +mirumee_ariadne-codegen_pr196 +mirumee_ariadne-codegen_pr203 +mirumee_ariadne-codegen_pr205 +mirumee_ariadne-codegen_pr206 +mirumee_ariadne-codegen_pr207 +mirumee_ariadne-codegen_pr218 +mirumee_ariadne-codegen_pr221 +mirumee_ariadne-codegen_pr222 +mirumee_ariadne-codegen_pr224 +mirumee_ariadne-codegen_pr227 +mirumee_ariadne-codegen_pr229 +mirumee_ariadne-codegen_pr232 +mirumee_ariadne-codegen_pr242 +mirumee_ariadne-codegen_pr243 +mirumee_ariadne-codegen_pr244 +mirumee_ariadne-codegen_pr245 +mirumee_ariadne-codegen_pr246 +mirumee_ariadne-codegen_pr248 +mirumee_ariadne-codegen_pr255 +mirumee_ariadne-codegen_pr264 +mirumee_ariadne-codegen_pr267 +mirumee_ariadne-codegen_pr278 +mirumee_ariadne-codegen_pr281 +mirumee_ariadne-codegen_pr292 +mirumee_ariadne-codegen_pr304 +mirumee_ariadne-codegen_pr307 +mirumee_ariadne-codegen_pr35 +mirumee_ariadne-codegen_pr357 +mirumee_ariadne-codegen_pr36 +mirumee_ariadne-codegen_pr362 +mirumee_ariadne-codegen_pr363 +mirumee_ariadne-codegen_pr369 +mirumee_ariadne-codegen_pr379 +mirumee_ariadne-codegen_pr38 +mirumee_ariadne-codegen_pr380 +mirumee_ariadne-codegen_pr381 +mirumee_ariadne-codegen_pr39 +mirumee_ariadne-codegen_pr47 +mirumee_ariadne-codegen_pr48 +mirumee_ariadne-codegen_pr50 +mirumee_ariadne-codegen_pr52 +mirumee_ariadne-codegen_pr53 +mirumee_ariadne-codegen_pr54 +mirumee_ariadne-codegen_pr55 +mirumee_ariadne-codegen_pr56 +mirumee_ariadne-codegen_pr58 +mirumee_ariadne-codegen_pr8 +mirumee_google-i18n-address_pr35 +miso-belica_sumy_pr169 +miso-belica_sumy_pr189 +miso-belica_sumy_pr203 +mit-ll-responsible-ai_hydra-zen_pr104 +mit-ll-responsible-ai_hydra-zen_pr110 +mit-ll-responsible-ai_hydra-zen_pr112 +mit-ll-responsible-ai_hydra-zen_pr116 +mit-ll-responsible-ai_hydra-zen_pr118 +mit-ll-responsible-ai_hydra-zen_pr119 +mit-ll-responsible-ai_hydra-zen_pr122 +mit-ll-responsible-ai_hydra-zen_pr125 +mit-ll-responsible-ai_hydra-zen_pr131 +mit-ll-responsible-ai_hydra-zen_pr134 +mit-ll-responsible-ai_hydra-zen_pr156 +mit-ll-responsible-ai_hydra-zen_pr162 +mit-ll-responsible-ai_hydra-zen_pr172 +mit-ll-responsible-ai_hydra-zen_pr177 +mit-ll-responsible-ai_hydra-zen_pr55 +mit-ll-responsible-ai_hydra-zen_pr57 +mit-ll-responsible-ai_hydra-zen_pr60 +mit-ll-responsible-ai_hydra-zen_pr83 +mit-ll-responsible-ai_hydra-zen_pr84 +mit-ll-responsible-ai_hydra-zen_pr87 +mit-ll-responsible-ai_hydra-zen_pr90 +mivek_python-metar-taf-parser_pr17 +mivek_python-metar-taf-parser_pr18 +mivek_python-metar-taf-parser_pr49 +mivek_python-metar-taf-parser_pr5 +mivek_python-metar-taf-parser_pr51 +mivek_python-metar-taf-parser_pr57 +mivek_python-metar-taf-parser_pr7 +mivek_python-metar-taf-parser_pr73 +miyakogi_m2r_pr16 +mkdocs_mkdocs-click_pr25 +mkdocs_mkdocs-click_pr29 +mkdocs_mkdocs-click_pr36 +mkdocs_mkdocs-click_pr45 +mkdocs_mkdocs-click_pr52 +mkdocs_mkdocs-click_pr60 +mkdocs_mkdocs-click_pr79 +mkdocs_mkdocs-click_pr82 +mkdocs_mkdocs-click_pr84 +mkdocs_mkdocs-click_pr90 +mkorpela_overrides_pr39 +mkorpela_overrides_pr50 +mkorpela_overrides_pr57 +mkorpela_overrides_pr59 +mkorpela_overrides_pr69 +mkorpela_overrides_pr70 +mkorpela_overrides_pr76 +mkorpela_overrides_pr81 +mkorpela_overrides_pr82 +mkorpela_pabot_pr317 +mkorpela_pabot_pr413 +mkorpela_pabot_pr496 +mkorpela_pabot_pr520 +mkorpela_pabot_pr607 +mkorpela_pabot_pr651 +ml31415_numpy-groupies_pr59 +ml31415_numpy-groupies_pr61 +mlenzen_collections-extended_pr143 +mlenzen_collections-extended_pr149 +mlenzen_collections-extended_pr152 +mlenzen_collections-extended_pr170 +mmaitre314_picklescan_pr10 +mmaitre314_picklescan_pr12 +mmaitre314_picklescan_pr19 +mmaitre314_picklescan_pr21 +mmaitre314_picklescan_pr3 +mmaitre314_picklescan_pr40 +mmaitre314_picklescan_pr9 +mmore500_alifedata-phyloinformatics-convert_pr24 +mmore500_alifedata-phyloinformatics-convert_pr3 +mmore500_alifedata-phyloinformatics-convert_pr5 +mmore500_alifedata-phyloinformatics-convert_pr6 +moble_quaternion_pr150 +moble_quaternion_pr157 +moble_quaternion_pr179 +moble_quaternion_pr182 +moble_quaternion_pr197 +moble_quaternion_pr223 +moble_quaternion_pr224 +mondeja_mkdocs-include-markdown-plugin_pr107 +mondeja_mkdocs-include-markdown-plugin_pr112 +mondeja_mkdocs-include-markdown-plugin_pr115 +mondeja_mkdocs-include-markdown-plugin_pr2 +mondeja_mkdocs-include-markdown-plugin_pr46 +mondeja_mkdocs-include-markdown-plugin_pr48 +mondeja_mkdocs-include-markdown-plugin_pr51 +mondeja_mkdocs-include-markdown-plugin_pr56 +mondeja_mkdocs-include-markdown-plugin_pr72 +mondeja_mkdocs-include-markdown-plugin_pr79 +mondeja_mkdocs-include-markdown-plugin_pr81 +mondeja_mkdocs-include-markdown-plugin_pr89 +mondeja_mkdocs-include-markdown-plugin_pr91 +mondeja_mkdocs-include-markdown-plugin_pr93 +mondeja_mkdocs-include-markdown-plugin_pr95 +mongodb_mongo-python-driver_pr1243 +mongodb_mongo-python-driver_pr1246 +mongodb_mongo-python-driver_pr1252 +mongodb_mongo-python-driver_pr1261 +mongodb_mongo-python-driver_pr1263 +mongodb_mongo-python-driver_pr1270 +mongodb_mongo-python-driver_pr1273 +mongodb_mongo-python-driver_pr1275 +mongodb_mongo-python-driver_pr1277 +mongodb_mongo-python-driver_pr1285 +mongodb_mongo-python-driver_pr1287 +mongodb_mongo-python-driver_pr1295 +mongodb_mongo-python-driver_pr1296 +mongodb_mongo-python-driver_pr1313 +mongodb_mongo-python-driver_pr1315 +mongodb_mongo-python-driver_pr1320 +mongodb_mongo-python-driver_pr1324 +mongodb_mongo-python-driver_pr1328 +mongodb_mongo-python-driver_pr1337 +mongodb_mongo-python-driver_pr1338 +mongodb_mongo-python-driver_pr1339 +mongodb_mongo-python-driver_pr1346 +mongodb_mongo-python-driver_pr1351 +mongodb_mongo-python-driver_pr1368 +mongodb_mongo-python-driver_pr1370 +mongodb_mongo-python-driver_pr1371 +mongodb_mongo-python-driver_pr1389 +mongodb_mongo-python-driver_pr1395 +mongodb_mongo-python-driver_pr1402 +mongodb_mongo-python-driver_pr1409 +mongodb_mongo-python-driver_pr1418 +mongodb_mongo-python-driver_pr1444 +mongodb_mongo-python-driver_pr1473 +mongodb_mongo-python-driver_pr1481 +mongodb_mongo-python-driver_pr1491 +mongodb_mongo-python-driver_pr1495 +mongodb_mongo-python-driver_pr1510 +mongodb_mongo-python-driver_pr1512 +mongodb_mongo-python-driver_pr1526 +mongodb_mongo-python-driver_pr1537 +mongodb_mongo-python-driver_pr1544 +mongodb_mongo-python-driver_pr1556 +mongodb_mongo-python-driver_pr1573 +mongodb_mongo-python-driver_pr1579 +mongodb_mongo-python-driver_pr1584 +mongodb_mongo-python-driver_pr1600 +mongodb_mongo-python-driver_pr1616 +mongodb_mongo-python-driver_pr1644 +mongodb_mongo-python-driver_pr1645 +mongodb_mongo-python-driver_pr1646 +mongodb_mongo-python-driver_pr1659 +mongodb_mongo-python-driver_pr658 +mongodb_mongo-python-driver_pr659 +mongodb_mongo-python-driver_pr660 +mongodb_mongo-python-driver_pr663 +mongodb_mongo-python-driver_pr664 +mongodb_mongo-python-driver_pr676 +mongodb_mongo-python-driver_pr679 +mongodb_mongo-python-driver_pr683 +mongodb_mongo-python-driver_pr688 +mongodb_mongo-python-driver_pr694 +mongodb_mongo-python-driver_pr695 +mongodb_mongo-python-driver_pr697 +mongodb_mongo-python-driver_pr698 +mongodb_mongo-python-driver_pr699 +mongodb_mongo-python-driver_pr706 +mongodb_mongo-python-driver_pr711 +mongodb_mongo-python-driver_pr718 +mongodb_mongo-python-driver_pr721 +mongodb_mongo-python-driver_pr722 +mongodb_mongo-python-driver_pr723 +mongodb_mongo-python-driver_pr724 +mongodb_mongo-python-driver_pr725 +mongodb_mongo-python-driver_pr728 +mongodb_mongo-python-driver_pr729 +mongodb_mongo-python-driver_pr730 +mongodb_mongo-python-driver_pr731 +mongodb_mongo-python-driver_pr738 +mongodb_mongo-python-driver_pr739 +mongodb_mongo-python-driver_pr742 +mongodb_mongo-python-driver_pr747 +mongodb_mongo-python-driver_pr749 +mongodb_mongo-python-driver_pr752 +mongodb_mongo-python-driver_pr754 +mongodb_mongo-python-driver_pr755 +mongodb_mongo-python-driver_pr760 +mongodb_mongo-python-driver_pr761 +mongodb_mongo-python-driver_pr767 +mongodb_pymongo-auth-aws_pr10 +mongodb_pymongo-auth-aws_pr7 +mongodb_pymongo-auth-aws_pr9 +more-itertools_more-itertools_pr1000 +more-itertools_more-itertools_pr1002 +more-itertools_more-itertools_pr1004 +more-itertools_more-itertools_pr1018 +more-itertools_more-itertools_pr1028 +more-itertools_more-itertools_pr103 +more-itertools_more-itertools_pr1040 +more-itertools_more-itertools_pr1048 +more-itertools_more-itertools_pr105 +more-itertools_more-itertools_pr1056 +more-itertools_more-itertools_pr1058 +more-itertools_more-itertools_pr1068 +more-itertools_more-itertools_pr107 +more-itertools_more-itertools_pr1077 +more-itertools_more-itertools_pr1078 +more-itertools_more-itertools_pr108 +more-itertools_more-itertools_pr1081 +more-itertools_more-itertools_pr1082 +more-itertools_more-itertools_pr1085 +more-itertools_more-itertools_pr1095 +more-itertools_more-itertools_pr1097 +more-itertools_more-itertools_pr1099 +more-itertools_more-itertools_pr110 +more-itertools_more-itertools_pr1101 +more-itertools_more-itertools_pr1107 +more-itertools_more-itertools_pr113 +more-itertools_more-itertools_pr118 +more-itertools_more-itertools_pr127 +more-itertools_more-itertools_pr128 +more-itertools_more-itertools_pr137 +more-itertools_more-itertools_pr140 +more-itertools_more-itertools_pr145 +more-itertools_more-itertools_pr146 +more-itertools_more-itertools_pr148 +more-itertools_more-itertools_pr152 +more-itertools_more-itertools_pr165 +more-itertools_more-itertools_pr167 +more-itertools_more-itertools_pr169 +more-itertools_more-itertools_pr170 +more-itertools_more-itertools_pr171 +more-itertools_more-itertools_pr172 +more-itertools_more-itertools_pr173 +more-itertools_more-itertools_pr174 +more-itertools_more-itertools_pr176 +more-itertools_more-itertools_pr177 +more-itertools_more-itertools_pr178 +more-itertools_more-itertools_pr184 +more-itertools_more-itertools_pr186 +more-itertools_more-itertools_pr187 +more-itertools_more-itertools_pr209 +more-itertools_more-itertools_pr212 +more-itertools_more-itertools_pr213 +more-itertools_more-itertools_pr221 +more-itertools_more-itertools_pr229 +more-itertools_more-itertools_pr240 +more-itertools_more-itertools_pr247 +more-itertools_more-itertools_pr249 +more-itertools_more-itertools_pr258 +more-itertools_more-itertools_pr274 +more-itertools_more-itertools_pr276 +more-itertools_more-itertools_pr278 +more-itertools_more-itertools_pr279 +more-itertools_more-itertools_pr284 +more-itertools_more-itertools_pr285 +more-itertools_more-itertools_pr290 +more-itertools_more-itertools_pr292 +more-itertools_more-itertools_pr294 +more-itertools_more-itertools_pr298 +more-itertools_more-itertools_pr301 +more-itertools_more-itertools_pr305 +more-itertools_more-itertools_pr306 +more-itertools_more-itertools_pr309 +more-itertools_more-itertools_pr310 +more-itertools_more-itertools_pr313 +more-itertools_more-itertools_pr325 +more-itertools_more-itertools_pr326 +more-itertools_more-itertools_pr346 +more-itertools_more-itertools_pr356 +more-itertools_more-itertools_pr362 +more-itertools_more-itertools_pr363 +more-itertools_more-itertools_pr365 +more-itertools_more-itertools_pr368 +more-itertools_more-itertools_pr373 +more-itertools_more-itertools_pr374 +more-itertools_more-itertools_pr382 +more-itertools_more-itertools_pr391 +more-itertools_more-itertools_pr392 +more-itertools_more-itertools_pr407 +more-itertools_more-itertools_pr411 +more-itertools_more-itertools_pr412 +more-itertools_more-itertools_pr415 +more-itertools_more-itertools_pr422 +more-itertools_more-itertools_pr423 +more-itertools_more-itertools_pr429 +more-itertools_more-itertools_pr432 +more-itertools_more-itertools_pr434 +more-itertools_more-itertools_pr436 +more-itertools_more-itertools_pr440 +more-itertools_more-itertools_pr444 +more-itertools_more-itertools_pr454 +more-itertools_more-itertools_pr455 +more-itertools_more-itertools_pr463 +more-itertools_more-itertools_pr471 +more-itertools_more-itertools_pr473 +more-itertools_more-itertools_pr475 +more-itertools_more-itertools_pr484 +more-itertools_more-itertools_pr486 +more-itertools_more-itertools_pr490 +more-itertools_more-itertools_pr496 +more-itertools_more-itertools_pr497 +more-itertools_more-itertools_pr498 +more-itertools_more-itertools_pr503 +more-itertools_more-itertools_pr509 +more-itertools_more-itertools_pr511 +more-itertools_more-itertools_pr531 +more-itertools_more-itertools_pr533 +more-itertools_more-itertools_pr537 +more-itertools_more-itertools_pr539 +more-itertools_more-itertools_pr542 +more-itertools_more-itertools_pr545 +more-itertools_more-itertools_pr557 +more-itertools_more-itertools_pr560 +more-itertools_more-itertools_pr565 +more-itertools_more-itertools_pr566 +more-itertools_more-itertools_pr570 +more-itertools_more-itertools_pr572 +more-itertools_more-itertools_pr573 +more-itertools_more-itertools_pr587 +more-itertools_more-itertools_pr599 +more-itertools_more-itertools_pr606 +more-itertools_more-itertools_pr627 +more-itertools_more-itertools_pr63 +more-itertools_more-itertools_pr630 +more-itertools_more-itertools_pr641 +more-itertools_more-itertools_pr642 +more-itertools_more-itertools_pr643 +more-itertools_more-itertools_pr645 +more-itertools_more-itertools_pr646 +more-itertools_more-itertools_pr647 +more-itertools_more-itertools_pr653 +more-itertools_more-itertools_pr659 +more-itertools_more-itertools_pr674 +more-itertools_more-itertools_pr676 +more-itertools_more-itertools_pr686 +more-itertools_more-itertools_pr689 +more-itertools_more-itertools_pr694 +more-itertools_more-itertools_pr70 +more-itertools_more-itertools_pr703 +more-itertools_more-itertools_pr704 +more-itertools_more-itertools_pr706 +more-itertools_more-itertools_pr708 +more-itertools_more-itertools_pr71 +more-itertools_more-itertools_pr714 +more-itertools_more-itertools_pr723 +more-itertools_more-itertools_pr734 +more-itertools_more-itertools_pr736 +more-itertools_more-itertools_pr74 +more-itertools_more-itertools_pr742 +more-itertools_more-itertools_pr743 +more-itertools_more-itertools_pr753 +more-itertools_more-itertools_pr755 +more-itertools_more-itertools_pr756 +more-itertools_more-itertools_pr757 +more-itertools_more-itertools_pr76 +more-itertools_more-itertools_pr765 +more-itertools_more-itertools_pr777 +more-itertools_more-itertools_pr78 +more-itertools_more-itertools_pr783 +more-itertools_more-itertools_pr784 +more-itertools_more-itertools_pr785 +more-itertools_more-itertools_pr79 +more-itertools_more-itertools_pr791 +more-itertools_more-itertools_pr793 +more-itertools_more-itertools_pr796 +more-itertools_more-itertools_pr81 +more-itertools_more-itertools_pr825 +more-itertools_more-itertools_pr828 +more-itertools_more-itertools_pr829 +more-itertools_more-itertools_pr834 +more-itertools_more-itertools_pr841 +more-itertools_more-itertools_pr845 +more-itertools_more-itertools_pr847 +more-itertools_more-itertools_pr850 +more-itertools_more-itertools_pr855 +more-itertools_more-itertools_pr873 +more-itertools_more-itertools_pr874 +more-itertools_more-itertools_pr875 +more-itertools_more-itertools_pr877 +more-itertools_more-itertools_pr892 +more-itertools_more-itertools_pr903 +more-itertools_more-itertools_pr913 +more-itertools_more-itertools_pr917 +more-itertools_more-itertools_pr926 +more-itertools_more-itertools_pr93 +more-itertools_more-itertools_pr938 +more-itertools_more-itertools_pr94 +more-itertools_more-itertools_pr940 +more-itertools_more-itertools_pr95 +more-itertools_more-itertools_pr951 +more-itertools_more-itertools_pr952 +more-itertools_more-itertools_pr954 +more-itertools_more-itertools_pr960 +more-itertools_more-itertools_pr961 +more-itertools_more-itertools_pr963 +more-itertools_more-itertools_pr964 +more-itertools_more-itertools_pr97 +more-itertools_more-itertools_pr98 +more-itertools_more-itertools_pr985 +more-itertools_more-itertools_pr988 +more-itertools_more-itertools_pr999 +mozilla_django-csp_pr213 +mozilla_django-csp_pr237 +mozilla_django-csp_pr251 +mozilla_django-csp_pr257 +mozilla_django-csp_pr258 +msiemens_tinydb_pr11 +msiemens_tinydb_pr114 +msiemens_tinydb_pr12 +msiemens_tinydb_pr139 +msiemens_tinydb_pr145 +msiemens_tinydb_pr15 +msiemens_tinydb_pr16 +msiemens_tinydb_pr184 +msiemens_tinydb_pr187 +msiemens_tinydb_pr188 +msiemens_tinydb_pr19 +msiemens_tinydb_pr202 +msiemens_tinydb_pr216 +msiemens_tinydb_pr229 +msiemens_tinydb_pr231 +msiemens_tinydb_pr238 +msiemens_tinydb_pr256 +msiemens_tinydb_pr279 +msiemens_tinydb_pr33 +msiemens_tinydb_pr38 +msiemens_tinydb_pr39 +msiemens_tinydb_pr395 +msiemens_tinydb_pr41 +msiemens_tinydb_pr424 +msiemens_tinydb_pr43 +msiemens_tinydb_pr46 +msiemens_tinydb_pr504 +msiemens_tinydb_pr573 +msiemens_tinydb_pr61 +mtkennerly_dunamai_pr38 +mtkennerly_dunamai_pr44 +mtth_hdfs_pr192 +mtth_hdfs_pr210 +multani_structlog-gcp_pr10 +multani_structlog-gcp_pr14 +multani_structlog-gcp_pr38 +multani_structlog-gcp_pr42 +multani_structlog-gcp_pr5 +multani_structlog-gcp_pr98 +mvcisback_py-aiger_pr102 +mwclient_mwclient_pr108 +mwclient_mwclient_pr143 +mwclient_mwclient_pr163 +mwclient_mwclient_pr173 +mwclient_mwclient_pr232 +mwclient_mwclient_pr242 +mwclient_mwclient_pr264 +mwclient_mwclient_pr286 +mwclient_mwclient_pr288 +mwclient_mwclient_pr291 +mwclient_mwclient_pr293 +mwclient_mwclient_pr308 +mwclient_mwclient_pr316 +mwclient_mwclient_pr327 +mwclient_mwclient_pr335 +mwclient_mwclient_pr339 +mwclient_mwclient_pr343 +mwclient_mwclient_pr345 +mwclient_mwclient_pr352 +mwclient_mwclient_pr356 +mwclient_mwclient_pr365 +mwclient_mwclient_pr370 +myusuf3_delorean_pr2 +myusuf3_delorean_pr62 +myusuf3_delorean_pr69 +namespace-ee_django-datadog-logger_pr40 +napari_napari-plugin-engine_pr2 +napari_napari-plugin-engine_pr3 +napari_napari-plugin-engine_pr32 +napari_napari-plugin-engine_pr6 +nayaverdier_dyntastic_pr5 +ncclient_ncclient_pr200 +ncclient_ncclient_pr242 +ncclient_ncclient_pr259 +ncclient_ncclient_pr283 +ncclient_ncclient_pr296 +ncclient_ncclient_pr299 +ncclient_ncclient_pr301 +ncclient_ncclient_pr309 +ncclient_ncclient_pr314 +ncclient_ncclient_pr319 +ncclient_ncclient_pr324 +ncclient_ncclient_pr328 +ncclient_ncclient_pr330 +ncclient_ncclient_pr350 +ncclient_ncclient_pr354 +ncclient_ncclient_pr358 +ncclient_ncclient_pr363 +ncclient_ncclient_pr392 +ncclient_ncclient_pr397 +ncclient_ncclient_pr404 +ncclient_ncclient_pr405 +ncclient_ncclient_pr407 +ncclient_ncclient_pr409 +ncclient_ncclient_pr412 +ncclient_ncclient_pr418 +ncclient_ncclient_pr420 +ncclient_ncclient_pr430 +ncclient_ncclient_pr434 +ncclient_ncclient_pr435 +ncclient_ncclient_pr446 +ncclient_ncclient_pr460 +ncclient_ncclient_pr485 +ncclient_ncclient_pr491 +ncclient_ncclient_pr510 +ncclient_ncclient_pr517 +ncclient_ncclient_pr528 +ncclient_ncclient_pr555 +ncclient_ncclient_pr556 +ncclient_ncclient_pr568 +ncclient_ncclient_pr570 +ncclient_ncclient_pr574 +ncclient_ncclient_pr576 +ncclient_ncclient_pr591 +ncclient_ncclient_pr600 +ncclient_ncclient_pr605 +ncclient_ncclient_pr607 +ncclient_ncclient_pr609 +ncclient_ncclient_pr628 +ncclient_ncclient_pr639 +ncclient_ncclient_pr645 +ncclient_ncclient_pr69 +nedbat_cog_pr4 +neovim_python-client_pr384 +neovim_python-client_pr399 +neovim_python-client_pr405 +neovim_python-client_pr413 +neovim_python-client_pr414 +neovim_python-client_pr469 +neovim_python-client_pr506 +neovim_python-client_pr534 +neovim_python-client_pr535 +neovim_python-client_pr540 +neovim_python-client_pr546 +nephila_giturlparse_pr110 +nerdocs_pydifact_pr14 +nerdocs_pydifact_pr33 +nerdocs_pydifact_pr35 +nerdocs_pydifact_pr48 +nerdocs_pydifact_pr51 +nerdocs_pydifact_pr60 +nerdocs_pydifact_pr61 +nerdocs_pydifact_pr77 +nerdocs_pydifact_pr80 +newville_pyshortcuts_pr18 +nhairs_python-json-logger_pr26 +nhairs_python-json-logger_pr39 +nhairs_python-json-logger_pr52 +nicklambourne_slackblocks_pr108 +nicklambourne_slackblocks_pr113 +nicklambourne_slackblocks_pr32 +nicklambourne_slackblocks_pr38 +nicklambourne_slackblocks_pr41 +nicklambourne_slackblocks_pr43 +nicklambourne_slackblocks_pr49 +nicklambourne_slackblocks_pr69 +nickstenning_honcho_pr149 +nicodv_kmodes_pr194 +nipreps_acres_pr13 +nipy_nitime_pr199 +nipy_nitime_pr200 +nipy_nitransforms_pr17 +nipy_nitransforms_pr24 +nipy_nitransforms_pr27 +no-plagiarism_pymorphy3_pr27 +noahmorrison_chevron_pr94 +nomonosound_numpy-minmax_pr21 +nomonosound_numpy-minmax_pr23 +nschloe_matplotx_pr11 +nschloe_matplotx_pr22 +nschloe_pytest-codeblocks_pr1 +nschloe_pytest-codeblocks_pr2 +nschloe_pytest-codeblocks_pr20 +nschloe_pytest-codeblocks_pr25 +nschloe_pytest-codeblocks_pr40 +nschloe_pytest-codeblocks_pr9 +nuclio_nuclio-jupyter_pr23 +nuclio_nuclio-jupyter_pr25 +nuclio_nuclio-jupyter_pr28 +nuclio_nuclio-jupyter_pr29 +nuclio_nuclio-jupyter_pr37 +nuclio_nuclio-jupyter_pr40 +nuclio_nuclio-jupyter_pr42 +nuclio_nuclio-jupyter_pr44 +numpy_numpy-financial_pr22 +numpy_numpy-financial_pr43 +numpy_numpy-financial_pr47 +numpy_numpy-financial_pr49 +numpy_numpy-financial_pr54 +numpy_numpy-financial_pr62 +numpy_numpy-financial_pr81 +nylas_nylas-python_pr100 +nylas_nylas-python_pr101 +nylas_nylas-python_pr102 +nylas_nylas-python_pr103 +nylas_nylas-python_pr106 +nylas_nylas-python_pr111 +nylas_nylas-python_pr112 +nylas_nylas-python_pr114 +nylas_nylas-python_pr123 +nylas_nylas-python_pr124 +nylas_nylas-python_pr131 +nylas_nylas-python_pr134 +nylas_nylas-python_pr137 +nylas_nylas-python_pr141 +nylas_nylas-python_pr146 +nylas_nylas-python_pr147 +nylas_nylas-python_pr152 +nylas_nylas-python_pr153 +nylas_nylas-python_pr154 +nylas_nylas-python_pr155 +nylas_nylas-python_pr156 +nylas_nylas-python_pr157 +nylas_nylas-python_pr158 +nylas_nylas-python_pr162 +nylas_nylas-python_pr163 +nylas_nylas-python_pr166 +nylas_nylas-python_pr167 +nylas_nylas-python_pr168 +nylas_nylas-python_pr171 +nylas_nylas-python_pr173 +nylas_nylas-python_pr177 +nylas_nylas-python_pr180 +nylas_nylas-python_pr183 +nylas_nylas-python_pr186 +nylas_nylas-python_pr190 +nylas_nylas-python_pr195 +nylas_nylas-python_pr197 +nylas_nylas-python_pr201 +nylas_nylas-python_pr203 +nylas_nylas-python_pr207 +nylas_nylas-python_pr208 +nylas_nylas-python_pr213 +nylas_nylas-python_pr215 +nylas_nylas-python_pr217 +nylas_nylas-python_pr225 +nylas_nylas-python_pr228 +nylas_nylas-python_pr229 +nylas_nylas-python_pr233 +nylas_nylas-python_pr236 +nylas_nylas-python_pr243 +nylas_nylas-python_pr342 +nylas_nylas-python_pr348 +nylas_nylas-python_pr350 +nylas_nylas-python_pr352 +nylas_nylas-python_pr357 +nylas_nylas-python_pr360 +nylas_nylas-python_pr361 +nylas_nylas-python_pr362 +nylas_nylas-python_pr363 +nylas_nylas-python_pr371 +nylas_nylas-python_pr372 +nylas_nylas-python_pr383 +nylas_nylas-python_pr385 +nylas_nylas-python_pr386 +nylas_nylas-python_pr397 +nylas_nylas-python_pr399 +nylas_nylas-python_pr404 +nylas_nylas-python_pr407 +nylas_nylas-python_pr411 +nylas_nylas-python_pr414 +nylas_nylas-python_pr419 +nylas_nylas-python_pr422 +nylas_nylas-python_pr423 +nylas_nylas-python_pr425 +nylas_nylas-python_pr426 +nylas_nylas-python_pr432 +nylas_nylas-python_pr434 +nylas_nylas-python_pr436 +nylas_nylas-python_pr439 +nylas_nylas-python_pr440 +nylas_nylas-python_pr444 +nylas_nylas-python_pr46 +nylas_nylas-python_pr52 +nylas_nylas-python_pr55 +nylas_nylas-python_pr80 +nylas_nylas-python_pr96 +nylas_nylas-python_pr97 +nylas_nylas-python_pr98 +nylas_nylas-python_pr99 +oasis-open_cti-pattern-validator_pr10 +oasis-open_cti-pattern-validator_pr11 +oasis-open_cti-pattern-validator_pr12 +oasis-open_cti-pattern-validator_pr33 +oasis-open_cti-pattern-validator_pr64 +oasis-open_cti-pattern-validator_pr65 +oasis-open_cti-pattern-validator_pr75 +oasis-open_cti-pattern-validator_pr81 +oasis-open_cti-python-stix2_pr400 +oasis-open_cti-python-stix2_pr401 +oasis-open_cti-python-stix2_pr404 +oasis-open_cti-python-stix2_pr407 +oasis-open_cti-python-stix2_pr431 +oasis-open_cti-python-stix2_pr436 +oasis-open_cti-python-stix2_pr438 +oasis-open_cti-python-stix2_pr439 +oasis-open_cti-python-stix2_pr445 +oasis-open_cti-python-stix2_pr449 +oasis-open_cti-python-stix2_pr454 +oasis-open_cti-python-stix2_pr456 +oasis-open_cti-python-stix2_pr467 +oasis-open_cti-python-stix2_pr470 +oasis-open_cti-python-stix2_pr481 +oasis-open_cti-python-stix2_pr482 +oasis-open_cti-python-stix2_pr483 +oasis-open_cti-python-stix2_pr491 +oasis-open_cti-python-stix2_pr513 +oasis-open_cti-python-stix2_pr521 +oasis-open_cti-python-stix2_pr605 +oasis-open_cti-python-stix2_pr607 +oasis-open_cti-taxii-client_pr11 +oasis-open_cti-taxii-client_pr18 +oasis-open_cti-taxii-client_pr44 +oasis-open_cti-taxii-client_pr47 +oasis-open_cti-taxii-client_pr54 +oasis-open_cti-taxii-client_pr56 +oasis-open_cti-taxii-client_pr79 +oasis-open_cti-taxii-client_pr85 +oasis-open_cti-taxii-client_pr94 +oauthlib_oauthlib_pr103 +oauthlib_oauthlib_pr112 +oauthlib_oauthlib_pr124 +oauthlib_oauthlib_pr129 +oauthlib_oauthlib_pr143 +oauthlib_oauthlib_pr166 +oauthlib_oauthlib_pr170 +oauthlib_oauthlib_pr189 +oauthlib_oauthlib_pr199 +oauthlib_oauthlib_pr201 +oauthlib_oauthlib_pr206 +oauthlib_oauthlib_pr208 +oauthlib_oauthlib_pr214 +oauthlib_oauthlib_pr216 +oauthlib_oauthlib_pr224 +oauthlib_oauthlib_pr231 +oauthlib_oauthlib_pr239 +oauthlib_oauthlib_pr314 +oauthlib_oauthlib_pr316 +oauthlib_oauthlib_pr323 +oauthlib_oauthlib_pr336 +oauthlib_oauthlib_pr339 +oauthlib_oauthlib_pr351 +oauthlib_oauthlib_pr354 +oauthlib_oauthlib_pr355 +oauthlib_oauthlib_pr358 +oauthlib_oauthlib_pr362 +oauthlib_oauthlib_pr381 +oauthlib_oauthlib_pr396 +oauthlib_oauthlib_pr416 +oauthlib_oauthlib_pr417 +oauthlib_oauthlib_pr453 +oauthlib_oauthlib_pr455 +oauthlib_oauthlib_pr456 +oauthlib_oauthlib_pr458 +oauthlib_oauthlib_pr462 +oauthlib_oauthlib_pr463 +oauthlib_oauthlib_pr464 +oauthlib_oauthlib_pr465 +oauthlib_oauthlib_pr466 +oauthlib_oauthlib_pr481 +oauthlib_oauthlib_pr484 +oauthlib_oauthlib_pr488 +oauthlib_oauthlib_pr508 +oauthlib_oauthlib_pr533 +oauthlib_oauthlib_pr542 +oauthlib_oauthlib_pr546 +oauthlib_oauthlib_pr593 +oauthlib_oauthlib_pr60 +oauthlib_oauthlib_pr614 +oauthlib_oauthlib_pr617 +oauthlib_oauthlib_pr623 +oauthlib_oauthlib_pr625 +oauthlib_oauthlib_pr630 +oauthlib_oauthlib_pr64 +oauthlib_oauthlib_pr645 +oauthlib_oauthlib_pr65 +oauthlib_oauthlib_pr653 +oauthlib_oauthlib_pr656 +oauthlib_oauthlib_pr658 +oauthlib_oauthlib_pr66 +oauthlib_oauthlib_pr660 +oauthlib_oauthlib_pr663 +oauthlib_oauthlib_pr668 +oauthlib_oauthlib_pr669 +oauthlib_oauthlib_pr671 +oauthlib_oauthlib_pr674 +oauthlib_oauthlib_pr675 +oauthlib_oauthlib_pr677 +oauthlib_oauthlib_pr680 +oauthlib_oauthlib_pr69 +oauthlib_oauthlib_pr691 +oauthlib_oauthlib_pr703 +oauthlib_oauthlib_pr716 +oauthlib_oauthlib_pr720 +oauthlib_oauthlib_pr729 +oauthlib_oauthlib_pr731 +oauthlib_oauthlib_pr747 +oauthlib_oauthlib_pr752 +oauthlib_oauthlib_pr753 +oauthlib_oauthlib_pr760 +oauthlib_oauthlib_pr771 +oauthlib_oauthlib_pr783 +oauthlib_oauthlib_pr786 +oauthlib_oauthlib_pr787 +oauthlib_oauthlib_pr790 +oauthlib_oauthlib_pr791 +oauthlib_oauthlib_pr795 +oauthlib_oauthlib_pr806 +oauthlib_oauthlib_pr818 +oauthlib_oauthlib_pr828 +oauthlib_oauthlib_pr838 +oauthlib_oauthlib_pr853 +oauthlib_oauthlib_pr855 +oauthlib_oauthlib_pr87 +oauthlib_oauthlib_pr93 +octoenergy_tentaclio_pr109 +octoenergy_tentaclio_pr110 +octoenergy_tentaclio_pr111 +octoenergy_tentaclio_pr115 +octoenergy_tentaclio_pr121 +octoenergy_tentaclio_pr124 +octoenergy_tentaclio_pr126 +octoenergy_tentaclio_pr130 +octoenergy_tentaclio_pr132 +octoenergy_tentaclio_pr138 +octoenergy_tentaclio_pr141 +octoenergy_tentaclio_pr153 +octoenergy_tentaclio_pr164 +octoenergy_tentaclio_pr188 +octoenergy_tentaclio_pr196 +octoenergy_tentaclio_pr201 +octoenergy_tentaclio_pr203 +octoenergy_tentaclio_pr213 +octoenergy_tentaclio_pr215 +octoenergy_tentaclio_pr226 +ofek_coincurve_pr156 +ofek_coincurve_pr160 +ofek_coincurve_pr161 +ofek_coincurve_pr162 +ofek_coincurve_pr182 +ofek_coincurve_pr188 +ofek_hatch-vcs_pr24 +ofek_hatch-vcs_pr53 +ofek_hatch-vcs_pr6 +oittaa_uuid6-python_pr16 +oittaa_uuid6-python_pr211 +okken_pytest-check_pr10 +okken_pytest-check_pr66 +okken_pytest-check_pr69 +okken_pytest-check_pr77 +okken_pytest-check_pr81 +okken_pytest-check_pr86 +okta_okta-jwt-verifier-python_pr12 +okta_okta-jwt-verifier-python_pr25 +okta_okta-jwt-verifier-python_pr32 +okta_okta-jwt-verifier-python_pr8 +okta_okta-jwt-verifier-python_pr9 +olofk_fusesoc_pr364 +olofk_fusesoc_pr431 +olofk_fusesoc_pr457 +olofk_fusesoc_pr566 +olofk_fusesoc_pr568 +olofk_fusesoc_pr583 +olofk_fusesoc_pr636 +olofk_fusesoc_pr640 +olofk_fusesoc_pr645 +olofk_fusesoc_pr647 +olofk_fusesoc_pr668 +olofk_fusesoc_pr704 +olofk_fusesoc_pr706 +olofk_fusesoc_pr711 +olofk_fusesoc_pr720 +olofk_fusesoc_pr722 +olofk_fusesoc_pr724 +olofk_fusesoc_pr726 +olofk_fusesoc_pr737 +olzhasar_pytest-watcher_pr12 +olzhasar_pytest-watcher_pr14 +olzhasar_pytest-watcher_pr17 +olzhasar_pytest-watcher_pr9 +omni-us_jsonargparse_pr145 +omni-us_jsonargparse_pr162 +omni-us_jsonargparse_pr164 +omni-us_jsonargparse_pr177 +omni-us_jsonargparse_pr182 +omni-us_jsonargparse_pr186 +omni-us_jsonargparse_pr190 +omni-us_jsonargparse_pr191 +omni-us_jsonargparse_pr194 +omni-us_jsonargparse_pr197 +omni-us_jsonargparse_pr198 +omni-us_jsonargparse_pr199 +omni-us_jsonargparse_pr202 +omni-us_jsonargparse_pr210 +omni-us_jsonargparse_pr211 +omni-us_jsonargparse_pr214 +omni-us_jsonargparse_pr215 +omni-us_jsonargparse_pr216 +omni-us_jsonargparse_pr218 +omni-us_jsonargparse_pr220 +omni-us_jsonargparse_pr222 +omni-us_jsonargparse_pr223 +omni-us_jsonargparse_pr225 +omni-us_jsonargparse_pr233 +omni-us_jsonargparse_pr239 +omni-us_jsonargparse_pr240 +omni-us_jsonargparse_pr248 +omni-us_jsonargparse_pr253 +omni-us_jsonargparse_pr264 +omni-us_jsonargparse_pr266 +omni-us_jsonargparse_pr267 +omni-us_jsonargparse_pr268 +omni-us_jsonargparse_pr270 +omni-us_jsonargparse_pr272 +omni-us_jsonargparse_pr273 +omni-us_jsonargparse_pr274 +omni-us_jsonargparse_pr282 +omni-us_jsonargparse_pr285 +omni-us_jsonargparse_pr288 +omni-us_jsonargparse_pr291 +omni-us_jsonargparse_pr296 +omni-us_jsonargparse_pr302 +omni-us_jsonargparse_pr310 +omni-us_jsonargparse_pr314 +omni-us_jsonargparse_pr318 +omni-us_jsonargparse_pr323 +omni-us_jsonargparse_pr326 +omni-us_jsonargparse_pr340 +omni-us_jsonargparse_pr344 +omni-us_jsonargparse_pr346 +omni-us_jsonargparse_pr351 +omni-us_jsonargparse_pr363 +omni-us_jsonargparse_pr364 +omni-us_jsonargparse_pr369 +omni-us_jsonargparse_pr370 +omni-us_jsonargparse_pr381 +omni-us_jsonargparse_pr386 +omni-us_jsonargparse_pr390 +omni-us_jsonargparse_pr399 +omni-us_jsonargparse_pr401 +omni-us_jsonargparse_pr402 +omni-us_jsonargparse_pr403 +omni-us_jsonargparse_pr405 +omni-us_jsonargparse_pr406 +omni-us_jsonargparse_pr412 +omni-us_jsonargparse_pr416 +omni-us_jsonargparse_pr422 +omni-us_jsonargparse_pr432 +omni-us_jsonargparse_pr434 +omni-us_jsonargparse_pr435 +omni-us_jsonargparse_pr444 +omni-us_jsonargparse_pr445 +omni-us_jsonargparse_pr458 +omni-us_jsonargparse_pr468 +omni-us_jsonargparse_pr475 +omni-us_jsonargparse_pr476 +omni-us_jsonargparse_pr480 +omni-us_jsonargparse_pr485 +omni-us_jsonargparse_pr486 +omni-us_jsonargparse_pr502 +omni-us_jsonargparse_pr506 +omni-us_jsonargparse_pr508 +omni-us_jsonargparse_pr513 +omni-us_jsonargparse_pr518 +omni-us_jsonargparse_pr522 +omni-us_jsonargparse_pr527 +omni-us_jsonargparse_pr530 +omni-us_jsonargparse_pr535 +omni-us_jsonargparse_pr548 +omni-us_jsonargparse_pr549 +omni-us_jsonargparse_pr551 +omni-us_jsonargparse_pr560 +omni-us_jsonargparse_pr564 +omni-us_jsonargparse_pr568 +omni-us_jsonargparse_pr599 +omni-us_jsonargparse_pr601 +omni-us_jsonargparse_pr608 +omni-us_jsonargparse_pr625 +omni-us_jsonargparse_pr628 +omni-us_jsonargparse_pr630 +omni-us_jsonargparse_pr633 +omni-us_jsonargparse_pr637 +omni-us_jsonargparse_pr638 +omni-us_jsonargparse_pr643 +omni-us_jsonargparse_pr644 +omni-us_jsonargparse_pr650 +omni-us_jsonargparse_pr652 +omni-us_jsonargparse_pr660 +omni-us_jsonargparse_pr661 +omni-us_jsonargparse_pr662 +omni-us_jsonargparse_pr667 +omni-us_jsonargparse_pr668 +omni-us_jsonargparse_pr681 +omni-us_jsonargparse_pr694 +omni-us_jsonargparse_pr697 +omni-us_jsonargparse_pr698 +omni-us_jsonargparse_pr707 +omni-us_jsonargparse_pr709 +omni-us_jsonargparse_pr711 +omni-us_jsonargparse_pr717 +omni-us_jsonargparse_pr718 +omni-us_jsonargparse_pr720 +omni-us_jsonargparse_pr724 +omni-us_jsonargparse_pr736 +omni-us_jsonargparse_pr743 +omni-us_jsonargparse_pr746 +omni-us_jsonargparse_pr754 +omni-us_jsonargparse_pr756 +omni-us_jsonargparse_pr760 +omni-us_jsonargparse_pr763 +omni-us_jsonargparse_pr765 +omni-us_jsonargparse_pr770 +omni-us_jsonargparse_pr771 +omni-us_jsonargparse_pr775 +omni-us_jsonargparse_pr781 +omni-us_jsonargparse_pr783 +omni-us_jsonargparse_pr787 +omni-us_jsonargparse_pr795 +omni-us_jsonargparse_pr796 +omni-us_jsonargparse_pr810 +omni-us_jsonargparse_pr814 +omni-us_jsonargparse_pr815 +omnilib_sphinx-mdinclude_pr68 +onnx_tensorflow-onnx_pr1000 +onnx_tensorflow-onnx_pr1020 +onnx_tensorflow-onnx_pr1042 +onnx_tensorflow-onnx_pr1054 +onnx_tensorflow-onnx_pr1074 +onnx_tensorflow-onnx_pr1077 +onnx_tensorflow-onnx_pr1090 +onnx_tensorflow-onnx_pr1102 +onnx_tensorflow-onnx_pr1103 +onnx_tensorflow-onnx_pr1107 +onnx_tensorflow-onnx_pr1124 +onnx_tensorflow-onnx_pr1146 +onnx_tensorflow-onnx_pr1151 +onnx_tensorflow-onnx_pr1161 +onnx_tensorflow-onnx_pr1168 +onnx_tensorflow-onnx_pr1174 +onnx_tensorflow-onnx_pr1176 +onnx_tensorflow-onnx_pr1183 +onnx_tensorflow-onnx_pr1199 +onnx_tensorflow-onnx_pr1202 +onnx_tensorflow-onnx_pr1206 +onnx_tensorflow-onnx_pr1218 +onnx_tensorflow-onnx_pr1238 +onnx_tensorflow-onnx_pr1262 +onnx_tensorflow-onnx_pr1263 +onnx_tensorflow-onnx_pr1288 +onnx_tensorflow-onnx_pr1289 +onnx_tensorflow-onnx_pr1292 +onnx_tensorflow-onnx_pr1297 +onnx_tensorflow-onnx_pr1299 +onnx_tensorflow-onnx_pr1313 +onnx_tensorflow-onnx_pr1314 +onnx_tensorflow-onnx_pr1315 +onnx_tensorflow-onnx_pr1316 +onnx_tensorflow-onnx_pr1318 +onnx_tensorflow-onnx_pr1319 +onnx_tensorflow-onnx_pr1321 +onnx_tensorflow-onnx_pr1330 +onnx_tensorflow-onnx_pr1332 +onnx_tensorflow-onnx_pr1333 +onnx_tensorflow-onnx_pr1335 +onnx_tensorflow-onnx_pr1338 +onnx_tensorflow-onnx_pr1339 +onnx_tensorflow-onnx_pr1340 +onnx_tensorflow-onnx_pr1342 +onnx_tensorflow-onnx_pr1343 +onnx_tensorflow-onnx_pr1346 +onnx_tensorflow-onnx_pr1347 +onnx_tensorflow-onnx_pr1350 +onnx_tensorflow-onnx_pr1351 +onnx_tensorflow-onnx_pr1354 +onnx_tensorflow-onnx_pr1355 +onnx_tensorflow-onnx_pr1363 +onnx_tensorflow-onnx_pr1365 +onnx_tensorflow-onnx_pr1366 +onnx_tensorflow-onnx_pr1369 +onnx_tensorflow-onnx_pr1370 +onnx_tensorflow-onnx_pr1372 +onnx_tensorflow-onnx_pr1373 +onnx_tensorflow-onnx_pr1374 +onnx_tensorflow-onnx_pr1380 +onnx_tensorflow-onnx_pr1383 +onnx_tensorflow-onnx_pr1384 +onnx_tensorflow-onnx_pr1401 +onnx_tensorflow-onnx_pr1406 +onnx_tensorflow-onnx_pr1409 +onnx_tensorflow-onnx_pr1411 +onnx_tensorflow-onnx_pr1414 +onnx_tensorflow-onnx_pr1419 +onnx_tensorflow-onnx_pr832 +onnx_tensorflow-onnx_pr839 +onnx_tensorflow-onnx_pr850 +onnx_tensorflow-onnx_pr867 +onnx_tensorflow-onnx_pr871 +onnx_tensorflow-onnx_pr879 +onnx_tensorflow-onnx_pr880 +onnx_tensorflow-onnx_pr882 +onnx_tensorflow-onnx_pr949 +onnx_tensorflow-onnx_pr968 +onnx_tensorflow-onnx_pr974 +open-feature_python-sdk_pr103 +open-feature_python-sdk_pr134 +open-feature_python-sdk_pr136 +open-feature_python-sdk_pr139 +open-feature_python-sdk_pr141 +open-feature_python-sdk_pr142 +open-feature_python-sdk_pr172 +open-feature_python-sdk_pr213 +open-feature_python-sdk_pr215 +open-feature_python-sdk_pr216 +open-feature_python-sdk_pr233 +open-feature_python-sdk_pr257 +open-feature_python-sdk_pr26 +open-feature_python-sdk_pr261 +open-feature_python-sdk_pr27 +open-feature_python-sdk_pr278 +open-feature_python-sdk_pr285 +open-feature_python-sdk_pr291 +open-feature_python-sdk_pr306 +open-feature_python-sdk_pr309 +open-feature_python-sdk_pr314 +open-feature_python-sdk_pr324 +open-feature_python-sdk_pr329 +open-feature_python-sdk_pr38 +open-feature_python-sdk_pr389 +open-feature_python-sdk_pr395 +open-feature_python-sdk_pr415 +open-feature_python-sdk_pr423 +open-feature_python-sdk_pr425 +open-feature_python-sdk_pr43 +open-feature_python-sdk_pr44 +open-feature_python-sdk_pr442 +open-feature_python-sdk_pr446 +open-feature_python-sdk_pr451 +open-feature_python-sdk_pr474 +open-feature_python-sdk_pr5 +open-feature_python-sdk_pr504 +open-feature_python-sdk_pr523 +open-feature_python-sdk_pr533 +open-feature_python-sdk_pr535 +open-feature_python-sdk_pr537 +open-feature_python-sdk_pr538 +open-feature_python-sdk_pr6 +open-feature_python-sdk_pr64 +open-feature_python-sdk_pr66 +open-meteo_python-requests_pr95 +opencobra_optlang_pr259 +opencobra_optlang_pr269 +openedx_api-doc-tools_pr28 +openedx_api-doc-tools_pr53 +openedx_codejail_pr105 +openedx_codejail_pr106 +openedx_codejail_pr141 +openedx_codejail_pr151 +openedx_codejail_pr167 +openedx_codejail_pr201 +openedx_codejail_pr207 +openedx_codejail_pr99 +openedx_django-user-tasks_pr148 +openedx_django-user-tasks_pr151 +openedx_django-user-tasks_pr304 +openedx_django-user-tasks_pr323 +openedx_edx-celeryutils_pr101 +openedx_edx-celeryutils_pr45 +openedx_edx-django-utils_pr10 +openedx_edx-django-utils_pr11 +openedx_edx-django-utils_pr118 +openedx_edx-django-utils_pr12 +openedx_edx-django-utils_pr137 +openedx_edx-django-utils_pr146 +openedx_edx-django-utils_pr156 +openedx_edx-django-utils_pr165 +openedx_edx-django-utils_pr17 +openedx_edx-django-utils_pr188 +openedx_edx-django-utils_pr200 +openedx_edx-django-utils_pr209 +openedx_edx-django-utils_pr210 +openedx_edx-django-utils_pr215 +openedx_edx-django-utils_pr242 +openedx_edx-django-utils_pr246 +openedx_edx-django-utils_pr26 +openedx_edx-django-utils_pr27 +openedx_edx-django-utils_pr28 +openedx_edx-django-utils_pr289 +openedx_edx-django-utils_pr30 +openedx_edx-django-utils_pr313 +openedx_edx-django-utils_pr327 +openedx_edx-django-utils_pr330 +openedx_edx-django-utils_pr357 +openedx_edx-django-utils_pr397 +openedx_edx-django-utils_pr415 +openedx_edx-django-utils_pr416 +openedx_edx-django-utils_pr418 +openedx_edx-django-utils_pr44 +openedx_edx-django-utils_pr45 +openedx_edx-django-utils_pr451 +openedx_edx-django-utils_pr457 +openedx_edx-django-utils_pr464 +openedx_edx-django-utils_pr467 +openedx_edx-django-utils_pr48 +openedx_edx-django-utils_pr485 +openedx_edx-django-utils_pr496 +openedx_edx-django-utils_pr527 +openedx_edx-django-utils_pr53 +openedx_edx-django-utils_pr58 +openedx_edx-django-utils_pr64 +openedx_edx-django-utils_pr65 +openedx_edx-django-utils_pr68 +openedx_edx-django-utils_pr70 +openedx_edx-django-utils_pr73 +openedx_edx-django-utils_pr9 +openedx_edx-drf-extensions_pr254 +openedx_edx-drf-extensions_pr268 +openedx_edx-drf-extensions_pr270 +openedx_edx-drf-extensions_pr275 +openedx_edx-drf-extensions_pr287 +openedx_edx-drf-extensions_pr311 +openedx_edx-drf-extensions_pr317 +openedx_edx-drf-extensions_pr324 +openedx_edx-drf-extensions_pr331 +openedx_edx-drf-extensions_pr354 +openedx_edx-drf-extensions_pr388 +openedx_edx-drf-extensions_pr392 +openedx_edx-drf-extensions_pr404 +openedx_edx-drf-extensions_pr406 +openedx_edx-drf-extensions_pr419 +openedx_edx-drf-extensions_pr422 +openedx_edx-drf-extensions_pr425 +openedx_edx-drf-extensions_pr433 +openedx_edx-drf-extensions_pr442 +openedx_edx-lint_pr41 +openedx_edx-lint_pr44 +openedx_edx-rest-api-client_pr30 +openedx_edx-rest-api-client_pr32 +openedx_edx-rest-api-client_pr35 +openedx_edx-rest-api-client_pr37 +openedx_edx-rest-api-client_pr38 +openedx_edx-rest-api-client_pr40 +openedx_openedx-events_pr104 +openedx_openedx-events_pr129 +openedx_openedx-events_pr131 +openedx_openedx-events_pr132 +openedx_openedx-events_pr152 +openedx_openedx-events_pr154 +openedx_openedx-events_pr168 +openedx_openedx-events_pr175 +openedx_openedx-events_pr179 +openedx_openedx-events_pr18 +openedx_openedx-events_pr181 +openedx_openedx-events_pr187 +openedx_openedx-events_pr189 +openedx_openedx-events_pr212 +openedx_openedx-events_pr219 +openedx_openedx-events_pr221 +openedx_openedx-events_pr229 +openedx_openedx-events_pr23 +openedx_openedx-events_pr230 +openedx_openedx-events_pr256 +openedx_openedx-events_pr26 +openedx_openedx-events_pr273 +openedx_openedx-events_pr287 +openedx_openedx-events_pr312 +openedx_openedx-events_pr318 +openedx_openedx-events_pr341 +openedx_openedx-events_pr37 +openedx_openedx-events_pr386 +openedx_openedx-events_pr394 +openedx_openedx-events_pr404 +openedx_openedx-events_pr41 +openedx_openedx-events_pr45 +openedx_openedx-events_pr455 +openedx_openedx-events_pr47 +openedx_openedx-events_pr478 +openedx_openedx-events_pr479 +openedx_openedx-events_pr51 +openedx_openedx-events_pr7 +openedx_openedx-events_pr81 +openedx_openedx-events_pr83 +openedx_openedx-events_pr84 +openedx_openedx-events_pr85 +openedx_openedx-events_pr95 +openedx_super-csv_pr100 +openedx_super-csv_pr107 +openedx_super-csv_pr216 +openeemeter_eeweather_pr10 +openeemeter_eeweather_pr12 +openeemeter_eeweather_pr20 +openeemeter_eeweather_pr24 +openeemeter_eeweather_pr26 +openeemeter_eeweather_pr3 +openeemeter_eeweather_pr30 +openeemeter_eeweather_pr32 +openeemeter_eeweather_pr38 +openeemeter_eeweather_pr39 +openeemeter_eeweather_pr42 +openeemeter_eeweather_pr44 +openeemeter_eeweather_pr50 +openeemeter_eeweather_pr65 +openeemeter_eeweather_pr7 +openeemeter_eeweather_pr8 +openeemeter_eeweather_pr89 +openqasm_oqpy_pr103 +openqasm_oqpy_pr18 +openqasm_oqpy_pr20 +openqasm_oqpy_pr24 +openqasm_oqpy_pr26 +openqasm_oqpy_pr28 +openqasm_oqpy_pr31 +openqasm_oqpy_pr34 +openqasm_oqpy_pr35 +openqasm_oqpy_pr38 +openqasm_oqpy_pr43 +openqasm_oqpy_pr44 +openqasm_oqpy_pr47 +openqasm_oqpy_pr48 +openqasm_oqpy_pr51 +openqasm_oqpy_pr53 +openqasm_oqpy_pr54 +openqasm_oqpy_pr58 +openqasm_oqpy_pr60 +openqasm_oqpy_pr64 +openqasm_oqpy_pr66 +openqasm_oqpy_pr68 +openqasm_oqpy_pr72 +openqasm_oqpy_pr73 +openqasm_oqpy_pr75 +openqasm_oqpy_pr77 +openqasm_oqpy_pr83 +openqasm_oqpy_pr86 +openqasm_oqpy_pr90 +openqasm_oqpy_pr93 +openqasm_oqpy_pr95 +openqasm_oqpy_pr99 +opensanctions_rigour_pr10 +opensanctions_rigour_pr113 +opensanctions_rigour_pr13 +opensanctions_rigour_pr137 +opensanctions_rigour_pr14 +opensanctions_rigour_pr145 +opensanctions_rigour_pr148 +opensanctions_rigour_pr149 +opensanctions_rigour_pr23 +opensanctions_rigour_pr64 +opensanctions_rigour_pr65 +opensanctions_rigour_pr68 +opensanctions_rigour_pr70 +opensanctions_rigour_pr76 +opensanctions_rigour_pr79 +openshift_openshift-client-python_pr113 +openshift_openshift-client-python_pr133 +openshift_openshift-client-python_pr161 +openshift_openshift-client-python_pr165 +openshift_openshift-client-python_pr58 +openshift_openshift-client-python_pr64 +openshift_openshift-client-python_pr83 +opentracing_basictracer-python_pr37 +opentracing_basictracer-python_pr43 +openwisp_django-swappable-models_pr33 +openwisp_django-swappable-models_pr57 +optimizely_python-sdk_pr102 +optimizely_python-sdk_pr104 +optimizely_python-sdk_pr107 +optimizely_python-sdk_pr111 +optimizely_python-sdk_pr113 +optimizely_python-sdk_pr119 +optimizely_python-sdk_pr123 +optimizely_python-sdk_pr128 +optimizely_python-sdk_pr136 +optimizely_python-sdk_pr140 +optimizely_python-sdk_pr141 +optimizely_python-sdk_pr144 +optimizely_python-sdk_pr149 +optimizely_python-sdk_pr150 +optimizely_python-sdk_pr151 +optimizely_python-sdk_pr153 +optimizely_python-sdk_pr155 +optimizely_python-sdk_pr156 +optimizely_python-sdk_pr167 +optimizely_python-sdk_pr169 +optimizely_python-sdk_pr170 +optimizely_python-sdk_pr171 +optimizely_python-sdk_pr174 +optimizely_python-sdk_pr176 +optimizely_python-sdk_pr180 +optimizely_python-sdk_pr182 +optimizely_python-sdk_pr184 +optimizely_python-sdk_pr191 +optimizely_python-sdk_pr194 +optimizely_python-sdk_pr20 +optimizely_python-sdk_pr205 +optimizely_python-sdk_pr211 +optimizely_python-sdk_pr213 +optimizely_python-sdk_pr214 +optimizely_python-sdk_pr217 +optimizely_python-sdk_pr218 +optimizely_python-sdk_pr228 +optimizely_python-sdk_pr234 +optimizely_python-sdk_pr235 +optimizely_python-sdk_pr267 +optimizely_python-sdk_pr268 +optimizely_python-sdk_pr271 +optimizely_python-sdk_pr275 +optimizely_python-sdk_pr279 +optimizely_python-sdk_pr282 +optimizely_python-sdk_pr285 +optimizely_python-sdk_pr287 +optimizely_python-sdk_pr293 +optimizely_python-sdk_pr3 +optimizely_python-sdk_pr300 +optimizely_python-sdk_pr302 +optimizely_python-sdk_pr303 +optimizely_python-sdk_pr322 +optimizely_python-sdk_pr325 +optimizely_python-sdk_pr338 +optimizely_python-sdk_pr339 +optimizely_python-sdk_pr342 +optimizely_python-sdk_pr347 +optimizely_python-sdk_pr351 +optimizely_python-sdk_pr353 +optimizely_python-sdk_pr356 +optimizely_python-sdk_pr361 +optimizely_python-sdk_pr367 +optimizely_python-sdk_pr378 +optimizely_python-sdk_pr384 +optimizely_python-sdk_pr385 +optimizely_python-sdk_pr389 +optimizely_python-sdk_pr393 +optimizely_python-sdk_pr396 +optimizely_python-sdk_pr398 +optimizely_python-sdk_pr399 +optimizely_python-sdk_pr401 +optimizely_python-sdk_pr405 +optimizely_python-sdk_pr406 +optimizely_python-sdk_pr408 +optimizely_python-sdk_pr409 +optimizely_python-sdk_pr410 +optimizely_python-sdk_pr411 +optimizely_python-sdk_pr412 +optimizely_python-sdk_pr413 +optimizely_python-sdk_pr414 +optimizely_python-sdk_pr416 +optimizely_python-sdk_pr418 +optimizely_python-sdk_pr419 +optimizely_python-sdk_pr423 +optimizely_python-sdk_pr424 +optimizely_python-sdk_pr428 +optimizely_python-sdk_pr430 +optimizely_python-sdk_pr433 +optimizely_python-sdk_pr440 +optimizely_python-sdk_pr443 +optimizely_python-sdk_pr445 +optimizely_python-sdk_pr448 +optimizely_python-sdk_pr454 +optimizely_python-sdk_pr459 +optimizely_python-sdk_pr46 +optimizely_python-sdk_pr55 +optimizely_python-sdk_pr57 +optimizely_python-sdk_pr58 +optimizely_python-sdk_pr61 +optimizely_python-sdk_pr68 +optimizely_python-sdk_pr70 +optimizely_python-sdk_pr71 +optimizely_python-sdk_pr73 +optimizely_python-sdk_pr75 +optimizely_python-sdk_pr77 +optimizely_python-sdk_pr80 +optimizely_python-sdk_pr81 +optimizely_python-sdk_pr85 +optimizely_python-sdk_pr86 +optimizely_python-sdk_pr87 +optimizely_python-sdk_pr88 +optimizely_python-sdk_pr89 +optimizely_python-sdk_pr92 +oras-project_oras-py_pr109 +oras-project_oras-py_pr131 +oras-project_oras-py_pr146 +oras-project_oras-py_pr150 +oras-project_oras-py_pr153 +oras-project_oras-py_pr161 +oras-project_oras-py_pr166 +oras-project_oras-py_pr176 +oras-project_oras-py_pr183 +oras-project_oras-py_pr192 +oras-project_oras-py_pr195 +oras-project_oras-py_pr206 +orsinium-labs_mypy-baseline_pr1 +orsinium-labs_mypy-baseline_pr20 +orsinium-labs_mypy-baseline_pr7 +orsinium_textdistance_pr71 +orsinium_textdistance_pr84 +orsinium_textdistance_pr89 +orsinium_textdistance_pr90 +osantana_prettyconf_pr25 +osantana_prettyconf_pr28 +osantana_prettyconf_pr29 +osantana_prettyconf_pr3 +osantana_prettyconf_pr30 +osantana_prettyconf_pr43 +ouhammmourachid_mermaid-py_pr105 +ouhammmourachid_mermaid-py_pr163 +ouhammmourachid_mermaid-py_pr26 +ouhammmourachid_mermaid-py_pr39 +oxan_djangorestframework-dataclasses_pr20 +oxan_djangorestframework-dataclasses_pr36 +oxan_djangorestframework-dataclasses_pr45 +oxan_djangorestframework-dataclasses_pr50 +oxan_djangorestframework-dataclasses_pr66 +oxan_djangorestframework-dataclasses_pr69 +oxan_djangorestframework-dataclasses_pr80 +oxan_djangorestframework-dataclasses_pr83 +oxan_djangorestframework-dataclasses_pr84 +oxigraph_oxrdflib_pr14 +oxigraph_oxrdflib_pr43 +oxigraph_oxrdflib_pr61 +p1c2u_jsonschema-path_pr172 +p1c2u_jsonschema-path_pr39 +p1c2u_jsonschema-path_pr58 +p1c2u_jsonschema-path_pr72 +p1c2u_jsonschema-spec_pr39 +p1c2u_jsonschema-spec_pr6 +p1c2u_jsonschema-spec_pr74 +p1c2u_pathable_pr10 +p1c2u_pathable_pr13 +p1c2u_pathable_pr40 +p1c2u_pathable_pr43 +p1c2u_pathable_pr6 +p1c2u_pathable_pr8 +p2p-ld_numpydantic_pr11 +p2p-ld_numpydantic_pr12 +p2p-ld_numpydantic_pr14 +p2p-ld_numpydantic_pr15 +p2p-ld_numpydantic_pr16 +p2p-ld_numpydantic_pr24 +p2p-ld_numpydantic_pr40 +p2p-ld_numpydantic_pr43 +p2p-ld_numpydantic_pr47 +p2p-ld_numpydantic_pr6 +p2p-ld_numpydantic_pr8 +pahaz_sshtunnel_pr106 +pahaz_sshtunnel_pr112 +pahaz_sshtunnel_pr123 +pahaz_sshtunnel_pr149 +pahaz_sshtunnel_pr205 +pahaz_sshtunnel_pr209 +pahaz_sshtunnel_pr214 +pahaz_sshtunnel_pr216 +pahaz_sshtunnel_pr247 +pahaz_sshtunnel_pr75 +pahaz_sshtunnel_pr83 +pahaz_sshtunnel_pr88 +pallets-eco_blinker_pr141 +pallets-eco_blinker_pr145 +pallets-eco_blinker_pr150 +pallets-eco_blinker_pr76 +pallets-eco_blinker_pr83 +pallets-eco_blinker_pr84 +pallets-eco_blinker_pr94 +pallets-eco_flask-admin_pr1009 +pallets-eco_flask-admin_pr1010 +pallets-eco_flask-admin_pr1013 +pallets-eco_flask-admin_pr1017 +pallets-eco_flask-admin_pr1023 +pallets-eco_flask-admin_pr1038 +pallets-eco_flask-admin_pr1039 +pallets-eco_flask-admin_pr1046 +pallets-eco_flask-admin_pr1052 +pallets-eco_flask-admin_pr1053 +pallets-eco_flask-admin_pr1054 +pallets-eco_flask-admin_pr1069 +pallets-eco_flask-admin_pr1077 +pallets-eco_flask-admin_pr1080 +pallets-eco_flask-admin_pr1087 +pallets-eco_flask-admin_pr1099 +pallets-eco_flask-admin_pr1114 +pallets-eco_flask-admin_pr1137 +pallets-eco_flask-admin_pr1151 +pallets-eco_flask-admin_pr1154 +pallets-eco_flask-admin_pr1155 +pallets-eco_flask-admin_pr1160 +pallets-eco_flask-admin_pr1164 +pallets-eco_flask-admin_pr1177 +pallets-eco_flask-admin_pr1183 +pallets-eco_flask-admin_pr1186 +pallets-eco_flask-admin_pr1191 +pallets-eco_flask-admin_pr1194 +pallets-eco_flask-admin_pr1203 +pallets-eco_flask-admin_pr1209 +pallets-eco_flask-admin_pr1213 +pallets-eco_flask-admin_pr1215 +pallets-eco_flask-admin_pr1231 +pallets-eco_flask-admin_pr1236 +pallets-eco_flask-admin_pr1238 +pallets-eco_flask-admin_pr1242 +pallets-eco_flask-admin_pr1249 +pallets-eco_flask-admin_pr1255 +pallets-eco_flask-admin_pr1265 +pallets-eco_flask-admin_pr1266 +pallets-eco_flask-admin_pr1267 +pallets-eco_flask-admin_pr1288 +pallets-eco_flask-admin_pr1296 +pallets-eco_flask-admin_pr1309 +pallets-eco_flask-admin_pr1316 +pallets-eco_flask-admin_pr1320 +pallets-eco_flask-admin_pr1333 +pallets-eco_flask-admin_pr1334 +pallets-eco_flask-admin_pr1340 +pallets-eco_flask-admin_pr1346 +pallets-eco_flask-admin_pr1348 +pallets-eco_flask-admin_pr1350 +pallets-eco_flask-admin_pr1352 +pallets-eco_flask-admin_pr1361 +pallets-eco_flask-admin_pr1362 +pallets-eco_flask-admin_pr1379 +pallets-eco_flask-admin_pr1400 +pallets-eco_flask-admin_pr1409 +pallets-eco_flask-admin_pr1411 +pallets-eco_flask-admin_pr1415 +pallets-eco_flask-admin_pr1416 +pallets-eco_flask-admin_pr1429 +pallets-eco_flask-admin_pr1501 +pallets-eco_flask-admin_pr1510 +pallets-eco_flask-admin_pr815 +pallets-eco_flask-admin_pr819 +pallets-eco_flask-admin_pr824 +pallets-eco_flask-admin_pr831 +pallets-eco_flask-admin_pr832 +pallets-eco_flask-admin_pr833 +pallets-eco_flask-admin_pr843 +pallets-eco_flask-admin_pr860 +pallets-eco_flask-admin_pr862 +pallets-eco_flask-admin_pr865 +pallets-eco_flask-admin_pr866 +pallets-eco_flask-admin_pr879 +pallets-eco_flask-admin_pr891 +pallets-eco_flask-admin_pr900 +pallets-eco_flask-admin_pr901 +pallets-eco_flask-admin_pr902 +pallets-eco_flask-admin_pr919 +pallets-eco_flask-admin_pr933 +pallets-eco_flask-admin_pr942 +pallets-eco_flask-admin_pr950 +pallets-eco_flask-admin_pr952 +pallets-eco_flask-admin_pr962 +pallets-eco_flask-admin_pr963 +pallets-eco_flask-admin_pr994 +pallets-eco_flask-admin_pr996 +pallets-eco_flask-alembic_pr26 +pallets-eco_flask-alembic_pr29 +pallets-eco_flask-classful_pr160 +pallets-eco_flask-debugtoolbar_pr118 +pallets-eco_flask-debugtoolbar_pr218 +pallets-eco_flask-debugtoolbar_pr233 +pallets-eco_flask-debugtoolbar_pr242 +pallets-eco_flask-debugtoolbar_pr243 +pallets-eco_flask-debugtoolbar_pr250 +pallets-eco_flask-debugtoolbar_pr255 +pallets-eco_flask-debugtoolbar_pr274 +pallets-eco_flask-debugtoolbar_pr290 +pallets-eco_flask-debugtoolbar_pr86 +pallets-eco_flask-mail_pr219 +pallets-eco_flask-mail_pr221 +pallets-eco_flask-pydantic_pr44 +pallets-eco_flask-sqlalchemy_pr467 +pallets-eco_flask-sqlalchemy_pr931 +pallets-eco_flask-sqlalchemy_pr943 +pallets-eco_wtforms_pr389 +pallets-eco_wtforms_pr395 +pallets-eco_wtforms_pr400 +pallets-eco_wtforms_pr403 +pallets-eco_wtforms_pr407 +pallets-eco_wtforms_pr409 +pallets-eco_wtforms_pr410 +pallets-eco_wtforms_pr413 +pallets-eco_wtforms_pr429 +pallets-eco_wtforms_pr451 +pallets-eco_wtforms_pr463 +pallets-eco_wtforms_pr467 +pallets-eco_wtforms_pr475 +pallets-eco_wtforms_pr493 +pallets-eco_wtforms_pr524 +pallets-eco_wtforms_pr537 +pallets-eco_wtforms_pr548 +pallets-eco_wtforms_pr568 +pallets-eco_wtforms_pr573 +pallets-eco_wtforms_pr592 +pallets-eco_wtforms_pr596 +pallets-eco_wtforms_pr598 +pallets-eco_wtforms_pr601 +pallets-eco_wtforms_pr605 +pallets-eco_wtforms_pr608 +pallets-eco_wtforms_pr614 +pallets-eco_wtforms_pr615 +pallets-eco_wtforms_pr642 +pallets-eco_wtforms_pr667 +pallets-eco_wtforms_pr675 +pallets-eco_wtforms_pr688 +pallets-eco_wtforms_pr694 +pallets-eco_wtforms_pr703 +pallets-eco_wtforms_pr710 +pallets-eco_wtforms_pr729 +pallets-eco_wtforms_pr739 +pallets-eco_wtforms_pr741 +pallets-eco_wtforms_pr761 +pallets-eco_wtforms_pr765 +pallets-eco_wtforms_pr807 +pallets-eco_wtforms_pr808 +pallets-eco_wtforms_pr809 +pallets-eco_wtforms_pr810 +pallets-eco_wtforms_pr816 +pallets-eco_wtforms_pr858 +pallets-eco_wtforms_pr862 +pallets-eco_wtforms_pr880 +pallets_click_pr1000 +pallets_click_pr1002 +pallets_click_pr1005 +pallets_click_pr1008 +pallets_click_pr1014 +pallets_click_pr1050 +pallets_click_pr1061 +pallets_click_pr1091 +pallets_click_pr1098 +pallets_click_pr1099 +pallets_click_pr1105 +pallets_click_pr1108 +pallets_click_pr1115 +pallets_click_pr1172 +pallets_click_pr1191 +pallets_click_pr1273 +pallets_click_pr1295 +pallets_click_pr1312 +pallets_click_pr1332 +pallets_click_pr1348 +pallets_click_pr1354 +pallets_click_pr1355 +pallets_click_pr1402 +pallets_click_pr1405 +pallets_click_pr1429 +pallets_click_pr1455 +pallets_click_pr1492 +pallets_click_pr1497 +pallets_click_pr1517 +pallets_click_pr1535 +pallets_click_pr1551 +pallets_click_pr1566 +pallets_click_pr1582 +pallets_click_pr1586 +pallets_click_pr1587 +pallets_click_pr1594 +pallets_click_pr1604 +pallets_click_pr1606 +pallets_click_pr1609 +pallets_click_pr1614 +pallets_click_pr1615 +pallets_click_pr1617 +pallets_click_pr1618 +pallets_click_pr1621 +pallets_click_pr1622 +pallets_click_pr1623 +pallets_click_pr1630 +pallets_click_pr1679 +pallets_click_pr1683 +pallets_click_pr1687 +pallets_click_pr1693 +pallets_click_pr1695 +pallets_click_pr1698 +pallets_click_pr1709 +pallets_click_pr1715 +pallets_click_pr1755 +pallets_click_pr1772 +pallets_click_pr1785 +pallets_click_pr1786 +pallets_click_pr1793 +pallets_click_pr1803 +pallets_click_pr1804 +pallets_click_pr1805 +pallets_click_pr1816 +pallets_click_pr1820 +pallets_click_pr1822 +pallets_click_pr1825 +pallets_click_pr1829 +pallets_click_pr1830 +pallets_click_pr1834 +pallets_click_pr1836 +pallets_click_pr1840 +pallets_click_pr1846 +pallets_click_pr1848 +pallets_click_pr1850 +pallets_click_pr1852 +pallets_click_pr1856 +pallets_click_pr1872 +pallets_click_pr1896 +pallets_click_pr1962 +pallets_click_pr1964 +pallets_click_pr1987 +pallets_click_pr1990 +pallets_click_pr1998 +pallets_click_pr2130 +pallets_click_pr2151 +pallets_click_pr2201 +pallets_click_pr2203 +pallets_click_pr2212 +pallets_click_pr2215 +pallets_click_pr2217 +pallets_click_pr2219 +pallets_click_pr2223 +pallets_click_pr2270 +pallets_click_pr2271 +pallets_click_pr2397 +pallets_click_pr2509 +pallets_click_pr2517 +pallets_click_pr2523 +pallets_click_pr2591 +pallets_click_pr2592 +pallets_click_pr2599 +pallets_click_pr2604 +pallets_click_pr2622 +pallets_click_pr2630 +pallets_click_pr2680 +pallets_click_pr2696 +pallets_click_pr2727 +pallets_click_pr2788 +pallets_click_pr2796 +pallets_click_pr2800 +pallets_click_pr2804 +pallets_click_pr2818 +pallets_click_pr2829 +pallets_click_pr2840 +pallets_click_pr2940 +pallets_click_pr3008 +pallets_click_pr3030 +pallets_click_pr3031 +pallets_click_pr3048 +pallets_click_pr3058 +pallets_click_pr453 +pallets_click_pr475 +pallets_click_pr487 +pallets_click_pr496 +pallets_click_pr500 +pallets_click_pr538 +pallets_click_pr557 +pallets_click_pr650 +pallets_click_pr664 +pallets_click_pr681 +pallets_click_pr706 +pallets_click_pr709 +pallets_click_pr710 +pallets_click_pr755 +pallets_click_pr775 +pallets_click_pr787 +pallets_click_pr799 +pallets_click_pr806 +pallets_click_pr809 +pallets_click_pr830 +pallets_click_pr842 +pallets_click_pr863 +pallets_click_pr865 +pallets_click_pr868 +pallets_click_pr869 +pallets_click_pr874 +pallets_click_pr887 +pallets_click_pr889 +pallets_click_pr938 +pallets_click_pr991 +pallets_click_pr994 +pallets_click_pr996 +pallets_click_pr997 +pallets_click_pr999 +pallets_flask_pr3563 +pallets_flask_pr3574 +pallets_flask_pr3684 +pallets_itsdangerous_pr113 +pallets_itsdangerous_pr141 +pallets_itsdangerous_pr154 +pallets_itsdangerous_pr186 +pallets_itsdangerous_pr273 +pallets_itsdangerous_pr374 +pallets_jinja_pr1002 +pallets_jinja_pr1008 +pallets_jinja_pr1013 +pallets_jinja_pr1014 +pallets_jinja_pr1018 +pallets_jinja_pr1047 +pallets_jinja_pr1064 +pallets_jinja_pr1079 +pallets_jinja_pr1080 +pallets_jinja_pr1086 +pallets_jinja_pr1090 +pallets_jinja_pr1095 +pallets_jinja_pr1098 +pallets_jinja_pr1101 +pallets_jinja_pr1105 +pallets_jinja_pr1109 +pallets_jinja_pr1110 +pallets_jinja_pr1113 +pallets_jinja_pr1114 +pallets_jinja_pr1117 +pallets_jinja_pr1167 +pallets_jinja_pr1169 +pallets_jinja_pr1195 +pallets_jinja_pr1233 +pallets_jinja_pr1240 +pallets_jinja_pr1241 +pallets_jinja_pr1243 +pallets_jinja_pr1244 +pallets_jinja_pr1247 +pallets_jinja_pr1248 +pallets_jinja_pr1294 +pallets_jinja_pr1303 +pallets_jinja_pr1339 +pallets_jinja_pr1360 +pallets_jinja_pr1363 +pallets_jinja_pr1366 +pallets_jinja_pr1374 +pallets_jinja_pr1383 +pallets_jinja_pr1393 +pallets_jinja_pr1465 +pallets_jinja_pr1511 +pallets_jinja_pr1559 +pallets_jinja_pr1564 +pallets_jinja_pr1613 +pallets_jinja_pr1614 +pallets_jinja_pr673 +pallets_jinja_pr766 +pallets_jinja_pr824 +pallets_jinja_pr828 +pallets_jinja_pr922 +pallets_jinja_pr923 +pallets_jinja_pr938 +pallets_jinja_pr983 +pallets_jinja_pr993 +pallets_jinja_pr994 +pallets_markupsafe_pr100 +pallets_markupsafe_pr224 +pallets_werkzeug_pr1458 +pallets_werkzeug_pr1537 +pallets_werkzeug_pr1550 +pallets_werkzeug_pr1567 +pallets_werkzeug_pr1574 +pallets_werkzeug_pr1577 +pallets_werkzeug_pr1590 +pallets_werkzeug_pr1605 +pallets_werkzeug_pr1617 +pallets_werkzeug_pr1618 +pallets_werkzeug_pr1639 +pallets_werkzeug_pr1640 +pallets_werkzeug_pr1654 +pallets_werkzeug_pr1694 +pallets_werkzeug_pr1699 +pallets_werkzeug_pr1709 +pallets_werkzeug_pr1770 +pallets_werkzeug_pr2287 +pamelafox_axe-playwright-python_pr3 +pamelafox_openai-messages-token-helper_pr11 +pamelafox_openai-messages-token-helper_pr13 +pamelafox_openai-messages-token-helper_pr14 +pamelafox_openai-messages-token-helper_pr15 +pamelafox_openai-messages-token-helper_pr19 +pamelafox_openai-messages-token-helper_pr2 +pamelafox_openai-messages-token-helper_pr22 +pamelafox_openai-messages-token-helper_pr5 +pangeo-data_rechunker_pr134 +pangeo-data_rechunker_pr22 +pangeo-data_rechunker_pr27 +pangeo-data_rechunker_pr30 +pangeo-data_rechunker_pr48 +pangeo-data_rechunker_pr89 +pangeo-data_rechunker_pr93 +pappasam_toml-sort_pr3 +pappasam_toml-sort_pr4 +pappasam_toml-sort_pr77 +pappasam_toml-sort_pr91 +pdfminer_pdfminer.six_pr1 +pdfminer_pdfminer.six_pr121 +pdfminer_pdfminer.six_pr125 +pdfminer_pdfminer.six_pr129 +pdfminer_pdfminer.six_pr142 +pdfminer_pdfminer.six_pr158 +pdfminer_pdfminer.six_pr16 +pdfminer_pdfminer.six_pr33 +pdfminer_pdfminer.six_pr5 +pdfminer_pdfminer.six_pr88 +pdm-project_pdm-backend_pr105 +pdm-project_pdm-backend_pr114 +pdm-project_pdm-backend_pr120 +pdm-project_pdm-backend_pr127 +pdm-project_pdm-backend_pr132 +pdm-project_pdm-backend_pr14 +pdm-project_pdm-backend_pr16 +pdm-project_pdm-backend_pr17 +pdm-project_pdm-backend_pr19 +pdm-project_pdm-backend_pr2 +pdm-project_pdm-backend_pr20 +pdm-project_pdm-backend_pr21 +pdm-project_pdm-backend_pr26 +pdm-project_pdm-backend_pr27 +pdm-project_pdm-backend_pr28 +pdm-project_pdm-backend_pr36 +pdm-project_pdm-backend_pr4 +pdm-project_pdm-backend_pr42 +pdm-project_pdm-backend_pr45 +pdm-project_pdm-backend_pr49 +pdm-project_pdm-backend_pr5 +pdm-project_pdm-backend_pr53 +pdm-project_pdm-backend_pr59 +pdm-project_pdm-backend_pr65 +pdm-project_pdm-backend_pr73 +pdm-project_pdm-backend_pr75 +pdm-project_pdm-backend_pr8 +pdm-project_pdm-backend_pr85 +pdm-project_pdm-backend_pr88 +pdm-project_pdm-backend_pr93 +pdm-project_pdm-backend_pr95 +pdm-project_pdm-backend_pr96 +pdm-project_pdm-backend_pr98 +pecan_pecan_pr140 +pecan_pecan_pr160 +pecan_pecan_pr164 +pecan_pecan_pr166 +pecan_pecan_pr169 +pepkit_pephubclient_pr37 +pepkit_peppy_pr390 +pepkit_peppy_pr398 +pepkit_peppy_pr407 +pepkit_peppy_pr415 +pepkit_peppy_pr425 +pepkit_peppy_pr426 +pepkit_peppy_pr453 +pepkit_peppy_pr472 +pepkit_peppy_pr485 +pepkit_peppy_pr489 +pepkit_peppy_pr494 +pepkit_peppy_pr495 +pepkit_peppy_pr500 +pepkit_pipestat_pr136 +pepkit_pipestat_pr165 +pepkit_pipestat_pr194 +pepkit_pipestat_pr198 +pepkit_pipestat_pr208 +pepkit_pipestat_pr216 +perrygeo_python-rasterstats_pr279 +perrygeo_python-rasterstats_pr280 +perrygeo_python-rasterstats_pr290 +perrygeo_python-rasterstats_pr299 +perrygeo_python-rasterstats_pr300 +perrygeo_python-rasterstats_pr301 +perrygeo_python-rasterstats_pr310 +peter-wangxu_persist-queue_pr12 +peter-wangxu_persist-queue_pr17 +peter-wangxu_persist-queue_pr20 +peter-wangxu_persist-queue_pr47 +peter-wangxu_persist-queue_pr53 +peter-wangxu_persist-queue_pr61 +peterbe_hashin_pr106 +peterbe_hashin_pr107 +peterbe_hashin_pr109 +peterbe_hashin_pr110 +peterbe_hashin_pr114 +peterbe_hashin_pr117 +peterbe_hashin_pr125 +peterbe_hashin_pr131 +peterbe_hashin_pr159 +peterbe_hashin_pr186 +peterbe_hashin_pr214 +peterbe_hashin_pr22 +peterbe_hashin_pr65 +peterbe_hashin_pr72 +peterbe_hashin_pr74 +peterbe_hashin_pr77 +peterbe_hashin_pr83 +peterbe_hashin_pr88 +peterbe_hashin_pr91 +peterbe_hashin_pr95 +peterbe_premailer_pr108 +peterbe_premailer_pr112 +peterbe_premailer_pr116 +peterbe_premailer_pr124 +peterbe_premailer_pr126 +peterbe_premailer_pr135 +peterbe_premailer_pr136 +peterbe_premailer_pr138 +peterbe_premailer_pr155 +peterbe_premailer_pr160 +peterbe_premailer_pr165 +peterbe_premailer_pr188 +peterbe_premailer_pr200 +peterbe_premailer_pr208 +peterbe_premailer_pr87 +peterbe_premailer_pr92 +peterbe_premailer_pr99 +peterdemin_pip-compile-multi_pr1 +peterdemin_pip-compile-multi_pr11 +peterdemin_pip-compile-multi_pr2 +peterdemin_pip-compile-multi_pr252 +peterdemin_pip-compile-multi_pr288 +peterdemin_pip-compile-multi_pr483 +peterdemin_pip-compile-multi_pr6 +peterdemin_pip-compile-multi_pr8 +petl-developers_petl_pr342 +petl-developers_petl_pr359 +petl-developers_petl_pr361 +petl-developers_petl_pr362 +petl-developers_petl_pr367 +petl-developers_petl_pr400 +petl-developers_petl_pr402 +petl-developers_petl_pr408 +petl-developers_petl_pr414 +petl-developers_petl_pr417 +petl-developers_petl_pr421 +petl-developers_petl_pr460 +petl-developers_petl_pr463 +pfmoore_editables_pr18 +pfnet_pysen_pr38 +pgjones_quart-rate-limiter_pr12 +phfaist_pylatexenc_pr66 +philpep_testinfra_pr627 +philpep_testinfra_pr630 +philpep_testinfra_pr635 +philpep_testinfra_pr642 +philpep_testinfra_pr658 +philpep_testinfra_pr662 +philpep_testinfra_pr671 +philpep_testinfra_pr681 +philpep_testinfra_pr695 +philpep_testinfra_pr717 +philpep_testinfra_pr723 +philpep_testinfra_pr724 +philpep_testinfra_pr741 +philpep_testinfra_pr743 +philpep_testinfra_pr751 +philpep_testinfra_pr763 +philpep_testinfra_pr769 +philpep_testinfra_pr781 +philpep_testinfra_pr792 +piccolo-orm_targ_pr2 +pinax_django-user-accounts_pr323 +pinax_django-user-accounts_pr327 +pinax_django-user-accounts_pr363 +pinax_django-user-accounts_pr364 +pinax_django-user-accounts_pr370 +pinax_django-user-accounts_pr376 +pinterest_pymemcache_pr115 +pinterest_pymemcache_pr128 +pinterest_pymemcache_pr131 +pinterest_pymemcache_pr146 +pinterest_pymemcache_pr165 +pinterest_pymemcache_pr179 +pinterest_pymemcache_pr18 +pinterest_pymemcache_pr180 +pinterest_pymemcache_pr182 +pinterest_pymemcache_pr183 +pinterest_pymemcache_pr20 +pinterest_pymemcache_pr23 +pinterest_pymemcache_pr237 +pinterest_pymemcache_pr36 +pinterest_pymemcache_pr39 +pinterest_pymemcache_pr395 +pinterest_pymemcache_pr471 +pipecat-ai_pipecat-flows_pr102 +pipecat-ai_pipecat-flows_pr115 +pipecat-ai_pipecat-flows_pr128 +pipecat-ai_pipecat-flows_pr140 +pipecat-ai_pipecat-flows_pr171 +pipecat-ai_pipecat-flows_pr174 +pipecat-ai_pipecat-flows_pr191 +pipecat-ai_pipecat-flows_pr195 +pipecat-ai_pipecat-flows_pr201 +pipecat-ai_pipecat-flows_pr212 +pipecat-ai_pipecat-flows_pr214 +pipecat-ai_pipecat-flows_pr57 +pipecat-ai_pipecat-flows_pr59 +pipecat-ai_pipecat-flows_pr63 +pipecat-ai_pipecat-flows_pr68 +pipecat-ai_pipecat-flows_pr69 +pipecat-ai_pipecat-flows_pr75 +pipecat-ai_pipecat-flows_pr82 +pipecat-ai_pipecat-flows_pr83 +pipecat-ai_pipecat-flows_pr87 +pipecat-ai_pipecat-flows_pr88 +pipecat-ai_pipecat-flows_pr90 +pipecat-ai_pipecat-flows_pr91 +pipecat-ai_pipecat-flows_pr92 +pipecat-ai_pipecat-flows_pr93 +piskvorky_sqlitedict_pr105 +piskvorky_sqlitedict_pr113 +piskvorky_sqlitedict_pr128 +piskvorky_sqlitedict_pr161 +piskvorky_sqlitedict_pr38 +piskvorky_sqlitedict_pr50 +piskvorky_sqlitedict_pr55 +piskvorky_sqlitedict_pr65 +piskvorky_sqlitedict_pr72 +piskvorky_sqlitedict_pr94 +plamere_spotipy_pr1036 +plamere_spotipy_pr1042 +plamere_spotipy_pr1052 +plamere_spotipy_pr1059 +plamere_spotipy_pr1108 +plamere_spotipy_pr1141 +plamere_spotipy_pr1161 +plamere_spotipy_pr1177 +plamere_spotipy_pr1178 +plamere_spotipy_pr1189 +plamere_spotipy_pr125 +plamere_spotipy_pr893 +plamere_spotipy_pr901 +plamere_spotipy_pr919 +plamere_spotipy_pr941 +plamere_spotipy_pr986 +pnpnpn_timeout-decorator_pr65 +podhmo_dictknife_pr101 +podhmo_dictknife_pr102 +podhmo_dictknife_pr103 +podhmo_dictknife_pr108 +podhmo_dictknife_pr111 +podhmo_dictknife_pr112 +podhmo_dictknife_pr113 +podhmo_dictknife_pr114 +podhmo_dictknife_pr115 +podhmo_dictknife_pr116 +podhmo_dictknife_pr117 +podhmo_dictknife_pr126 +podhmo_dictknife_pr127 +podhmo_dictknife_pr132 +podhmo_dictknife_pr133 +podhmo_dictknife_pr136 +podhmo_dictknife_pr137 +podhmo_dictknife_pr139 +podhmo_dictknife_pr160 +podhmo_dictknife_pr162 +podhmo_dictknife_pr163 +podhmo_dictknife_pr173 +podhmo_dictknife_pr174 +podhmo_dictknife_pr177 +podhmo_dictknife_pr182 +podhmo_dictknife_pr183 +podhmo_dictknife_pr19 +podhmo_dictknife_pr196 +podhmo_dictknife_pr22 +podhmo_dictknife_pr23 +podhmo_dictknife_pr24 +podhmo_dictknife_pr32 +podhmo_dictknife_pr44 +podhmo_dictknife_pr46 +podhmo_dictknife_pr50 +podhmo_dictknife_pr54 +podhmo_dictknife_pr55 +podhmo_dictknife_pr62 +podhmo_dictknife_pr72 +podhmo_dictknife_pr76 +podhmo_dictknife_pr78 +podhmo_dictknife_pr80 +podhmo_dictknife_pr82 +podhmo_python-node-semver_pr14 +podhmo_python-node-semver_pr19 +podhmo_python-node-semver_pr44 +polkascan_py-scale-codec_pr107 +polkascan_py-scale-codec_pr116 +polkascan_py-scale-codec_pr22 +polkascan_py-scale-codec_pr72 +polkascan_py-scale-codec_pr76 +polkascan_py-scale-codec_pr91 +polkascan_py-scale-codec_pr92 +polkascan_py-scale-codec_pr93 +polm_cutlet_pr1 +populationgenomics_production-pipelines_pr427 +populationgenomics_production-pipelines_pr432 +populationgenomics_production-pipelines_pr433 +populationgenomics_production-pipelines_pr445 +populationgenomics_production-pipelines_pr448 +populationgenomics_production-pipelines_pr450 +populationgenomics_production-pipelines_pr453 +populationgenomics_production-pipelines_pr459 +populationgenomics_production-pipelines_pr462 +populationgenomics_production-pipelines_pr470 +populationgenomics_production-pipelines_pr472 +populationgenomics_production-pipelines_pr478 +populationgenomics_production-pipelines_pr479 +populationgenomics_production-pipelines_pr480 +populationgenomics_production-pipelines_pr481 +populationgenomics_production-pipelines_pr483 +populationgenomics_production-pipelines_pr490 +populationgenomics_production-pipelines_pr493 +populationgenomics_production-pipelines_pr496 +populationgenomics_production-pipelines_pr507 +populationgenomics_production-pipelines_pr508 +populationgenomics_production-pipelines_pr511 +populationgenomics_production-pipelines_pr513 +populationgenomics_production-pipelines_pr515 +populationgenomics_production-pipelines_pr518 +populationgenomics_production-pipelines_pr519 +populationgenomics_production-pipelines_pr522 +populationgenomics_production-pipelines_pr529 +populationgenomics_production-pipelines_pr530 +populationgenomics_production-pipelines_pr531 +populationgenomics_production-pipelines_pr534 +populationgenomics_production-pipelines_pr535 +populationgenomics_production-pipelines_pr537 +populationgenomics_production-pipelines_pr544 +populationgenomics_production-pipelines_pr549 +populationgenomics_production-pipelines_pr551 +populationgenomics_production-pipelines_pr555 +populationgenomics_production-pipelines_pr556 +populationgenomics_production-pipelines_pr566 +populationgenomics_production-pipelines_pr576 +populationgenomics_production-pipelines_pr577 +populationgenomics_production-pipelines_pr583 +populationgenomics_production-pipelines_pr589 +populationgenomics_production-pipelines_pr592 +populationgenomics_production-pipelines_pr593 +populationgenomics_production-pipelines_pr600 +populationgenomics_production-pipelines_pr601 +populationgenomics_production-pipelines_pr603 +populationgenomics_production-pipelines_pr609 +populationgenomics_production-pipelines_pr616 +populationgenomics_production-pipelines_pr621 +populationgenomics_production-pipelines_pr623 +populationgenomics_production-pipelines_pr626 +populationgenomics_production-pipelines_pr630 +populationgenomics_production-pipelines_pr635 +populationgenomics_production-pipelines_pr637 +populationgenomics_production-pipelines_pr645 +populationgenomics_production-pipelines_pr648 +populationgenomics_production-pipelines_pr649 +populationgenomics_production-pipelines_pr653 +populationgenomics_production-pipelines_pr654 +populationgenomics_production-pipelines_pr659 +populationgenomics_production-pipelines_pr661 +populationgenomics_production-pipelines_pr672 +populationgenomics_production-pipelines_pr675 +populationgenomics_production-pipelines_pr677 +populationgenomics_production-pipelines_pr685 +populationgenomics_production-pipelines_pr690 +populationgenomics_production-pipelines_pr691 +populationgenomics_production-pipelines_pr699 +populationgenomics_production-pipelines_pr701 +populationgenomics_production-pipelines_pr704 +populationgenomics_production-pipelines_pr705 +populationgenomics_production-pipelines_pr718 +populationgenomics_production-pipelines_pr721 +populationgenomics_production-pipelines_pr723 +populationgenomics_production-pipelines_pr745 +populationgenomics_production-pipelines_pr754 +populationgenomics_production-pipelines_pr764 +populationgenomics_production-pipelines_pr770 +populationgenomics_production-pipelines_pr784 +populationgenomics_production-pipelines_pr785 +populationgenomics_production-pipelines_pr787 +populationgenomics_production-pipelines_pr789 +populationgenomics_production-pipelines_pr794 +populationgenomics_production-pipelines_pr796 +populationgenomics_production-pipelines_pr798 +populationgenomics_production-pipelines_pr806 +populationgenomics_production-pipelines_pr807 +populationgenomics_production-pipelines_pr816 +populationgenomics_production-pipelines_pr818 +populationgenomics_production-pipelines_pr819 +populationgenomics_production-pipelines_pr821 +populationgenomics_production-pipelines_pr824 +populationgenomics_production-pipelines_pr825 +populationgenomics_production-pipelines_pr829 +populationgenomics_production-pipelines_pr831 +populationgenomics_production-pipelines_pr836 +populationgenomics_production-pipelines_pr845 +populationgenomics_production-pipelines_pr846 +populationgenomics_production-pipelines_pr847 +populationgenomics_production-pipelines_pr850 +populationgenomics_production-pipelines_pr851 +populationgenomics_production-pipelines_pr860 +populationgenomics_production-pipelines_pr861 +populationgenomics_production-pipelines_pr863 +populationgenomics_production-pipelines_pr874 +populationgenomics_production-pipelines_pr879 +populationgenomics_production-pipelines_pr880 +posthog_drf-exceptions-hog_pr13 +posthog_drf-exceptions-hog_pr29 +posthog_drf-exceptions-hog_pr39 +praw-dev_asyncprawcore_pr104 +praw-dev_asyncprawcore_pr113 +praw-dev_asyncprawcore_pr51 +praw-dev_asyncprawcore_pr67 +praw-dev_asyncprawcore_pr97 +praw-dev_praw_pr394 +praw-dev_praw_pr563 +praw-dev_praw_pr565 +praw-dev_praw_pr575 +praw-dev_praw_pr576 +praw-dev_praw_pr591 +praw-dev_praw_pr602 +praw-dev_praw_pr603 +praw-dev_praw_pr606 +praw-dev_praw_pr612 +praw-dev_praw_pr618 +praw-dev_praw_pr625 +praw-dev_praw_pr637 +praw-dev_praw_pr654 +praw-dev_prawcore_pr105 +praw-dev_prawcore_pr112 +praw-dev_prawcore_pr115 +praw-dev_prawcore_pr116 +praw-dev_prawcore_pr117 +praw-dev_prawcore_pr119 +praw-dev_prawcore_pr122 +praw-dev_prawcore_pr13 +praw-dev_prawcore_pr147 +praw-dev_prawcore_pr15 +praw-dev_prawcore_pr16 +praw-dev_prawcore_pr165 +praw-dev_prawcore_pr19 +praw-dev_prawcore_pr197 +praw-dev_prawcore_pr206 +praw-dev_prawcore_pr24 +praw-dev_prawcore_pr244 +praw-dev_prawcore_pr25 +praw-dev_prawcore_pr26 +praw-dev_prawcore_pr27 +praw-dev_prawcore_pr28 +praw-dev_prawcore_pr3 +praw-dev_prawcore_pr32 +praw-dev_prawcore_pr4 +praw-dev_prawcore_pr40 +praw-dev_prawcore_pr42 +praw-dev_prawcore_pr45 +praw-dev_prawcore_pr46 +praw-dev_prawcore_pr48 +praw-dev_prawcore_pr49 +praw-dev_prawcore_pr5 +praw-dev_prawcore_pr51 +praw-dev_prawcore_pr52 +praw-dev_prawcore_pr54 +praw-dev_prawcore_pr55 +praw-dev_prawcore_pr56 +praw-dev_prawcore_pr57 +praw-dev_prawcore_pr59 +praw-dev_prawcore_pr61 +praw-dev_prawcore_pr62 +praw-dev_prawcore_pr66 +praw-dev_prawcore_pr68 +praw-dev_prawcore_pr79 +praw-dev_prawcore_pr82 +praw-dev_prawcore_pr88 +praw-dev_prawcore_pr9 +praw-dev_prawcore_pr90 +praw-dev_prawcore_pr96 +praw-dev_prawcore_pr99 +pre-commit_identify_pr118 +pre-commit_identify_pr12 +pre-commit_identify_pr14 +pre-commit_identify_pr169 +pre-commit_identify_pr177 +pre-commit_identify_pr202 +pre-commit_identify_pr27 +pre-commit_identify_pr468 +pre-commit_identify_pr48 +pre-commit_identify_pr519 +pre-commit_identify_pr63 +pre-commit_identify_pr7 +pre-commit_identify_pr87 +pre-commit_pre-commit-hooks_pr1014 +pre-commit_pre-commit-hooks_pr102 +pre-commit_pre-commit-hooks_pr1031 +pre-commit_pre-commit-hooks_pr1039 +pre-commit_pre-commit-hooks_pr107 +pre-commit_pre-commit-hooks_pr109 +pre-commit_pre-commit-hooks_pr1095 +pre-commit_pre-commit-hooks_pr111 +pre-commit_pre-commit-hooks_pr116 +pre-commit_pre-commit-hooks_pr117 +pre-commit_pre-commit-hooks_pr1202 +pre-commit_pre-commit-hooks_pr133 +pre-commit_pre-commit-hooks_pr135 +pre-commit_pre-commit-hooks_pr147 +pre-commit_pre-commit-hooks_pr149 +pre-commit_pre-commit-hooks_pr15 +pre-commit_pre-commit-hooks_pr153 +pre-commit_pre-commit-hooks_pr172 +pre-commit_pre-commit-hooks_pr175 +pre-commit_pre-commit-hooks_pr18 +pre-commit_pre-commit-hooks_pr184 +pre-commit_pre-commit-hooks_pr185 +pre-commit_pre-commit-hooks_pr199 +pre-commit_pre-commit-hooks_pr202 +pre-commit_pre-commit-hooks_pr203 +pre-commit_pre-commit-hooks_pr205 +pre-commit_pre-commit-hooks_pr207 +pre-commit_pre-commit-hooks_pr213 +pre-commit_pre-commit-hooks_pr215 +pre-commit_pre-commit-hooks_pr22 +pre-commit_pre-commit-hooks_pr230 +pre-commit_pre-commit-hooks_pr24 +pre-commit_pre-commit-hooks_pr240 +pre-commit_pre-commit-hooks_pr243 +pre-commit_pre-commit-hooks_pr244 +pre-commit_pre-commit-hooks_pr249 +pre-commit_pre-commit-hooks_pr251 +pre-commit_pre-commit-hooks_pr254 +pre-commit_pre-commit-hooks_pr260 +pre-commit_pre-commit-hooks_pr271 +pre-commit_pre-commit-hooks_pr274 +pre-commit_pre-commit-hooks_pr275 +pre-commit_pre-commit-hooks_pr279 +pre-commit_pre-commit-hooks_pr28 +pre-commit_pre-commit-hooks_pr281 +pre-commit_pre-commit-hooks_pr283 +pre-commit_pre-commit-hooks_pr294 +pre-commit_pre-commit-hooks_pr297 +pre-commit_pre-commit-hooks_pr301 +pre-commit_pre-commit-hooks_pr327 +pre-commit_pre-commit-hooks_pr341 +pre-commit_pre-commit-hooks_pr35 +pre-commit_pre-commit-hooks_pr36 +pre-commit_pre-commit-hooks_pr360 +pre-commit_pre-commit-hooks_pr376 +pre-commit_pre-commit-hooks_pr384 +pre-commit_pre-commit-hooks_pr386 +pre-commit_pre-commit-hooks_pr39 +pre-commit_pre-commit-hooks_pr43 +pre-commit_pre-commit-hooks_pr469 +pre-commit_pre-commit-hooks_pr47 +pre-commit_pre-commit-hooks_pr478 +pre-commit_pre-commit-hooks_pr479 +pre-commit_pre-commit-hooks_pr48 +pre-commit_pre-commit-hooks_pr483 +pre-commit_pre-commit-hooks_pr488 +pre-commit_pre-commit-hooks_pr49 +pre-commit_pre-commit-hooks_pr502 +pre-commit_pre-commit-hooks_pr511 +pre-commit_pre-commit-hooks_pr522 +pre-commit_pre-commit-hooks_pr524 +pre-commit_pre-commit-hooks_pr545 +pre-commit_pre-commit-hooks_pr549 +pre-commit_pre-commit-hooks_pr55 +pre-commit_pre-commit-hooks_pr558 +pre-commit_pre-commit-hooks_pr56 +pre-commit_pre-commit-hooks_pr565 +pre-commit_pre-commit-hooks_pr571 +pre-commit_pre-commit-hooks_pr58 +pre-commit_pre-commit-hooks_pr582 +pre-commit_pre-commit-hooks_pr6 +pre-commit_pre-commit-hooks_pr626 +pre-commit_pre-commit-hooks_pr65 +pre-commit_pre-commit-hooks_pr674 +pre-commit_pre-commit-hooks_pr7 +pre-commit_pre-commit-hooks_pr719 +pre-commit_pre-commit-hooks_pr748 +pre-commit_pre-commit-hooks_pr771 +pre-commit_pre-commit-hooks_pr815 +pre-commit_pre-commit-hooks_pr85 +pre-commit_pre-commit-hooks_pr850 +pre-commit_pre-commit-hooks_pr87 +pre-commit_pre-commit-hooks_pr944 +predictive-analytics-lab_data-science-types_pr67 +predictive-analytics-lab_data-science-types_pr69 +predictive-analytics-lab_data-science-types_pr75 +predictive-analytics-lab_data-science-types_pr76 +projectmesa_mesa_pr1001 +projectmesa_mesa_pr103 +projectmesa_mesa_pr1087 +projectmesa_mesa_pr1115 +projectmesa_mesa_pr1116 +projectmesa_mesa_pr1141 +projectmesa_mesa_pr1162 +projectmesa_mesa_pr1181 +projectmesa_mesa_pr1184 +projectmesa_mesa_pr1245 +projectmesa_mesa_pr1260 +projectmesa_mesa_pr1262 +projectmesa_mesa_pr1272 +projectmesa_mesa_pr1283 +projectmesa_mesa_pr1287 +projectmesa_mesa_pr1293 +projectmesa_mesa_pr1294 +projectmesa_mesa_pr1308 +projectmesa_mesa_pr1321 +projectmesa_mesa_pr1322 +projectmesa_mesa_pr1325 +projectmesa_mesa_pr1338 +projectmesa_mesa_pr1342 +projectmesa_mesa_pr1345 +projectmesa_mesa_pr1347 +projectmesa_mesa_pr1349 +projectmesa_mesa_pr1351 +projectmesa_mesa_pr1356 +projectmesa_mesa_pr1376 +projectmesa_mesa_pr1381 +projectmesa_mesa_pr1403 +projectmesa_mesa_pr1435 +projectmesa_mesa_pr1439 +projectmesa_mesa_pr1453 +projectmesa_mesa_pr1455 +projectmesa_mesa_pr1456 +projectmesa_mesa_pr1457 +projectmesa_mesa_pr1465 +projectmesa_mesa_pr1472 +projectmesa_mesa_pr1474 +projectmesa_mesa_pr1478 +projectmesa_mesa_pr1497 +projectmesa_mesa_pr1498 +projectmesa_mesa_pr1507 +projectmesa_mesa_pr1509 +projectmesa_mesa_pr1516 +projectmesa_mesa_pr1517 +projectmesa_mesa_pr1523 +projectmesa_mesa_pr1524 +projectmesa_mesa_pr1525 +projectmesa_mesa_pr1536 +projectmesa_mesa_pr1542 +projectmesa_mesa_pr1546 +projectmesa_mesa_pr155 +projectmesa_mesa_pr156 +projectmesa_mesa_pr1564 +projectmesa_mesa_pr1565 +projectmesa_mesa_pr1568 +projectmesa_mesa_pr157 +projectmesa_mesa_pr1570 +projectmesa_mesa_pr1575 +projectmesa_mesa_pr1614 +projectmesa_mesa_pr1659 +projectmesa_mesa_pr1667 +projectmesa_mesa_pr1686 +projectmesa_mesa_pr1688 +projectmesa_mesa_pr1693 +projectmesa_mesa_pr170 +projectmesa_mesa_pr1702 +projectmesa_mesa_pr1710 +projectmesa_mesa_pr1718 +projectmesa_mesa_pr1723 +projectmesa_mesa_pr1724 +projectmesa_mesa_pr1751 +projectmesa_mesa_pr1758 +projectmesa_mesa_pr1779 +projectmesa_mesa_pr178 +projectmesa_mesa_pr1780 +projectmesa_mesa_pr1783 +projectmesa_mesa_pr1784 +projectmesa_mesa_pr1788 +projectmesa_mesa_pr1798 +projectmesa_mesa_pr1809 +projectmesa_mesa_pr1830 +projectmesa_mesa_pr1832 +projectmesa_mesa_pr1851 +projectmesa_mesa_pr1877 +projectmesa_mesa_pr1894 +projectmesa_mesa_pr1907 +projectmesa_mesa_pr192 +projectmesa_mesa_pr1920 +projectmesa_mesa_pr2084 +projectmesa_mesa_pr2195 +projectmesa_mesa_pr2214 +projectmesa_mesa_pr2219 +projectmesa_mesa_pr2220 +projectmesa_mesa_pr2237 +projectmesa_mesa_pr2240 +projectmesa_mesa_pr2251 +projectmesa_mesa_pr2252 +projectmesa_mesa_pr2253 +projectmesa_mesa_pr2254 +projectmesa_mesa_pr2266 +projectmesa_mesa_pr2267 +projectmesa_mesa_pr2279 +projectmesa_mesa_pr2280 +projectmesa_mesa_pr2283 +projectmesa_mesa_pr2289 +projectmesa_mesa_pr2290 +projectmesa_mesa_pr2291 +projectmesa_mesa_pr2292 +projectmesa_mesa_pr2293 +projectmesa_mesa_pr2296 +projectmesa_mesa_pr2300 +projectmesa_mesa_pr2307 +projectmesa_mesa_pr2309 +projectmesa_mesa_pr2319 +projectmesa_mesa_pr2327 +projectmesa_mesa_pr2328 +projectmesa_mesa_pr2332 +projectmesa_mesa_pr2333 +projectmesa_mesa_pr2336 +projectmesa_mesa_pr2344 +projectmesa_mesa_pr2348 +projectmesa_mesa_pr2350 +projectmesa_mesa_pr2351 +projectmesa_mesa_pr2352 +projectmesa_mesa_pr2353 +projectmesa_mesa_pr2357 +projectmesa_mesa_pr2358 +projectmesa_mesa_pr2359 +projectmesa_mesa_pr2378 +projectmesa_mesa_pr2379 +projectmesa_mesa_pr2390 +projectmesa_mesa_pr2394 +projectmesa_mesa_pr2399 +projectmesa_mesa_pr2400 +projectmesa_mesa_pr2403 +projectmesa_mesa_pr2414 +projectmesa_mesa_pr2418 +projectmesa_mesa_pr2429 +projectmesa_mesa_pr2430 +projectmesa_mesa_pr2442 +projectmesa_mesa_pr2445 +projectmesa_mesa_pr2446 +projectmesa_mesa_pr2447 +projectmesa_mesa_pr2463 +projectmesa_mesa_pr2478 +projectmesa_mesa_pr2479 +projectmesa_mesa_pr2487 +projectmesa_mesa_pr2489 +projectmesa_mesa_pr2491 +projectmesa_mesa_pr2496 +projectmesa_mesa_pr2501 +projectmesa_mesa_pr2502 +projectmesa_mesa_pr2503 +projectmesa_mesa_pr2505 +projectmesa_mesa_pr2506 +projectmesa_mesa_pr2512 +projectmesa_mesa_pr2518 +projectmesa_mesa_pr2523 +projectmesa_mesa_pr2540 +projectmesa_mesa_pr2541 +projectmesa_mesa_pr2543 +projectmesa_mesa_pr2544 +projectmesa_mesa_pr2546 +projectmesa_mesa_pr2548 +projectmesa_mesa_pr2598 +projectmesa_mesa_pr2599 +projectmesa_mesa_pr767 +projectmesa_mesa_pr779 +projectmesa_mesa_pr792 +projectmesa_mesa_pr796 +projectmesa_mesa_pr820 +projectmesa_mesa_pr823 +projectmesa_mesa_pr863 +projectmesa_mesa_pr917 +projectmesa_mesa_pr920 +projectmesa_mesa_pr936 +projectmesa_mesa_pr979 +projectmesa_mesa_pr981 +prompt-toolkit_ptpython_pr592 +prompt-toolkit_ptpython_pr621 +prompt-toolkit_python-prompt-toolkit_pr1007 +prompt-toolkit_python-prompt-toolkit_pr1018 +prompt-toolkit_python-prompt-toolkit_pr1029 +prompt-toolkit_python-prompt-toolkit_pr1035 +prompt-toolkit_python-prompt-toolkit_pr1039 +prompt-toolkit_python-prompt-toolkit_pr1051 +prompt-toolkit_python-prompt-toolkit_pr1062 +prompt-toolkit_python-prompt-toolkit_pr1064 +prompt-toolkit_python-prompt-toolkit_pr1067 +prompt-toolkit_python-prompt-toolkit_pr1074 +prompt-toolkit_python-prompt-toolkit_pr1080 +prompt-toolkit_python-prompt-toolkit_pr1083 +prompt-toolkit_python-prompt-toolkit_pr1091 +prompt-toolkit_python-prompt-toolkit_pr1095 +prompt-toolkit_python-prompt-toolkit_pr1110 +prompt-toolkit_python-prompt-toolkit_pr1112 +prompt-toolkit_python-prompt-toolkit_pr1122 +prompt-toolkit_python-prompt-toolkit_pr1127 +prompt-toolkit_python-prompt-toolkit_pr1167 +prompt-toolkit_python-prompt-toolkit_pr1168 +prompt-toolkit_python-prompt-toolkit_pr1217 +prompt-toolkit_python-prompt-toolkit_pr1223 +prompt-toolkit_python-prompt-toolkit_pr1237 +prompt-toolkit_python-prompt-toolkit_pr1246 +prompt-toolkit_python-prompt-toolkit_pr1263 +prompt-toolkit_python-prompt-toolkit_pr1312 +prompt-toolkit_python-prompt-toolkit_pr1328 +prompt-toolkit_python-prompt-toolkit_pr1332 +prompt-toolkit_python-prompt-toolkit_pr1336 +prompt-toolkit_python-prompt-toolkit_pr1348 +prompt-toolkit_python-prompt-toolkit_pr1360 +prompt-toolkit_python-prompt-toolkit_pr1361 +prompt-toolkit_python-prompt-toolkit_pr1394 +prompt-toolkit_python-prompt-toolkit_pr1446 +prompt-toolkit_python-prompt-toolkit_pr1455 +prompt-toolkit_python-prompt-toolkit_pr1505 +prompt-toolkit_python-prompt-toolkit_pr1512 +prompt-toolkit_python-prompt-toolkit_pr1535 +prompt-toolkit_python-prompt-toolkit_pr1547 +prompt-toolkit_python-prompt-toolkit_pr1548 +prompt-toolkit_python-prompt-toolkit_pr1555 +prompt-toolkit_python-prompt-toolkit_pr1559 +prompt-toolkit_python-prompt-toolkit_pr1560 +prompt-toolkit_python-prompt-toolkit_pr1566 +prompt-toolkit_python-prompt-toolkit_pr1568 +prompt-toolkit_python-prompt-toolkit_pr1582 +prompt-toolkit_python-prompt-toolkit_pr1586 +prompt-toolkit_python-prompt-toolkit_pr1589 +prompt-toolkit_python-prompt-toolkit_pr627 +prompt-toolkit_python-prompt-toolkit_pr631 +prompt-toolkit_python-prompt-toolkit_pr691 +prompt-toolkit_python-prompt-toolkit_pr760 +prompt-toolkit_python-prompt-toolkit_pr802 +prompt-toolkit_python-prompt-toolkit_pr838 +prompt-toolkit_python-prompt-toolkit_pr851 +prompt-toolkit_python-prompt-toolkit_pr867 +prompt-toolkit_python-prompt-toolkit_pr874 +prompt-toolkit_python-prompt-toolkit_pr877 +prompt-toolkit_python-prompt-toolkit_pr899 +prompt-toolkit_python-prompt-toolkit_pr910 +prompt-toolkit_python-prompt-toolkit_pr919 +prompt-toolkit_python-prompt-toolkit_pr929 +prompt-toolkit_python-prompt-toolkit_pr939 +prompt-toolkit_python-prompt-toolkit_pr943 +prompt-toolkit_python-prompt-toolkit_pr989 +psd-tools_psd-tools_pr111 +psd-tools_psd-tools_pr120 +psd-tools_psd-tools_pr121 +psd-tools_psd-tools_pr133 +psd-tools_psd-tools_pr138 +psd-tools_psd-tools_pr146 +psd-tools_psd-tools_pr161 +psd-tools_psd-tools_pr166 +psd-tools_psd-tools_pr169 +psd-tools_psd-tools_pr178 +psd-tools_psd-tools_pr182 +psd-tools_psd-tools_pr188 +psd-tools_psd-tools_pr96 +psd-tools_psd-tools_pr99 +pudo_dataset_pr284 +pudo_dataset_pr296 +pudo_dataset_pr315 +pudo_dataset_pr321 +pudo_dataset_pr346 +pudo_dataset_pr424 +pwaller_pyprof2calltree_pr41 +pwaller_pyprof2calltree_pr58 +pwwang_liquidpy_pr49 +pwwang_liquidpy_pr53 +pwwang_liquidpy_pr54 +pwwang_python-varname_pr103 +pwwang_python-varname_pr105 +pwwang_python-varname_pr15 +pwwang_python-varname_pr20 +pwwang_python-varname_pr27 +pwwang_python-varname_pr29 +pwwang_python-varname_pr32 +pwwang_python-varname_pr39 +pwwang_python-varname_pr42 +pwwang_python-varname_pr59 +pwwang_python-varname_pr63 +pwwang_python-varname_pr84 +py-moneyed_py-moneyed_pr102 +py-moneyed_py-moneyed_pr123 +py-moneyed_py-moneyed_pr150 +py-moneyed_py-moneyed_pr157 +py-moneyed_py-moneyed_pr162 +py-moneyed_py-moneyed_pr167 +py-moneyed_py-moneyed_pr168 +py-moneyed_py-moneyed_pr180 +py-moneyed_py-moneyed_pr64 +py-moneyed_py-moneyed_pr75 +py-moneyed_py-moneyed_pr78 +py-moneyed_py-moneyed_pr83 +py-moneyed_py-moneyed_pr92 +py-moneyed_py-moneyed_pr97 +pyansys_pypim_pr5 +pyapp-kit_app-model_pr10 +pyapp-kit_app-model_pr119 +pyapp-kit_app-model_pr130 +pyapp-kit_app-model_pr133 +pyapp-kit_app-model_pr145 +pyapp-kit_app-model_pr146 +pyapp-kit_app-model_pr16 +pyapp-kit_app-model_pr18 +pyapp-kit_app-model_pr194 +pyapp-kit_app-model_pr197 +pyapp-kit_app-model_pr202 +pyapp-kit_app-model_pr211 +pyapp-kit_app-model_pr212 +pyapp-kit_app-model_pr213 +pyapp-kit_app-model_pr237 +pyapp-kit_app-model_pr24 +pyapp-kit_app-model_pr241 +pyapp-kit_app-model_pr242 +pyapp-kit_app-model_pr26 +pyapp-kit_app-model_pr34 +pyapp-kit_app-model_pr35 +pyapp-kit_app-model_pr39 +pyapp-kit_app-model_pr40 +pyapp-kit_app-model_pr44 +pyapp-kit_app-model_pr45 +pyapp-kit_app-model_pr48 +pyapp-kit_app-model_pr5 +pyapp-kit_app-model_pr58 +pyapp-kit_app-model_pr59 +pyapp-kit_app-model_pr63 +pyapp-kit_app-model_pr67 +pyapp-kit_app-model_pr68 +pyapp-kit_app-model_pr7 +pyapp-kit_app-model_pr81 +pyapp-kit_in-n-out_pr5 +pyapp-kit_in-n-out_pr63 +pyapp-kit_psygnal_pr178 +pyapp-kit_psygnal_pr183 +pyapp-kit_psygnal_pr186 +pyapp-kit_psygnal_pr188 +pyapp-kit_psygnal_pr189 +pyapp-kit_psygnal_pr192 +pyapp-kit_psygnal_pr194 +pyapp-kit_psygnal_pr209 +pyapp-kit_psygnal_pr210 +pyapp-kit_psygnal_pr216 +pyapp-kit_psygnal_pr222 +pyapp-kit_psygnal_pr228 +pyapp-kit_psygnal_pr232 +pyasi_pybuildkite_pr101 +pyasi_pybuildkite_pr106 +pyasi_pybuildkite_pr13 +pyasi_pybuildkite_pr14 +pyasi_pybuildkite_pr18 +pyasi_pybuildkite_pr19 +pyasi_pybuildkite_pr22 +pyasi_pybuildkite_pr40 +pyasi_pybuildkite_pr53 +pyasi_pybuildkite_pr57 +pyasi_pybuildkite_pr58 +pyasi_pybuildkite_pr6 +pyasi_pybuildkite_pr82 +pyasi_pybuildkite_pr84 +pyasi_pybuildkite_pr87 +pyasi_pybuildkite_pr99 +pyasn1_pyasn1-modules_pr5 +pyasn1_pyasn1_pr13 +pyasn1_pyasn1_pr61 +pyasn1_pyasn1_pr82 +pyca_bcrypt_pr59 +pyca_bcrypt_pr79 +pyca_pynacl_pr127 +pyca_pynacl_pr138 +pyca_pynacl_pr39 +pyca_pynacl_pr41 +pyca_pynacl_pr52 +pyca_pyopenssl_pr1308 +pyca_pyopenssl_pr1310 +pyca_pyopenssl_pr1313 +pyca_pyopenssl_pr1327 +pyca_pyopenssl_pr1328 +pyca_pyopenssl_pr1330 +pyca_pyopenssl_pr1336 +pyca_pyopenssl_pr1344 +pyca_pyopenssl_pr1347 +pyca_pyopenssl_pr1351 +pyca_pyopenssl_pr1354 +pyca_pyopenssl_pr1357 +pyca_pyopenssl_pr1391 +pyca_pyopenssl_pr1399 +pyca_pyopenssl_pr1403 +pyca_service-identity_pr19 +pyca_service-identity_pr47 +pyca_service-identity_pr55 +pyca_service-identity_pr69 +pycasbin_sqlalchemy-adapter_pr48 +pycasbin_sqlalchemy-adapter_pr51 +pycasbin_sqlalchemy-adapter_pr56 +pycasbin_sqlalchemy-adapter_pr9 +pycontribs_ruyaml_pr59 +pycqa_doc8_pr122 +pycqa_doc8_pr49 +pycqa_doc8_pr51 +pycqa_doc8_pr66 +pycqa_isort_pr868 +pycqa_isort_pr878 +pycqa_isort_pr891 +pycqa_isort_pr892 +pycqa_isort_pr896 +pycqa_isort_pr939 +pycqa_isort_pr949 +pydantic_bump-pydantic_pr110 +pydantic_bump-pydantic_pr12 +pydantic_bump-pydantic_pr122 +pydantic_bump-pydantic_pr127 +pydantic_bump-pydantic_pr13 +pydantic_bump-pydantic_pr14 +pydantic_bump-pydantic_pr143 +pydantic_bump-pydantic_pr18 +pydantic_bump-pydantic_pr21 +pydantic_bump-pydantic_pr23 +pydantic_bump-pydantic_pr24 +pydantic_bump-pydantic_pr26 +pydantic_bump-pydantic_pr27 +pydantic_bump-pydantic_pr28 +pydantic_bump-pydantic_pr31 +pydantic_bump-pydantic_pr32 +pydantic_bump-pydantic_pr35 +pydantic_bump-pydantic_pr41 +pydantic_bump-pydantic_pr43 +pydantic_bump-pydantic_pr45 +pydantic_bump-pydantic_pr65 +pydantic_bump-pydantic_pr66 +pydantic_bump-pydantic_pr72 +pydantic_bump-pydantic_pr74 +pydantic_bump-pydantic_pr76 +pydantic_bump-pydantic_pr86 +pydantic_bump-pydantic_pr90 +pydantic_typing-inspection_pr24 +pydantic_typing-inspection_pr28 +pydicom_pylibjpeg_pr74 +pydicom_pylibjpeg_pr76 +pydicom_pylibjpeg_pr82 +pydoit_doit_pr292 +pydoit_doit_pr405 +pyinfra-dev_pyinfra_pr192 +pyinfra-dev_pyinfra_pr194 +pyinfra-dev_pyinfra_pr196 +pyinfra-dev_pyinfra_pr231 +pylabel-project_pylabel_pr125 +pylabel-project_pylabel_pr128 +pylabel-project_pylabel_pr25 +pylabel-project_pylabel_pr28 +pylabel-project_pylabel_pr31 +pylabel-project_pylabel_pr37 +pylabel-project_pylabel_pr64 +pylabel-project_pylabel_pr70 +pylast_pylast_pr237 +pylast_pylast_pr243 +pylast_pylast_pr244 +pylast_pylast_pr245 +pylast_pylast_pr264 +pylast_pylast_pr281 +pylast_pylast_pr290 +pylast_pylast_pr292 +pylast_pylast_pr297 +pylast_pylast_pr395 +pylast_pylast_pr442 +pyout_pyout_pr108 +pyout_pyout_pr109 +pyout_pyout_pr111 +pyout_pyout_pr149 +pyout_pyout_pr156 +pyout_pyout_pr86 +pyout_pyout_pr90 +pyout_pyout_pr98 +pypa_abi3audit_pr24 +pypa_installer_pr11 +pypa_installer_pr141 +pypa_installer_pr147 +pypa_installer_pr161 +pypa_installer_pr167 +pypa_installer_pr168 +pypa_installer_pr181 +pypa_installer_pr200 +pypa_installer_pr216 +pypa_installer_pr239 +pypa_installer_pr242 +pypa_installer_pr258 +pypa_installer_pr33 +pypa_installer_pr9 +pypa_installer_pr90 +pypa_installer_pr94 +pypa_installer_pr96 +pypa_pyproject-metadata_pr109 +pypa_pyproject-metadata_pr122 +pypa_pyproject-metadata_pr142 +pypa_pyproject-metadata_pr145 +pypa_pyproject-metadata_pr150 +pypa_pyproject-metadata_pr157 +pypa_pyproject-metadata_pr161 +pypa_pyproject-metadata_pr162 +pypa_pyproject-metadata_pr168 +pypa_pyproject-metadata_pr17 +pypa_pyproject-metadata_pr183 +pypa_pyproject-metadata_pr185 +pypa_pyproject-metadata_pr188 +pypa_pyproject-metadata_pr19 +pypa_pyproject-metadata_pr203 +pypa_pyproject-metadata_pr206 +pypa_pyproject-metadata_pr211 +pypa_pyproject-metadata_pr232 +pypa_pyproject-metadata_pr26 +pypa_pyproject-metadata_pr27 +pypa_pyproject-metadata_pr37 +pypa_pyproject-metadata_pr65 +pypa_pyproject-metadata_pr74 +pypa_pyproject-metadata_pr83 +pypa_pyproject-metadata_pr91 +pypa_twine_pr1024 +pypa_twine_pr107 +pypa_twine_pr112 +pypa_twine_pr1123 +pypa_twine_pr1131 +pypa_twine_pr1159 +pypa_twine_pr1172 +pypa_twine_pr1188 +pypa_twine_pr1191 +pypa_twine_pr121 +pypa_twine_pr138 +pypa_twine_pr152 +pypa_twine_pr162 +pypa_twine_pr243 +pypa_twine_pr248 +pypa_twine_pr249 +pypa_twine_pr252 +pypa_twine_pr319 +pypa_twine_pr322 +pypa_twine_pr337 +pypa_twine_pr365 +pypa_twine_pr368 +pypa_twine_pr395 +pypa_twine_pr397 +pypa_twine_pr405 +pypa_twine_pr412 +pypa_twine_pr427 +pypa_twine_pr428 +pypa_twine_pr440 +pypa_twine_pr441 +pypa_twine_pr452 +pypa_twine_pr460 +pypa_twine_pr472 +pypa_twine_pr477 +pypa_twine_pr484 +pypa_twine_pr488 +pypa_twine_pr509 +pypa_twine_pr510 +pypa_twine_pr525 +pypa_twine_pr58 +pypa_twine_pr62 +pypa_twine_pr66 +pypa_twine_pr68 +pypa_twine_pr72 +pypa_twine_pr73 +pypa_twine_pr79 +pypa_twine_pr82 +pypa_twine_pr83 +pypa_twine_pr86 +pypa_twine_pr94 +pypa_twine_pr97 +pysal_esda_pr274 +pysal_esda_pr293 +pysal_esda_pr295 +pysal_esda_pr296 +pysal_esda_pr326 +pysal_esda_pr327 +pysal_esda_pr355 +pysal_esda_pr356 +pysal_esda_pr359 +pysal_esda_pr360 +pysal_giddy_pr171 +pysal_giddy_pr84 +pysal_mapclassify_pr150 +pysal_mapclassify_pr153 +pysal_mapclassify_pr177 +pysal_mapclassify_pr181 +pysal_mapclassify_pr210 +pysal_mapclassify_pr216 +pysal_mapclassify_pr229 +pysal_mapclassify_pr274 +pysal_pointpats_pr102 +pysal_pointpats_pr104 +pysal_pointpats_pr111 +pysal_pointpats_pr116 +pysal_pointpats_pr118 +pysal_pointpats_pr145 +pysal_pointpats_pr147 +pysal_pointpats_pr149 +pysal_pointpats_pr159 +pysal_pointpats_pr45 +pysal_pointpats_pr48 +pysal_pointpats_pr56 +pysal_spaghetti_pr112 +pysal_spaghetti_pr116 +pysal_spaghetti_pr145 +pysal_spaghetti_pr167 +pysal_spaghetti_pr179 +pysal_spaghetti_pr181 +pysal_spaghetti_pr182 +pysal_spaghetti_pr185 +pysal_spaghetti_pr212 +pysal_spaghetti_pr349 +pysal_spaghetti_pr409 +pysal_spaghetti_pr471 +pysal_spaghetti_pr719 +pysal_spopt_pr294 +pysal_spopt_pr312 +pysal_spopt_pr319 +pytest-dev_pytest-bdd_pr335 +pytest-dev_pytest-bdd_pr398 +pytest-dev_pytest-bdd_pr415 +pytest-dev_pytest-bdd_pr431 +pytest-dev_pytest-bdd_pr445 +pytest-dev_pytest-bdd_pr503 +pytest-dev_pytest-bdd_pr534 +pytest-dev_pytest-bdd_pr539 +pytest-dev_pytest-freezer_pr4 +pytest-dev_pytest-subtests_pr131 +pytest-dev_pytest-subtests_pr139 +pytest-dev_pytest-subtests_pr169 +pytest-dev_pytest-subtests_pr190 +python-cas_python-cas_pr65 +python-control_python-control_pr1001 +python-control_python-control_pr1003 +python-control_python-control_pr1011 +python-control_python-control_pr1012 +python-control_python-control_pr1017 +python-control_python-control_pr1018 +python-control_python-control_pr1019 +python-control_python-control_pr1022 +python-control_python-control_pr1023 +python-control_python-control_pr1024 +python-control_python-control_pr1029 +python-control_python-control_pr1030 +python-control_python-control_pr1034 +python-control_python-control_pr1071 +python-control_python-control_pr1074 +python-control_python-control_pr1078 +python-control_python-control_pr1091 +python-control_python-control_pr1092 +python-control_python-control_pr1108 +python-control_python-control_pr790 +python-control_python-control_pr793 +python-control_python-control_pr794 +python-control_python-control_pr798 +python-control_python-control_pr809 +python-control_python-control_pr811 +python-control_python-control_pr826 +python-control_python-control_pr829 +python-control_python-control_pr834 +python-control_python-control_pr863 +python-control_python-control_pr877 +python-control_python-control_pr881 +python-control_python-control_pr883 +python-control_python-control_pr884 +python-control_python-control_pr885 +python-control_python-control_pr889 +python-control_python-control_pr892 +python-control_python-control_pr894 +python-control_python-control_pr900 +python-control_python-control_pr903 +python-control_python-control_pr913 +python-control_python-control_pr914 +python-control_python-control_pr920 +python-control_python-control_pr925 +python-control_python-control_pr937 +python-control_python-control_pr951 +python-control_python-control_pr953 +python-control_python-control_pr958 +python-control_python-control_pr965 +python-control_python-control_pr969 +python-control_python-control_pr971 +python-control_python-control_pr980 +python-control_python-control_pr989 +python-control_python-control_pr990 +python-control_python-control_pr994 +python-control_python-control_pr996 +python-desert_desert_pr123 +python-desert_desert_pr79 +python-distro_distro_pr106 +python-distro_distro_pr111 +python-distro_distro_pr113 +python-distro_distro_pr130 +python-distro_distro_pr145 +python-distro_distro_pr158 +python-distro_distro_pr181 +python-distro_distro_pr201 +python-distro_distro_pr247 +python-distro_distro_pr28 +python-distro_distro_pr30 +python-distro_distro_pr304 +python-distro_distro_pr305 +python-distro_distro_pr319 +python-distro_distro_pr39 +python-distro_distro_pr43 +python-distro_distro_pr45 +python-distro_distro_pr46 +python-distro_distro_pr51 +python-distro_distro_pr53 +python-distro_distro_pr66 +python-distro_distro_pr86 +python-distro_distro_pr89 +python-distro_distro_pr90 +python-distro_distro_pr93 +python-grimp_grimp_pr103 +python-grimp_grimp_pr17 +python-grimp_grimp_pr24 +python-grimp_grimp_pr37 +python-grimp_grimp_pr57 +python-grimp_grimp_pr66 +python-grimp_grimp_pr74 +python-grimp_grimp_pr79 +python-grimp_grimp_pr81 +python-grimp_grimp_pr93 +python-grimp_grimp_pr99 +python-hyper_hpack_pr12 +python-hyper_hpack_pr26 +python-hyper_hpack_pr263 +python-hyper_hpack_pr28 +python-hyper_hpack_pr31 +python-hyper_hpack_pr35 +python-hyper_hpack_pr37 +python-hyper_hpack_pr38 +python-hyper_hpack_pr4 +python-hyper_hpack_pr63 +python-hyper_hpack_pr64 +python-hyper_hyperframe_pr14 +python-hyper_hyperframe_pr147 +python-hyper_hyperframe_pr151 +python-hyper_hyperframe_pr163 +python-hyper_hyperframe_pr2 +python-hyper_hyperframe_pr9 +python-hyper_priority_pr36 +python-hyper_wsproto_pr148 +python-hyper_wsproto_pr149 +python-hyper_wsproto_pr36 +python-hyper_wsproto_pr40 +python-hyper_wsproto_pr42 +python-jsonschema_jsonschema_pr106 +python-jsonschema_jsonschema_pr123 +python-jsonschema_jsonschema_pr203 +python-lsp_pylsp-mypy_pr10 +python-lsp_pylsp-mypy_pr100 +python-lsp_pylsp-mypy_pr13 +python-lsp_pylsp-mypy_pr24 +python-lsp_pylsp-mypy_pr40 +python-lsp_pylsp-mypy_pr42 +python-lsp_pylsp-mypy_pr53 +python-lsp_python-lsp-ruff_pr109 +python-lsp_python-lsp-ruff_pr13 +python-lsp_python-lsp-ruff_pr4 +python-lsp_python-lsp-ruff_pr54 +python-lsp_python-lsp-ruff_pr6 +python-lsp_python-lsp-ruff_pr60 +python-lsp_python-lsp-ruff_pr62 +python-lsp_python-lsp-ruff_pr64 +python-lsp_python-lsp-ruff_pr66 +python-lsp_python-lsp-ruff_pr80 +python-lsp_python-lsp-ruff_pr94 +python-lsp_python-lsp-ruff_pr97 +python-openapi_openapi-core_pr418 +python-openapi_openapi-core_pr421 +python-openapi_openapi-core_pr422 +python-openapi_openapi-core_pr423 +python-openapi_openapi-core_pr429 +python-openapi_openapi-core_pr431 +python-openapi_openapi-core_pr432 +python-openapi_openapi-core_pr433 +python-openapi_openapi-core_pr434 +python-openapi_openapi-core_pr462 +python-openapi_openapi-core_pr468 +python-openapi_openapi-core_pr473 +python-openapi_openapi-core_pr482 +python-openapi_openapi-core_pr489 +python-openapi_openapi-core_pr491 +python-openapi_openapi-core_pr512 +python-openapi_openapi-core_pr529 +python-openapi_openapi-core_pr553 +python-openapi_openapi-core_pr555 +python-openapi_openapi-core_pr562 +python-openapi_openapi-core_pr646 +python-openapi_openapi-core_pr648 +python-openapi_openapi-core_pr680 +python-openapi_openapi-core_pr686 +python-openapi_openapi-core_pr691 +python-openapi_openapi-core_pr697 +python-openapi_openapi-core_pr701 +python-openapi_openapi-core_pr709 +python-openapi_openapi-core_pr738 +python-openapi_openapi-core_pr779 +python-openapi_openapi-core_pr802 +python-openapi_openapi-core_pr814 +python-openapi_openapi-core_pr830 +python-openapi_openapi-core_pr853 +python-openapi_openapi-core_pr859 +python-openapi_openapi-core_pr876 +python-openapi_openapi-schema-validator_pr135 +python-openapi_openapi-schema-validator_pr26 +python-openapi_openapi-schema-validator_pr30 +python-openapi_openapi-schema-validator_pr38 +python-openapi_openapi-schema-validator_pr52 +python-openapi_openapi-schema-validator_pr57 +python-openapi_openapi-schema-validator_pr59 +python-openapi_openapi-schema-validator_pr67 +python-openapi_openapi-spec-validator_pr137 +python-openapi_openapi-spec-validator_pr154 +python-openapi_openapi-spec-validator_pr232 +python-openapi_openapi-spec-validator_pr24 +python-openapi_openapi-spec-validator_pr25 +python-openapi_openapi-spec-validator_pr255 +python-openapi_openapi-spec-validator_pr28 +python-openapi_openapi-spec-validator_pr286 +python-openapi_openapi-spec-validator_pr291 +python-openapi_openapi-spec-validator_pr30 +python-openapi_openapi-spec-validator_pr35 +python-openapi_openapi-spec-validator_pr37 +python-openapi_openapi-spec-validator_pr4 +python-openapi_openapi-spec-validator_pr8 +python-parsy_parsy_pr3 +python-parsy_parsy_pr45 +python-poetry_cleo_pr10 +python-poetry_cleo_pr102 +python-poetry_cleo_pr112 +python-poetry_cleo_pr118 +python-poetry_cleo_pr13 +python-poetry_cleo_pr132 +python-poetry_cleo_pr135 +python-poetry_cleo_pr148 +python-poetry_cleo_pr157 +python-poetry_cleo_pr16 +python-poetry_cleo_pr166 +python-poetry_cleo_pr194 +python-poetry_cleo_pr199 +python-poetry_cleo_pr203 +python-poetry_cleo_pr208 +python-poetry_cleo_pr21 +python-poetry_cleo_pr214 +python-poetry_cleo_pr217 +python-poetry_cleo_pr225 +python-poetry_cleo_pr236 +python-poetry_cleo_pr240 +python-poetry_cleo_pr27 +python-poetry_cleo_pr29 +python-poetry_cleo_pr3 +python-poetry_cleo_pr31 +python-poetry_cleo_pr313 +python-poetry_cleo_pr343 +python-poetry_cleo_pr345 +python-poetry_cleo_pr358 +python-poetry_cleo_pr382 +python-poetry_cleo_pr413 +python-poetry_cleo_pr512 +python-poetry_cleo_pr8 +python-poetry_cleo_pr96 +python-poetry_cleo_pr97 +python-poetry_poetry-core_pr100 +python-poetry_poetry-core_pr101 +python-poetry_poetry-core_pr102 +python-poetry_poetry-core_pr103 +python-poetry_poetry-core_pr105 +python-poetry_poetry-core_pr108 +python-poetry_poetry-core_pr114 +python-poetry_poetry-core_pr118 +python-poetry_poetry-core_pr122 +python-poetry_poetry-core_pr128 +python-poetry_poetry-core_pr131 +python-poetry_poetry-core_pr134 +python-poetry_poetry-core_pr138 +python-poetry_poetry-core_pr142 +python-poetry_poetry-core_pr143 +python-poetry_poetry-core_pr148 +python-poetry_poetry-core_pr150 +python-poetry_poetry-core_pr153 +python-poetry_poetry-core_pr155 +python-poetry_poetry-core_pr157 +python-poetry_poetry-core_pr158 +python-poetry_poetry-core_pr159 +python-poetry_poetry-core_pr162 +python-poetry_poetry-core_pr167 +python-poetry_poetry-core_pr170 +python-poetry_poetry-core_pr171 +python-poetry_poetry-core_pr178 +python-poetry_poetry-core_pr182 +python-poetry_poetry-core_pr183 +python-poetry_poetry-core_pr186 +python-poetry_poetry-core_pr188 +python-poetry_poetry-core_pr192 +python-poetry_poetry-core_pr198 +python-poetry_poetry-core_pr201 +python-poetry_poetry-core_pr202 +python-poetry_poetry-core_pr204 +python-poetry_poetry-core_pr208 +python-poetry_poetry-core_pr211 +python-poetry_poetry-core_pr214 +python-poetry_poetry-core_pr219 +python-poetry_poetry-core_pr220 +python-poetry_poetry-core_pr221 +python-poetry_poetry-core_pr226 +python-poetry_poetry-core_pr228 +python-poetry_poetry-core_pr231 +python-poetry_poetry-core_pr233 +python-poetry_poetry-core_pr238 +python-poetry_poetry-core_pr239 +python-poetry_poetry-core_pr240 +python-poetry_poetry-core_pr241 +python-poetry_poetry-core_pr243 +python-poetry_poetry-core_pr248 +python-poetry_poetry-core_pr255 +python-poetry_poetry-core_pr264 +python-poetry_poetry-core_pr272 +python-poetry_poetry-core_pr274 +python-poetry_poetry-core_pr276 +python-poetry_poetry-core_pr280 +python-poetry_poetry-core_pr282 +python-poetry_poetry-core_pr283 +python-poetry_poetry-core_pr286 +python-poetry_poetry-core_pr290 +python-poetry_poetry-core_pr294 +python-poetry_poetry-core_pr299 +python-poetry_poetry-core_pr30 +python-poetry_poetry-core_pr301 +python-poetry_poetry-core_pr302 +python-poetry_poetry-core_pr308 +python-poetry_poetry-core_pr316 +python-poetry_poetry-core_pr324 +python-poetry_poetry-core_pr325 +python-poetry_poetry-core_pr333 +python-poetry_poetry-core_pr341 +python-poetry_poetry-core_pr345 +python-poetry_poetry-core_pr352 +python-poetry_poetry-core_pr357 +python-poetry_poetry-core_pr36 +python-poetry_poetry-core_pr365 +python-poetry_poetry-core_pr368 +python-poetry_poetry-core_pr371 +python-poetry_poetry-core_pr380 +python-poetry_poetry-core_pr381 +python-poetry_poetry-core_pr382 +python-poetry_poetry-core_pr385 +python-poetry_poetry-core_pr388 +python-poetry_poetry-core_pr390 +python-poetry_poetry-core_pr391 +python-poetry_poetry-core_pr393 +python-poetry_poetry-core_pr395 +python-poetry_poetry-core_pr398 +python-poetry_poetry-core_pr400 +python-poetry_poetry-core_pr402 +python-poetry_poetry-core_pr405 +python-poetry_poetry-core_pr407 +python-poetry_poetry-core_pr411 +python-poetry_poetry-core_pr415 +python-poetry_poetry-core_pr417 +python-poetry_poetry-core_pr433 +python-poetry_poetry-core_pr436 +python-poetry_poetry-core_pr437 +python-poetry_poetry-core_pr44 +python-poetry_poetry-core_pr446 +python-poetry_poetry-core_pr447 +python-poetry_poetry-core_pr448 +python-poetry_poetry-core_pr456 +python-poetry_poetry-core_pr458 +python-poetry_poetry-core_pr460 +python-poetry_poetry-core_pr461 +python-poetry_poetry-core_pr462 +python-poetry_poetry-core_pr463 +python-poetry_poetry-core_pr466 +python-poetry_poetry-core_pr467 +python-poetry_poetry-core_pr469 +python-poetry_poetry-core_pr473 +python-poetry_poetry-core_pr475 +python-poetry_poetry-core_pr482 +python-poetry_poetry-core_pr483 +python-poetry_poetry-core_pr484 +python-poetry_poetry-core_pr486 +python-poetry_poetry-core_pr487 +python-poetry_poetry-core_pr49 +python-poetry_poetry-core_pr495 +python-poetry_poetry-core_pr497 +python-poetry_poetry-core_pr500 +python-poetry_poetry-core_pr505 +python-poetry_poetry-core_pr51 +python-poetry_poetry-core_pr510 +python-poetry_poetry-core_pr512 +python-poetry_poetry-core_pr513 +python-poetry_poetry-core_pr514 +python-poetry_poetry-core_pr515 +python-poetry_poetry-core_pr517 +python-poetry_poetry-core_pr518 +python-poetry_poetry-core_pr520 +python-poetry_poetry-core_pr527 +python-poetry_poetry-core_pr528 +python-poetry_poetry-core_pr53 +python-poetry_poetry-core_pr532 +python-poetry_poetry-core_pr534 +python-poetry_poetry-core_pr535 +python-poetry_poetry-core_pr537 +python-poetry_poetry-core_pr54 +python-poetry_poetry-core_pr540 +python-poetry_poetry-core_pr542 +python-poetry_poetry-core_pr543 +python-poetry_poetry-core_pr546 +python-poetry_poetry-core_pr549 +python-poetry_poetry-core_pr550 +python-poetry_poetry-core_pr56 +python-poetry_poetry-core_pr561 +python-poetry_poetry-core_pr569 +python-poetry_poetry-core_pr57 +python-poetry_poetry-core_pr570 +python-poetry_poetry-core_pr578 +python-poetry_poetry-core_pr582 +python-poetry_poetry-core_pr591 +python-poetry_poetry-core_pr593 +python-poetry_poetry-core_pr60 +python-poetry_poetry-core_pr602 +python-poetry_poetry-core_pr607 +python-poetry_poetry-core_pr608 +python-poetry_poetry-core_pr609 +python-poetry_poetry-core_pr611 +python-poetry_poetry-core_pr620 +python-poetry_poetry-core_pr629 +python-poetry_poetry-core_pr633 +python-poetry_poetry-core_pr634 +python-poetry_poetry-core_pr636 +python-poetry_poetry-core_pr641 +python-poetry_poetry-core_pr648 +python-poetry_poetry-core_pr661 +python-poetry_poetry-core_pr664 +python-poetry_poetry-core_pr666 +python-poetry_poetry-core_pr670 +python-poetry_poetry-core_pr672 +python-poetry_poetry-core_pr675 +python-poetry_poetry-core_pr677 +python-poetry_poetry-core_pr69 +python-poetry_poetry-core_pr690 +python-poetry_poetry-core_pr70 +python-poetry_poetry-core_pr710 +python-poetry_poetry-core_pr722 +python-poetry_poetry-core_pr726 +python-poetry_poetry-core_pr729 +python-poetry_poetry-core_pr732 +python-poetry_poetry-core_pr734 +python-poetry_poetry-core_pr74 +python-poetry_poetry-core_pr75 +python-poetry_poetry-core_pr752 +python-poetry_poetry-core_pr754 +python-poetry_poetry-core_pr762 +python-poetry_poetry-core_pr766 +python-poetry_poetry-core_pr767 +python-poetry_poetry-core_pr771 +python-poetry_poetry-core_pr775 +python-poetry_poetry-core_pr78 +python-poetry_poetry-core_pr781 +python-poetry_poetry-core_pr783 +python-poetry_poetry-core_pr79 +python-poetry_poetry-core_pr794 +python-poetry_poetry-core_pr805 +python-poetry_poetry-core_pr807 +python-poetry_poetry-core_pr809 +python-poetry_poetry-core_pr81 +python-poetry_poetry-core_pr811 +python-poetry_poetry-core_pr816 +python-poetry_poetry-core_pr817 +python-poetry_poetry-core_pr818 +python-poetry_poetry-core_pr821 +python-poetry_poetry-core_pr823 +python-poetry_poetry-core_pr826 +python-poetry_poetry-core_pr827 +python-poetry_poetry-core_pr830 +python-poetry_poetry-core_pr832 +python-poetry_poetry-core_pr833 +python-poetry_poetry-core_pr835 +python-poetry_poetry-core_pr837 +python-poetry_poetry-core_pr838 +python-poetry_poetry-core_pr84 +python-poetry_poetry-core_pr841 +python-poetry_poetry-core_pr842 +python-poetry_poetry-core_pr845 +python-poetry_poetry-core_pr846 +python-poetry_poetry-core_pr849 +python-poetry_poetry-core_pr851 +python-poetry_poetry-core_pr853 +python-poetry_poetry-core_pr857 +python-poetry_poetry-core_pr858 +python-poetry_poetry-core_pr859 +python-poetry_poetry-core_pr86 +python-poetry_poetry-core_pr860 +python-poetry_poetry-core_pr868 +python-poetry_poetry-core_pr870 +python-poetry_poetry-core_pr874 +python-poetry_poetry-core_pr875 +python-poetry_poetry-core_pr877 +python-poetry_poetry-core_pr888 +python-poetry_poetry-core_pr891 +python-poetry_poetry-core_pr893 +python-poetry_poetry-core_pr90 +python-poetry_poetry-core_pr95 +python-poetry_poetry-plugin-export_pr103 +python-poetry_poetry-plugin-export_pr109 +python-poetry_poetry-plugin-export_pr130 +python-poetry_poetry-plugin-export_pr139 +python-poetry_poetry-plugin-export_pr209 +python-poetry_poetry-plugin-export_pr241 +python-poetry_poetry-plugin-export_pr258 +python-poetry_poetry-plugin-export_pr270 +python-scim_scim2-models_pr102 +python-scim_scim2-models_pr28 +python-scim_scim2-models_pr30 +python-scim_scim2-models_pr32 +python-scim_scim2-models_pr35 +python-scim_scim2-models_pr38 +python-scim_scim2-models_pr40 +python-scim_scim2-models_pr41 +python-scim_scim2-models_pr44 +python-scim_scim2-models_pr47 +python-scim_scim2-models_pr49 +python-scim_scim2-models_pr52 +python-scim_scim2-models_pr53 +python-scim_scim2-models_pr55 +python-scim_scim2-models_pr66 +python-scim_scim2-models_pr67 +python-scim_scim2-models_pr69 +python-scim_scim2-models_pr78 +python-scim_scim2-models_pr79 +python-scim_scim2-models_pr8 +python-scim_scim2-models_pr80 +python-scim_scim2-models_pr81 +python-scim_scim2-models_pr87 +python-scim_scim2-models_pr89 +python-scim_scim2-models_pr9 +python-scim_scim2-models_pr90 +python-scim_scim2-models_pr95 +python-scim_scim2-models_pr96 +python-scim_scim2-models_pr97 +python-scim_scim2-models_pr98 +python-semver_python-semver_pr124 +python-semver_python-semver_pr132 +python-semver_python-semver_pr140 +python-semver_python-semver_pr141 +python-semver_python-semver_pr152 +python-semver_python-semver_pr193 +python-semver_python-semver_pr198 +python-semver_python-semver_pr209 +python-semver_python-semver_pr22 +python-semver_python-semver_pr228 +python-semver_python-semver_pr23 +python-semver_python-semver_pr243 +python-semver_python-semver_pr245 +python-semver_python-semver_pr254 +python-semver_python-semver_pr264 +python-semver_python-semver_pr292 +python-semver_python-semver_pr318 +python-semver_python-semver_pr320 +python-semver_python-semver_pr359 +python-semver_python-semver_pr362 +python-semver_python-semver_pr365 +python-semver_python-semver_pr368 +python-semver_python-semver_pr388 +python-semver_python-semver_pr389 +python-semver_python-semver_pr402 +python-semver_python-semver_pr411 +python-semver_python-semver_pr420 +python-semver_python-semver_pr439 +python-semver_python-semver_pr445 +python-semver_python-semver_pr462 +python-semver_python-semver_pr6 +python-semver_python-semver_pr88 +python-semver_python-semver_pr97 +python-semver_python-semver_pr99 +python-tap_tappy_pr101 +python-tap_tappy_pr108 +python-tap_tappy_pr132 +python-tap_tappy_pr163 +python-tap_tappy_pr32 +python-tap_tappy_pr69 +python-tap_tappy_pr70 +python-tap_tappy_pr75 +python-tap_tappy_pr79 +python-tap_tappy_pr80 +python-tap_tappy_pr9 +python-tap_tappy_pr92 +python-trio_flake8-async_pr10 +python-trio_flake8-async_pr100 +python-trio_flake8-async_pr107 +python-trio_flake8-async_pr108 +python-trio_flake8-async_pr109 +python-trio_flake8-async_pr119 +python-trio_flake8-async_pr125 +python-trio_flake8-async_pr126 +python-trio_flake8-async_pr130 +python-trio_flake8-async_pr140 +python-trio_flake8-async_pr143 +python-trio_flake8-async_pr145 +python-trio_flake8-async_pr146 +python-trio_flake8-async_pr149 +python-trio_flake8-async_pr150 +python-trio_flake8-async_pr151 +python-trio_flake8-async_pr154 +python-trio_flake8-async_pr157 +python-trio_flake8-async_pr16 +python-trio_flake8-async_pr161 +python-trio_flake8-async_pr163 +python-trio_flake8-async_pr188 +python-trio_flake8-async_pr20 +python-trio_flake8-async_pr203 +python-trio_flake8-async_pr206 +python-trio_flake8-async_pr22 +python-trio_flake8-async_pr221 +python-trio_flake8-async_pr232 +python-trio_flake8-async_pr242 +python-trio_flake8-async_pr244 +python-trio_flake8-async_pr25 +python-trio_flake8-async_pr254 +python-trio_flake8-async_pr255 +python-trio_flake8-async_pr265 +python-trio_flake8-async_pr27 +python-trio_flake8-async_pr279 +python-trio_flake8-async_pr287 +python-trio_flake8-async_pr292 +python-trio_flake8-async_pr296 +python-trio_flake8-async_pr303 +python-trio_flake8-async_pr316 +python-trio_flake8-async_pr317 +python-trio_flake8-async_pr32 +python-trio_flake8-async_pr321 +python-trio_flake8-async_pr323 +python-trio_flake8-async_pr326 +python-trio_flake8-async_pr327 +python-trio_flake8-async_pr34 +python-trio_flake8-async_pr356 +python-trio_flake8-async_pr363 +python-trio_flake8-async_pr374 +python-trio_flake8-async_pr376 +python-trio_flake8-async_pr379 +python-trio_flake8-async_pr42 +python-trio_flake8-async_pr44 +python-trio_flake8-async_pr49 +python-trio_flake8-async_pr5 +python-trio_flake8-async_pr67 +python-trio_flake8-async_pr68 +python-trio_flake8-async_pr75 +python-trio_flake8-async_pr76 +python-trio_flake8-async_pr78 +python-trio_flake8-async_pr8 +python-trio_flake8-async_pr81 +python-trio_flake8-async_pr86 +python-trio_flake8-async_pr9 +python-trio_flake8-async_pr90 +python-trio_flake8-async_pr91 +python-trio_flake8-async_pr98 +python-trio_trio-websocket_pr183 +python-validators_validators_pr184 +python-validators_validators_pr201 +python-validators_validators_pr225 +python-validators_validators_pr231 +python-validators_validators_pr232 +python-validators_validators_pr235 +python-validators_validators_pr236 +python-validators_validators_pr239 +python-validators_validators_pr240 +python-validators_validators_pr241 +python-validators_validators_pr249 +python-validators_validators_pr252 +python-validators_validators_pr262 +python-validators_validators_pr264 +python-validators_validators_pr295 +python-validators_validators_pr297 +python-validators_validators_pr308 +python-validators_validators_pr334 +python-validators_validators_pr339 +python-validators_validators_pr347 +python-validators_validators_pr350 +python-validators_validators_pr351 +python-validators_validators_pr353 +python-validators_validators_pr354 +python-validators_validators_pr356 +python-validators_validators_pr357 +python-validators_validators_pr359 +python-validators_validators_pr367 +python-validators_validators_pr374 +python-validators_validators_pr379 +python-validators_validators_pr383 +python-validators_validators_pr384 +python-validators_validators_pr386 +python-validators_validators_pr387 +python-validators_validators_pr389 +python-validators_validators_pr409 +python-validators_validators_pr415 +python-validators_validators_pr417 +python-visualization_branca_pr11 +python-visualization_branca_pr39 +python-visualization_branca_pr4 +python-websockets_websockets_pr1535 +python-websockets_websockets_pr1541 +python-websockets_websockets_pr1543 +python-websockets_websockets_pr1585 +pythonnet_clr-loader_pr32 +pythonnet_clr-loader_pr43 +pytransitions_transitions_pr109 +pytransitions_transitions_pr11 +pytransitions_transitions_pr114 +pytransitions_transitions_pr12 +pytransitions_transitions_pr136 +pytransitions_transitions_pr143 +pytransitions_transitions_pr145 +pytransitions_transitions_pr154 +pytransitions_transitions_pr158 +pytransitions_transitions_pr172 +pytransitions_transitions_pr176 +pytransitions_transitions_pr179 +pytransitions_transitions_pr180 +pytransitions_transitions_pr184 +pytransitions_transitions_pr193 +pytransitions_transitions_pr197 +pytransitions_transitions_pr2 +pytransitions_transitions_pr217 +pytransitions_transitions_pr23 +pytransitions_transitions_pr239 +pytransitions_transitions_pr244 +pytransitions_transitions_pr254 +pytransitions_transitions_pr266 +pytransitions_transitions_pr317 +pytransitions_transitions_pr357 +pytransitions_transitions_pr378 +pytransitions_transitions_pr386 +pytransitions_transitions_pr44 +pytransitions_transitions_pr47 +pytransitions_transitions_pr61 +pytransitions_transitions_pr662 +pytransitions_transitions_pr676 +pytransitions_transitions_pr694 +pytransitions_transitions_pr712 +pytransitions_transitions_pr73 +pytransitions_transitions_pr8 +pytransitions_transitions_pr80 +pytransitions_transitions_pr88 +pytroll_donfig_pr22 +pytroll_donfig_pr49 +pytroll_donfig_pr59 +pytroll_donfig_pr60 +pytroll_donfig_pr63 +pyupio_dparse_pr18 +pyupio_dparse_pr68 +pyupio_dparse_pr76 +pyusb_pyusb_pr479 +pyvisa_pyvisa-py_pr269 +pyvisa_pyvisa-py_pr292 +pyvisa_pyvisa-py_pr294 +pyvisa_pyvisa-py_pr335 +pyvisa_pyvisa-py_pr349 +pyvisa_pyvisa-py_pr350 +pyvisa_pyvisa-py_pr352 +pyvisa_pyvisa-py_pr362 +pyvisa_pyvisa-py_pr379 +pyvisa_pyvisa-py_pr386 +pyvisa_pyvisa-py_pr402 +pyvisa_pyvisa-py_pr417 +pyvisa_pyvisa-py_pr430 +pyvisa_pyvisa-py_pr484 +pyvisa_pyvisa-py_pr496 +pyvisa_pyvisa-py_pr523 +pyvisa_pyvisa-py_pr530 +pyvisa_pyvisa-sim_pr75 +pyvisa_pyvisa-sim_pr78 +pyvisa_pyvisa-sim_pr96 +pyvisa_pyvisa_pr143 +pyvisa_pyvisa_pr151 +pyvisa_pyvisa_pr156 +pyvisa_pyvisa_pr172 +pyvisa_pyvisa_pr299 +pyvisa_pyvisa_pr340 +pyvisa_pyvisa_pr341 +pyvisa_pyvisa_pr349 +pyvisa_pyvisa_pr363 +pyvisa_pyvisa_pr391 +pyvisa_pyvisa_pr486 +pyvisa_pyvisa_pr509 +pyvisa_pyvisa_pr536 +pyvisa_pyvisa_pr540 +pyvisa_pyvisa_pr545 +pyvisa_pyvisa_pr547 +pyvisa_pyvisa_pr550 +pyvisa_pyvisa_pr552 +pyvisa_pyvisa_pr581 +pyvisa_pyvisa_pr598 +pyvisa_pyvisa_pr600 +pyvisa_pyvisa_pr653 +pyvisa_pyvisa_pr697 +pyvisa_pyvisa_pr699 +pyvisa_pyvisa_pr725 +pyvisa_pyvisa_pr733 +pyvisa_pyvisa_pr753 +pyvisa_pyvisa_pr774 +pyvisa_pyvisa_pr776 +pyvisa_pyvisa_pr787 +pyvisa_pyvisa_pr811 +pyvisa_pyvisa_pr859 +pyvisa_pyvisa_pr887 +pyvisa_pyvisa_pr892 +pyvisa_pyvisa_pr914 +pyvista_pyminiply_pr14 +pyvista_pyminiply_pr16 +qiskit-community_qiskit-ionq_pr102 +qiskit-community_qiskit-ionq_pr107 +qiskit-community_qiskit-ionq_pr108 +qiskit-community_qiskit-ionq_pr109 +qiskit-community_qiskit-ionq_pr111 +qiskit-community_qiskit-ionq_pr114 +qiskit-community_qiskit-ionq_pr124 +qiskit-community_qiskit-ionq_pr132 +qiskit-community_qiskit-ionq_pr135 +qiskit-community_qiskit-ionq_pr142 +qiskit-community_qiskit-ionq_pr144 +qiskit-community_qiskit-ionq_pr154 +qiskit-community_qiskit-ionq_pr155 +qiskit-community_qiskit-ionq_pr166 +qiskit-community_qiskit-ionq_pr174 +qiskit-community_qiskit-ionq_pr182 +qiskit-community_qiskit-ionq_pr185 +qiskit-community_qiskit-ionq_pr191 +qiskit-community_qiskit-ionq_pr196 +qiskit-community_qiskit-ionq_pr200 +qiskit-community_qiskit-ionq_pr202 +qiskit-community_qiskit-ionq_pr203 +qiskit-community_qiskit-ionq_pr208 +qiskit-community_qiskit-ionq_pr214 +qiskit-community_qiskit-ionq_pr223 +qiskit-community_qiskit-ionq_pr232 +qiskit-community_qiskit-ionq_pr236 +qiskit-community_qiskit-ionq_pr44 +qiskit-community_qiskit-ionq_pr51 +qiskit-community_qiskit-ionq_pr57 +qiskit-community_qiskit-ionq_pr82 +qiskit-community_qiskit-ionq_pr89 +qiskit-community_qiskit-ionq_pr94 +qiskit-community_qiskit-ionq_pr96 +qntm_greenery_pr110 +qntm_greenery_pr30 +qntm_greenery_pr53 +qntm_greenery_pr60 +qntm_greenery_pr65 +qntm_greenery_pr68 +qntm_greenery_pr69 +qntm_greenery_pr71 +qntm_greenery_pr72 +qntm_greenery_pr85 +qntm_greenery_pr87 +qntm_greenery_pr89 +qntm_greenery_pr90 +qntm_greenery_pr91 +qntm_greenery_pr98 +qntm_greenery_pr99 +qua-platform_py-qua-tools_pr196 +quantumgizmos_ldpc_pr46 +quantumgizmos_ldpc_pr50 +quintoandar_hive-metastore-client_pr13 +quintoandar_hive-metastore-client_pr30 +quintoandar_hive-metastore-client_pr37 +quintoandar_hive-metastore-client_pr39 +quintoandar_hive-metastore-client_pr42 +quintoandar_hive-metastore-client_pr43 +quintoandar_hive-metastore-client_pr49 +quintoandar_hive-metastore-client_pr55 +quintoandar_hive-metastore-client_pr64 +qulacs_qulacs_pr179 +r1chardj0n3s_parse_pr103 +r1chardj0n3s_parse_pr115 +r1chardj0n3s_parse_pr124 +r1chardj0n3s_parse_pr128 +r1chardj0n3s_parse_pr132 +r1chardj0n3s_parse_pr134 +r1chardj0n3s_parse_pr139 +r1chardj0n3s_parse_pr174 +r1chardj0n3s_parse_pr178 +r1chardj0n3s_parse_pr184 +r1chardj0n3s_parse_pr23 +r1chardj0n3s_parse_pr24 +r1chardj0n3s_parse_pr36 +r1chardj0n3s_parse_pr38 +r1chardj0n3s_parse_pr67 +r1chardj0n3s_parse_pr74 +r1chardj0n3s_parse_pr75 +r1chardj0n3s_parse_pr81 +r1chardj0n3s_parse_pr95 +r1chardj0n3s_parse_pr96 +radish-bdd_radish_pr303 +radish-bdd_radish_pr307 +radish-bdd_radish_pr309 +radish-bdd_radish_pr383 +radish-bdd_radish_pr391 +radish-bdd_radish_pr393 +radish-bdd_radish_pr395 +radish-bdd_radish_pr426 +radish-bdd_radish_pr447 +radish-bdd_radish_pr451 +radish-bdd_radish_pr457 +radish-bdd_radish_pr472 +radish-bdd_radish_pr486 +radish-bdd_radish_pr488 +raimon49_pip-licenses_pr102 +raimon49_pip-licenses_pr127 +raimon49_pip-licenses_pr136 +raimon49_pip-licenses_pr150 +raimon49_pip-licenses_pr152 +raimon49_pip-licenses_pr153 +raimon49_pip-licenses_pr158 +raimon49_pip-licenses_pr162 +raimon49_pip-licenses_pr173 +raimon49_pip-licenses_pr56 +raimon49_pip-licenses_pr58 +raimon49_pip-licenses_pr62 +raimon49_pip-licenses_pr64 +raimon49_pip-licenses_pr68 +raimon49_pip-licenses_pr76 +raimon49_pip-licenses_pr83 +raimon49_pip-licenses_pr86 +raimon49_pip-licenses_pr99 +ramonhagenaars_jsons_pr36 +ramonhagenaars_jsons_pr58 +ramonhagenaars_jsons_pr59 +ramonhagenaars_jsons_pr7 +ramonhagenaars_jsons_pr73 +ramonhagenaars_typish_pr10 +ramonhagenaars_typish_pr27 +ramonhagenaars_typish_pr5 +ramonhagenaars_typish_pr9 +raphaelm_python-sepaxml_pr30 +raphaelm_python-sepaxml_pr36 +raphaelm_python-sepaxml_pr5 +raphaelm_python-sepaxml_pr64 +raphaelm_python-sepaxml_pr9 +rasahq_rasa-sdk_pr103 +rasahq_rasa-sdk_pr105 +rasahq_rasa-sdk_pr18 +rasahq_rasa-sdk_pr20 +rasahq_rasa-sdk_pr38 +rasahq_rasa-sdk_pr45 +rasahq_rasa-sdk_pr46 +rasahq_rasa-sdk_pr47 +rasahq_rasa-sdk_pr49 +rasahq_rasa-sdk_pr57 +rasahq_rasa-sdk_pr65 +rasahq_rasa-sdk_pr67 +rasahq_rasa-sdk_pr74 +rasahq_rasa-sdk_pr88 +rasterio_affine_pr11 +rasterio_affine_pr117 +rasterio_affine_pr119 +rasterio_affine_pr121 +rasterio_affine_pr126 +rasterio_affine_pr20 +rasterio_affine_pr28 +rasterio_affine_pr35 +rasterio_affine_pr41 +rasterio_affine_pr52 +rasterio_affine_pr7 +rasterio_affine_pr72 +rasterio_affine_pr92 +rasterio_affine_pr96 +ratoaq2_knowit_pr203 +rayokota_jsonata-python_pr14 +rayokota_jsonata-python_pr23 +rbw_pysnow_pr11 +rbw_pysnow_pr18 +rbw_pysnow_pr20 +rbw_pysnow_pr24 +rbw_pysnow_pr41 +rbw_pysnow_pr46 +rbw_pysnow_pr48 +rbw_pysnow_pr50 +rbw_pysnow_pr52 +rbw_pysnow_pr54 +rbw_pysnow_pr59 +rbw_pysnow_pr67 +rbw_pysnow_pr71 +rbw_pysnow_pr73 +rbw_pysnow_pr82 +rbw_pysnow_pr89 +rbw_pysnow_pr91 +readthedocs_sphinx-autoapi_pr284 +readthedocs_sphinx-autoapi_pr353 +readthedocs_sphinx-autoapi_pr362 +readthedocs_sphinx-autoapi_pr423 +readthedocs_sphinx-autoapi_pr497 +readthedocs_sphinx-autoapi_pr538 +recognai_spacy-wordnet_pr11 +reef-technologies_logfury_pr9 +regebro_svg.path_pr108 +regebro_svg.path_pr110 +regebro_svg.path_pr111 +regebro_svg.path_pr73 +regebro_svg.path_pr77 +regebro_svg.path_pr83 +regebro_svg.path_pr92 +regebro_svg.path_pr99 +regebro_tzlocal_pr114 +regebro_tzlocal_pr116 +regebro_tzlocal_pr145 +regionmask_regionmask_pr18 +regionmask_regionmask_pr250 +regionmask_regionmask_pr255 +regionmask_regionmask_pr261 +regionmask_regionmask_pr267 +regionmask_regionmask_pr271 +regionmask_regionmask_pr280 +regionmask_regionmask_pr283 +regionmask_regionmask_pr289 +regionmask_regionmask_pr292 +regionmask_regionmask_pr294 +regionmask_regionmask_pr296 +regionmask_regionmask_pr297 +regionmask_regionmask_pr298 +regionmask_regionmask_pr305 +regionmask_regionmask_pr320 +regionmask_regionmask_pr321 +regionmask_regionmask_pr335 +regionmask_regionmask_pr361 +regionmask_regionmask_pr362 +regionmask_regionmask_pr369 +regionmask_regionmask_pr371 +regionmask_regionmask_pr373 +regionmask_regionmask_pr375 +regionmask_regionmask_pr378 +regionmask_regionmask_pr380 +regionmask_regionmask_pr381 +regionmask_regionmask_pr393 +regionmask_regionmask_pr396 +regionmask_regionmask_pr403 +regionmask_regionmask_pr405 +regionmask_regionmask_pr406 +regionmask_regionmask_pr41 +regionmask_regionmask_pr414 +regionmask_regionmask_pr417 +regionmask_regionmask_pr424 +regionmask_regionmask_pr425 +regionmask_regionmask_pr427 +regionmask_regionmask_pr428 +regionmask_regionmask_pr429 +regionmask_regionmask_pr436 +regionmask_regionmask_pr439 +regionmask_regionmask_pr44 +regionmask_regionmask_pr442 +regionmask_regionmask_pr45 +regionmask_regionmask_pr454 +regionmask_regionmask_pr466 +regionmask_regionmask_pr47 +regionmask_regionmask_pr470 +regionmask_regionmask_pr472 +regionmask_regionmask_pr478 +regionmask_regionmask_pr479 +regionmask_regionmask_pr48 +regionmask_regionmask_pr486 +regionmask_regionmask_pr493 +regionmask_regionmask_pr498 +regionmask_regionmask_pr519 +regionmask_regionmask_pr521 +regionmask_regionmask_pr55 +regionmask_regionmask_pr554 +regionmask_regionmask_pr557 +regionmask_regionmask_pr560 +regionmask_regionmask_pr569 +regionmask_regionmask_pr570 +regionmask_regionmask_pr575 +regionmask_regionmask_pr576 +regionmask_regionmask_pr586 +regionmask_regionmask_pr592 +regionmask_regionmask_pr60 +regionmask_regionmask_pr614 +regionmask_regionmask_pr65 +regionmask_regionmask_pr68 +remcohaszing_pywakeonlan_pr24 +remcohaszing_pywakeonlan_pr26 +renanivo_pytest-testdox_pr93 +renatopp_liac-arff_pr34 +renatopp_liac-arff_pr37 +renatopp_liac-arff_pr38 +renatopp_liac-arff_pr51 +renatopp_liac-arff_pr56 +renatopp_liac-arff_pr63 +renatopp_liac-arff_pr65 +renatopp_liac-arff_pr85 +renatopp_liac-arff_pr91 +reportportal_agent-python-behave_pr22 +reportportal_agent-python-behave_pr34 +reportportal_agent-python-behave_pr38 +reportportal_agent-python-behave_pr39 +reportportal_agent-python-behave_pr4 +reportportal_agent-python-behave_pr6 +reportportal_agent-python-pytest_pr175 +reportportal_agent-python-pytest_pr178 +reportportal_agent-python-pytest_pr202 +reportportal_agent-python-pytest_pr203 +reportportal_agent-python-pytest_pr209 +reportportal_agent-python-pytest_pr212 +reportportal_agent-python-pytest_pr215 +reportportal_agent-python-pytest_pr238 +reportportal_agent-python-pytest_pr240 +reportportal_agent-python-pytest_pr245 +reportportal_agent-python-pytest_pr264 +reportportal_agent-python-pytest_pr271 +reportportal_agent-python-pytest_pr274 +reportportal_agent-python-pytest_pr283 +reportportal_agent-python-pytest_pr285 +reportportal_agent-python-pytest_pr286 +reportportal_agent-python-pytest_pr291 +reportportal_agent-python-pytest_pr296 +reportportal_agent-python-pytest_pr373 +reportportal_agent-python-pytest_pr377 +reportportal_agent-python-pytest_pr378 +reportportal_agent-python-pytest_pr386 +reportportal_agent-python-pytest_pr387 +richard-gyiko_json-schema-to-pydantic_pr19 +richard-gyiko_json-schema-to-pydantic_pr20 +richard-gyiko_json-schema-to-pydantic_pr26 +richard-gyiko_json-schema-to-pydantic_pr31 +richardkiss_pycoin_pr108 +richardkiss_pycoin_pr110 +richardkiss_pycoin_pr111 +richardkiss_pycoin_pr117 +richardkiss_pycoin_pr123 +richardkiss_pycoin_pr124 +richardkiss_pycoin_pr128 +richardkiss_pycoin_pr133 +richardkiss_pycoin_pr137 +richardkiss_pycoin_pr145 +richardkiss_pycoin_pr157 +richardkiss_pycoin_pr172 +richardkiss_pycoin_pr177 +richardkiss_pycoin_pr24 +richardkiss_pycoin_pr392 +richardkiss_pycoin_pr40 +richardkiss_pycoin_pr400 +richardkiss_pycoin_pr42 +richardkiss_pycoin_pr44 +richardkiss_pycoin_pr63 +richardkiss_pycoin_pr80 +richardkiss_pycoin_pr82 +richardkiss_pycoin_pr88 +richardkiss_pycoin_pr90 +rlabbe_filterpy_pr192 +rlabbe_filterpy_pr194 +robotools_defcon_pr100 +robotools_defcon_pr110 +robotools_defcon_pr112 +robotools_defcon_pr113 +robotools_defcon_pr179 +robotools_defcon_pr180 +robotools_defcon_pr181 +robotools_defcon_pr183 +robotools_defcon_pr189 +robotools_defcon_pr199 +robotools_defcon_pr258 +robotools_defcon_pr269 +robotools_defcon_pr337 +robotools_defcon_pr338 +robotools_defcon_pr344 +robotools_defcon_pr348 +robotools_defcon_pr352 +robotools_defcon_pr367 +robotools_defcon_pr397 +robotools_defcon_pr402 +robotools_defcon_pr469 +robsdedude_flake8-picky-parentheses_pr16 +robsdedude_flake8-picky-parentheses_pr20 +robsdedude_flake8-picky-parentheses_pr23 +robsdedude_flake8-picky-parentheses_pr26 +robsdedude_flake8-picky-parentheses_pr34 +robsdedude_flake8-picky-parentheses_pr43 +rockem_busypie_pr12 +rockem_busypie_pr21 +rockem_busypie_pr28 +rockem_busypie_pr35 +rockem_busypie_pr38 +rockem_busypie_pr44 +rockem_busypie_pr47 +rockem_busypie_pr5 +rockem_busypie_pr62 +rokam_midea-local_pr127 +rokam_midea-local_pr17 +rokam_midea-local_pr176 +rokam_midea-local_pr177 +rokam_midea-local_pr179 +rokam_midea-local_pr189 +rokam_midea-local_pr191 +rokam_midea-local_pr199 +rokam_midea-local_pr200 +rokam_midea-local_pr209 +rokam_midea-local_pr21 +rokam_midea-local_pr210 +rokam_midea-local_pr212 +rokam_midea-local_pr214 +rokam_midea-local_pr22 +rokam_midea-local_pr221 +rokam_midea-local_pr227 +rokam_midea-local_pr232 +rokam_midea-local_pr235 +rokam_midea-local_pr241 +rokam_midea-local_pr245 +rokam_midea-local_pr248 +rokam_midea-local_pr25 +rokam_midea-local_pr251 +rokam_midea-local_pr256 +rokam_midea-local_pr263 +rokam_midea-local_pr265 +rokam_midea-local_pr270 +rokam_midea-local_pr271 +rokam_midea-local_pr276 +rokam_midea-local_pr278 +rokam_midea-local_pr284 +rokam_midea-local_pr294 +rokam_midea-local_pr304 +rokam_midea-local_pr329 +rokam_midea-local_pr336 +rokam_midea-local_pr337 +rokam_midea-local_pr338 +rokam_midea-local_pr341 +rokam_midea-local_pr343 +rokam_midea-local_pr350 +rokam_midea-local_pr351 +rokam_midea-local_pr353 +rokam_midea-local_pr354 +rokam_midea-local_pr358 +rokam_midea-local_pr359 +rokam_midea-local_pr36 +rokam_midea-local_pr360 +rokam_midea-local_pr363 +rokam_midea-local_pr364 +rokam_midea-local_pr366 +rokam_midea-local_pr368 +rokam_midea-local_pr369 +rokam_midea-local_pr370 +rokam_midea-local_pr371 +rokam_midea-local_pr374 +rokam_midea-local_pr376 +rokam_midea-local_pr379 +rokam_midea-local_pr385 +rokam_midea-local_pr386 +rokam_midea-local_pr389 +rokam_midea-local_pr399 +rokam_midea-local_pr40 +rokam_midea-local_pr407 +rokam_midea-local_pr408 +rokam_midea-local_pr41 +rokam_midea-local_pr411 +rokam_midea-local_pr412 +rokam_midea-local_pr48 +rokam_midea-local_pr5 +rokam_midea-local_pr51 +rokam_midea-local_pr57 +rokam_midea-local_pr67 +rokam_midea-local_pr68 +rollbar_pyrollbar_pr19 +rollbar_pyrollbar_pr448 +rollbar_pyrollbar_pr449 +rollbar_pyrollbar_pr450 +rollbar_pyrollbar_pr461 +rollbar_pyrollbar_pr468 +rollbar_pyrollbar_pr469 +rollbar_pyrollbar_pr470 +rollbar_pyrollbar_pr471 +rollbar_pyrollbar_pr474 +rollbar_pyrollbar_pr479 +rom1504_embedding-reader_pr16 +rom1504_embedding-reader_pr25 +rom1504_embedding-reader_pr9 +roniemartinez_latex2mathml_pr10 +roniemartinez_latex2mathml_pr102 +roniemartinez_latex2mathml_pr107 +roniemartinez_latex2mathml_pr111 +roniemartinez_latex2mathml_pr114 +roniemartinez_latex2mathml_pr116 +roniemartinez_latex2mathml_pr119 +roniemartinez_latex2mathml_pr121 +roniemartinez_latex2mathml_pr126 +roniemartinez_latex2mathml_pr132 +roniemartinez_latex2mathml_pr136 +roniemartinez_latex2mathml_pr137 +roniemartinez_latex2mathml_pr138 +roniemartinez_latex2mathml_pr139 +roniemartinez_latex2mathml_pr140 +roniemartinez_latex2mathml_pr141 +roniemartinez_latex2mathml_pr143 +roniemartinez_latex2mathml_pr144 +roniemartinez_latex2mathml_pr145 +roniemartinez_latex2mathml_pr146 +roniemartinez_latex2mathml_pr147 +roniemartinez_latex2mathml_pr148 +roniemartinez_latex2mathml_pr149 +roniemartinez_latex2mathml_pr150 +roniemartinez_latex2mathml_pr151 +roniemartinez_latex2mathml_pr153 +roniemartinez_latex2mathml_pr154 +roniemartinez_latex2mathml_pr156 +roniemartinez_latex2mathml_pr157 +roniemartinez_latex2mathml_pr158 +roniemartinez_latex2mathml_pr159 +roniemartinez_latex2mathml_pr163 +roniemartinez_latex2mathml_pr164 +roniemartinez_latex2mathml_pr165 +roniemartinez_latex2mathml_pr166 +roniemartinez_latex2mathml_pr167 +roniemartinez_latex2mathml_pr168 +roniemartinez_latex2mathml_pr169 +roniemartinez_latex2mathml_pr170 +roniemartinez_latex2mathml_pr171 +roniemartinez_latex2mathml_pr172 +roniemartinez_latex2mathml_pr174 +roniemartinez_latex2mathml_pr177 +roniemartinez_latex2mathml_pr179 +roniemartinez_latex2mathml_pr180 +roniemartinez_latex2mathml_pr181 +roniemartinez_latex2mathml_pr182 +roniemartinez_latex2mathml_pr183 +roniemartinez_latex2mathml_pr184 +roniemartinez_latex2mathml_pr185 +roniemartinez_latex2mathml_pr187 +roniemartinez_latex2mathml_pr188 +roniemartinez_latex2mathml_pr192 +roniemartinez_latex2mathml_pr195 +roniemartinez_latex2mathml_pr196 +roniemartinez_latex2mathml_pr198 +roniemartinez_latex2mathml_pr199 +roniemartinez_latex2mathml_pr200 +roniemartinez_latex2mathml_pr201 +roniemartinez_latex2mathml_pr204 +roniemartinez_latex2mathml_pr205 +roniemartinez_latex2mathml_pr206 +roniemartinez_latex2mathml_pr207 +roniemartinez_latex2mathml_pr208 +roniemartinez_latex2mathml_pr209 +roniemartinez_latex2mathml_pr210 +roniemartinez_latex2mathml_pr212 +roniemartinez_latex2mathml_pr213 +roniemartinez_latex2mathml_pr216 +roniemartinez_latex2mathml_pr217 +roniemartinez_latex2mathml_pr218 +roniemartinez_latex2mathml_pr234 +roniemartinez_latex2mathml_pr246 +roniemartinez_latex2mathml_pr258 +roniemartinez_latex2mathml_pr304 +roniemartinez_latex2mathml_pr306 +roniemartinez_latex2mathml_pr308 +roniemartinez_latex2mathml_pr309 +roniemartinez_latex2mathml_pr310 +roniemartinez_latex2mathml_pr311 +roniemartinez_latex2mathml_pr315 +roniemartinez_latex2mathml_pr316 +roniemartinez_latex2mathml_pr318 +roniemartinez_latex2mathml_pr319 +roniemartinez_latex2mathml_pr327 +roniemartinez_latex2mathml_pr379 +roniemartinez_latex2mathml_pr388 +roniemartinez_latex2mathml_pr393 +roniemartinez_latex2mathml_pr395 +roniemartinez_latex2mathml_pr43 +roniemartinez_latex2mathml_pr47 +roniemartinez_latex2mathml_pr48 +roniemartinez_latex2mathml_pr54 +roniemartinez_latex2mathml_pr65 +roniemartinez_latex2mathml_pr66 +roniemartinez_latex2mathml_pr74 +roniemartinez_latex2mathml_pr83 +roniemartinez_latex2mathml_pr86 +roniemartinez_latex2mathml_pr88 +roniemartinez_latex2mathml_pr93 +roniemartinez_latex2mathml_pr95 +roniemartinez_latex2mathml_pr97 +roniemartinez_latex2mathml_pr99 +ros-infrastructure_rosdep_pr640 +ros-infrastructure_rosdep_pr656 +ros-infrastructure_rosdep_pr692 +ros-infrastructure_rosdep_pr701 +ros-infrastructure_rosdep_pr726 +ros-infrastructure_rosdep_pr757 +ros-infrastructure_rosdep_pr787 +ros-infrastructure_rosdep_pr789 +ros-infrastructure_rosdep_pr815 +ros-infrastructure_rosdep_pr838 +ros-infrastructure_rosdep_pr846 +ros-infrastructure_rosdep_pr848 +ros-infrastructure_rosdep_pr862 +ros-infrastructure_rosdep_pr926 +ros-infrastructure_rosdep_pr949 +ros-infrastructure_rosdep_pr960 +ros-infrastructure_rosdep_pr975 +ros-infrastructure_rosdep_pr979 +ros-infrastructure_rosdep_pr997 +roskakori_pygount_pr101 +roskakori_pygount_pr115 +roskakori_pygount_pr148 +roskakori_pygount_pr165 +roskakori_pygount_pr168 +roskakori_pygount_pr169 +roskakori_pygount_pr170 +roskakori_pygount_pr186 +roskakori_pygount_pr188 +roskakori_pygount_pr189 +roskakori_pygount_pr203 +roskakori_pygount_pr32 +roskakori_pygount_pr34 +roskakori_pygount_pr43 +roskakori_pygount_pr85 +roskakori_pygount_pr86 +roskakori_pygount_pr90 +roskakori_pygount_pr96 +rossumai_rossum_pr20 +rossumai_rossum_pr28 +rossumai_rossum_pr33 +rossumai_rossum_pr36 +rossumai_rossum_pr4 +rossumai_rossum_pr6 +rossumai_rossum_pr8 +rstcheck_rstcheck-core_pr12 +rstcheck_rstcheck-core_pr24 +rstcheck_rstcheck-core_pr69 +rstudio_py-shinyswatch_pr12 +rstudio_py-shinyswatch_pr51 +rtfd_recommonmark_pr122 +rtfd_recommonmark_pr150 +rtfd_recommonmark_pr160 +rtfd_recommonmark_pr162 +rubik_radon_pr106 +rubik_radon_pr117 +rubik_radon_pr118 +rubik_radon_pr135 +rubik_radon_pr136 +rubik_radon_pr147 +rubik_radon_pr181 +rubik_radon_pr200 +rubik_radon_pr208 +rubik_radon_pr213 +rubik_radon_pr218 +rubik_radon_pr236 +rugleb_jsoncomparison_pr26 +russhousley_pyasn1-alt-modules_pr1 +russhousley_pyasn1-alt-modules_pr2 +russhousley_pyasn1-alt-modules_pr4 +russhousley_pyasn1-alt-modules_pr45 +russhousley_pyasn1-alt-modules_pr48 +russhousley_pyasn1-alt-modules_pr50 +russhousley_pyasn1-alt-modules_pr53 +russhousley_pyasn1-alt-modules_pr54 +russhousley_pyasn1-alt-modules_pr56 +russhousley_pyasn1-alt-modules_pr69 +russhousley_pyasn1-alt-modules_pr7 +russhousley_pyasn1-alt-modules_pr71 +russhousley_pyasn1-alt-modules_pr73 +russhousley_pyasn1-alt-modules_pr74 +russhousley_pyasn1-alt-modules_pr80 +russhousley_pyasn1-alt-modules_pr81 +russhousley_pyasn1-alt-modules_pr84 +russhousley_pyasn1-alt-modules_pr85 +russhousley_pyasn1-alt-modules_pr86 +russhousley_pyasn1-alt-modules_pr87 +russhousley_pyasn1-alt-modules_pr89 +russhousley_pyasn1-alt-modules_pr92 +rveachkc_pymsteams_pr40 +s4v4g3_otel-extensions-python_pr4 +salesforce_cloudsplaining_pr100 +salesforce_cloudsplaining_pr108 +salesforce_cloudsplaining_pr14 +salesforce_cloudsplaining_pr167 +salesforce_cloudsplaining_pr17 +salesforce_cloudsplaining_pr170 +salesforce_cloudsplaining_pr24 +salesforce_cloudsplaining_pr257 +salesforce_cloudsplaining_pr303 +salesforce_cloudsplaining_pr37 +salesforce_cloudsplaining_pr474 +salesforce_cloudsplaining_pr49 +salesforce_cloudsplaining_pr492 +salesforce_cloudsplaining_pr81 +salesforce_cloudsplaining_pr84 +salesforce_cloudsplaining_pr88 +salesforce_cloudsplaining_pr9 +salesforce_cloudsplaining_pr90 +saltstack_libnacl_pr102 +saltstack_libnacl_pr106 +saltstack_libnacl_pr109 +saltstack_libnacl_pr114 +saltstack_libnacl_pr118 +saltstack_libnacl_pr124 +saltstack_libnacl_pr133 +saltstack_libnacl_pr14 +saltstack_libnacl_pr31 +saltstack_libnacl_pr39 +saltstack_libnacl_pr44 +saltstack_libnacl_pr67 +saltstack_libnacl_pr68 +saltstack_libnacl_pr7 +saltstack_libnacl_pr80 +saltstack_libnacl_pr88 +saltstack_libnacl_pr89 +saltstack_libnacl_pr96 +saltstack_libnacl_pr97 +saltstack_libnacl_pr99 +sanders41_camel-converter_pr15 +sanders41_camel-converter_pr174 +sanders41_camel-converter_pr417 +sanders41_camel-converter_pr494 +sangwonl_python-mpegdash_pr20 +sangwonl_python-mpegdash_pr21 +sangwonl_python-mpegdash_pr22 +sangwonl_python-mpegdash_pr28 +sangwonl_python-mpegdash_pr37 +sangwonl_python-mpegdash_pr57 +sanic-org_sanic-routing_pr10 +sanic-org_sanic-routing_pr13 +sanic-org_sanic-routing_pr24 +sanic-org_sanic-routing_pr29 +sanic-org_sanic-routing_pr40 +sanic-org_sanic-routing_pr45 +sanic-org_sanic-routing_pr47 +sanic-org_sanic-routing_pr49 +sanic-org_sanic-routing_pr57 +sanic-org_sanic-routing_pr58 +sanic-org_sanic-routing_pr6 +sanic-org_sanic-routing_pr60 +sanic-org_sanic-routing_pr62 +sanic-org_sanic-routing_pr65 +sanic-org_sanic-routing_pr74 +sanic-org_sanic-routing_pr9 +sayanarijit_expandvars_pr13 +sayanarijit_expandvars_pr17 +sayanarijit_expandvars_pr18 +sayanarijit_expandvars_pr8 +sayanarijit_expandvars_pr9 +sbdchd_codeowners_pr33 +sbdchd_codeowners_pr37 +sbdchd_flake8-pie_pr117 +sbdchd_flake8-pie_pr121 +sbdchd_flake8-pie_pr18 +sbdchd_flake8-pie_pr19 +sbdchd_flake8-pie_pr20 +sbdchd_flake8-pie_pr21 +sbdchd_flake8-pie_pr29 +sbdchd_flake8-pie_pr32 +sbdchd_flake8-pie_pr40 +sbdchd_flake8-pie_pr49 +sbdchd_flake8-pie_pr54 +sbdchd_flake8-pie_pr72 +sbdchd_flake8-pie_pr76 +sbdchd_flake8-pie_pr8 +sbdchd_flake8-pie_pr81 +sbdchd_flake8-pie_pr93 +sbdchd_flake8-pie_pr94 +sbdchd_flake8-pie_pr95 +sbdchd_flake8-pie_pr96 +sbdchd_flake8-pie_pr97 +sbidoul_pyproject-dependencies_pr7 +sbidoul_whool_pr15 +sbidoul_whool_pr21 +sbrunner_jsonschema2md_pr128 +sbrunner_jsonschema2md_pr18 +sbrunner_jsonschema2md_pr2 +sbrunner_jsonschema2md_pr250 +sbrunner_jsonschema2md_pr297 +sbrunner_jsonschema2md_pr331 +sbrunner_jsonschema2md_pr431 +sbrunner_jsonschema2md_pr435 +sbrunner_jsonschema2md_pr437 +sbrunner_jsonschema2md_pr459 +sbtinstruments_asyncio-mqtt_pr234 +sbtinstruments_asyncio-mqtt_pr245 +sbtinstruments_asyncio-mqtt_pr249 +sbtinstruments_asyncio-mqtt_pr255 +sbtinstruments_asyncio-mqtt_pr285 +scastlara_pytest-tagging_pr13 +scastlara_pytest-tagging_pr6 +scikit-build_ninja-python-distributions_pr169 +scikit-build_ninja-python-distributions_pr54 +scikit-build_ninja-python-distributions_pr63 +scikit-build_ninja-python-distributions_pr90 +scikit-build_scikit-build-core_pr12 +scikit-build_scikit-build-core_pr13 +scikit-build_scikit-build-core_pr14 +scikit-build_scikit-build-core_pr16 +scikit-build_scikit-build-core_pr18 +scikit-build_scikit-build-core_pr19 +scikit-build_scikit-build-core_pr20 +scikit-build_scikit-build-core_pr22 +scikit-build_scikit-build-core_pr23 +scikit-build_scikit-build-core_pr25 +scikit-build_scikit-build-core_pr27 +scikit-build_scikit-build-core_pr3 +scikit-build_scikit-build-core_pr30 +scikit-build_scikit-build-core_pr31 +scikit-build_scikit-build-core_pr32 +scikit-build_scikit-build-core_pr8 +scikit-hep_awkward-0.x_pr179 +scikit-hep_awkward-0.x_pr184 +scikit-hep_awkward-0.x_pr188 +scikit-hep_awkward-0.x_pr191 +scikit-hep_awkward-0.x_pr193 +scikit-hep_awkward-0.x_pr194 +scikit-hep_awkward-0.x_pr202 +scikit-hep_awkward-0.x_pr209 +scikit-hep_awkward-0.x_pr248 +scikit-hep_cabinetry_pr19 +scikit-hep_cabinetry_pr22 +scikit-hep_cabinetry_pr32 +scikit-hep_cabinetry_pr34 +scikit-hep_cabinetry_pr35 +scikit-hep_cabinetry_pr47 +scikit-hep_cabinetry_pr48 +scikit-hep_cabinetry_pr49 +scikit-hep_mplhep_pr157 +scikit-hep_mplhep_pr222 +scikit-hep_mplhep_pr274 +scikit-hep_particle_pr101 +scikit-hep_particle_pr11 +scikit-hep_particle_pr114 +scikit-hep_particle_pr117 +scikit-hep_particle_pr119 +scikit-hep_particle_pr121 +scikit-hep_particle_pr128 +scikit-hep_particle_pr137 +scikit-hep_particle_pr139 +scikit-hep_particle_pr14 +scikit-hep_particle_pr144 +scikit-hep_particle_pr15 +scikit-hep_particle_pr155 +scikit-hep_particle_pr159 +scikit-hep_particle_pr16 +scikit-hep_particle_pr161 +scikit-hep_particle_pr174 +scikit-hep_particle_pr176 +scikit-hep_particle_pr186 +scikit-hep_particle_pr2 +scikit-hep_particle_pr20 +scikit-hep_particle_pr21 +scikit-hep_particle_pr231 +scikit-hep_particle_pr234 +scikit-hep_particle_pr26 +scikit-hep_particle_pr27 +scikit-hep_particle_pr32 +scikit-hep_particle_pr34 +scikit-hep_particle_pr45 +scikit-hep_particle_pr46 +scikit-hep_particle_pr47 +scikit-hep_particle_pr48 +scikit-hep_particle_pr51 +scikit-hep_particle_pr57 +scikit-hep_particle_pr6 +scikit-hep_particle_pr68 +scikit-hep_particle_pr70 +scikit-hep_particle_pr73 +scikit-hep_particle_pr74 +scikit-hep_particle_pr75 +scikit-hep_particle_pr76 +scikit-hep_particle_pr77 +scikit-hep_particle_pr83 +scikit-hep_particle_pr86 +scikit-hep_particle_pr90 +scikit-hep_particle_pr92 +scikit-hep_particle_pr93 +scikit-hep_particle_pr95 +scikit-hep_uproot3-methods_pr1 +scikit-hep_uproot3-methods_pr29 +scikit-hep_uproot3-methods_pr37 +scikit-hep_uproot3-methods_pr42 +scikit-hep_uproot3-methods_pr43 +scikit-hep_uproot3-methods_pr48 +scikit-hep_uproot3-methods_pr51 +scikit-hep_uproot3-methods_pr57 +scikit-hep_uproot3-methods_pr9 +scikit-hep_uproot3_pr106 +scikit-hep_uproot3_pr112 +scikit-hep_uproot3_pr114 +scikit-hep_uproot3_pr115 +scikit-hep_uproot3_pr230 +scikit-hep_uproot3_pr242 +scikit-hep_uproot3_pr258 +scikit-hep_uproot3_pr265 +scikit-hep_uproot3_pr271 +scikit-hep_uproot3_pr282 +scikit-hep_uproot3_pr291 +scikit-hep_uproot3_pr326 +scikit-hep_uproot3_pr337 +scikit-hep_uproot3_pr343 +scikit-hep_uproot3_pr353 +scikit-hep_uproot3_pr379 +scikit-hep_uproot3_pr385 +scikit-hep_uproot3_pr400 +scikit-hep_uproot3_pr417 +scikit-hep_uproot3_pr420 +scikit-hep_uproot3_pr427 +scikit-hep_uproot3_pr430 +scikit-hep_uproot3_pr439 +scikit-hep_uproot3_pr442 +scikit-hep_uproot3_pr446 +scikit-hep_uproot3_pr449 +scikit-hep_uproot3_pr459 +scikit-hep_uproot3_pr477 +scikit-hep_uproot3_pr514 +scikit-hep_uproot3_pr518 +scikit-hep_uproot3_pr53 +scikit-hep_uproot3_pr6 +scikit-hep_uproot3_pr94 +scikit-learn-contrib_forest-confidence-interval_pr113 +scikit-rf_scikit-rf_pr1023 +scikit-rf_scikit-rf_pr1028 +scikit-rf_scikit-rf_pr1030 +scikit-rf_scikit-rf_pr1033 +scikit-rf_scikit-rf_pr1040 +scikit-rf_scikit-rf_pr1042 +scikit-rf_scikit-rf_pr1044 +scikit-rf_scikit-rf_pr1045 +scikit-rf_scikit-rf_pr1069 +scikit-rf_scikit-rf_pr1070 +scikit-rf_scikit-rf_pr1073 +scikit-rf_scikit-rf_pr1077 +scikit-rf_scikit-rf_pr1080 +scikit-rf_scikit-rf_pr1082 +scikit-rf_scikit-rf_pr1085 +scikit-rf_scikit-rf_pr1089 +scikit-rf_scikit-rf_pr1092 +scikit-rf_scikit-rf_pr1095 +scikit-rf_scikit-rf_pr1096 +scikit-rf_scikit-rf_pr1104 +scikit-rf_scikit-rf_pr1107 +scikit-rf_scikit-rf_pr1108 +scikit-rf_scikit-rf_pr1117 +scikit-rf_scikit-rf_pr1118 +scikit-rf_scikit-rf_pr1120 +scikit-rf_scikit-rf_pr1122 +scikit-rf_scikit-rf_pr1124 +scikit-rf_scikit-rf_pr1133 +scikit-rf_scikit-rf_pr1135 +scikit-rf_scikit-rf_pr1137 +scikit-rf_scikit-rf_pr1138 +scikit-rf_scikit-rf_pr1144 +scikit-rf_scikit-rf_pr1145 +scikit-rf_scikit-rf_pr1149 +scikit-rf_scikit-rf_pr1150 +scikit-rf_scikit-rf_pr1151 +scikit-rf_scikit-rf_pr1153 +scikit-rf_scikit-rf_pr1158 +scikit-rf_scikit-rf_pr1160 +scikit-rf_scikit-rf_pr1162 +scikit-rf_scikit-rf_pr1166 +scikit-rf_scikit-rf_pr1168 +scikit-rf_scikit-rf_pr1170 +scikit-rf_scikit-rf_pr1175 +scikit-rf_scikit-rf_pr1176 +scikit-rf_scikit-rf_pr1181 +scikit-rf_scikit-rf_pr1183 +scikit-rf_scikit-rf_pr1192 +scikit-rf_scikit-rf_pr1195 +scikit-rf_scikit-rf_pr1200 +scikit-rf_scikit-rf_pr1202 +scikit-rf_scikit-rf_pr1203 +scikit-rf_scikit-rf_pr1206 +scikit-rf_scikit-rf_pr1207 +scikit-rf_scikit-rf_pr1212 +scikit-rf_scikit-rf_pr1219 +scikit-rf_scikit-rf_pr1220 +scikit-rf_scikit-rf_pr1223 +scikit-rf_scikit-rf_pr1227 +scikit-rf_scikit-rf_pr1228 +scikit-rf_scikit-rf_pr1233 +scikit-rf_scikit-rf_pr1235 +scikit-rf_scikit-rf_pr1238 +scikit-rf_scikit-rf_pr1242 +scikit-rf_scikit-rf_pr1246 +scikit-rf_scikit-rf_pr1257 +scikit-rf_scikit-rf_pr1258 +scikit-rf_scikit-rf_pr1261 +scikit-rf_scikit-rf_pr1282 +scikit-rf_scikit-rf_pr1304 +scikit-rf_scikit-rf_pr1320 +scikit-rf_scikit-rf_pr1330 +scikit-rf_scikit-rf_pr1332 +scikit-rf_scikit-rf_pr1336 +scikit-rf_scikit-rf_pr1340 +scikit-rf_scikit-rf_pr561 +scikit-rf_scikit-rf_pr563 +scikit-rf_scikit-rf_pr564 +scikit-rf_scikit-rf_pr571 +scikit-rf_scikit-rf_pr578 +scikit-rf_scikit-rf_pr585 +scikit-rf_scikit-rf_pr587 +scikit-rf_scikit-rf_pr588 +scikit-rf_scikit-rf_pr589 +scikit-rf_scikit-rf_pr591 +scikit-rf_scikit-rf_pr595 +scikit-rf_scikit-rf_pr602 +scikit-rf_scikit-rf_pr619 +scikit-rf_scikit-rf_pr625 +scikit-rf_scikit-rf_pr632 +scikit-rf_scikit-rf_pr635 +scikit-rf_scikit-rf_pr638 +scikit-rf_scikit-rf_pr639 +scikit-rf_scikit-rf_pr649 +scikit-rf_scikit-rf_pr655 +scikit-rf_scikit-rf_pr657 +scikit-rf_scikit-rf_pr658 +scikit-rf_scikit-rf_pr661 +scikit-rf_scikit-rf_pr664 +scikit-rf_scikit-rf_pr665 +scikit-rf_scikit-rf_pr666 +scikit-rf_scikit-rf_pr669 +scikit-rf_scikit-rf_pr671 +scikit-rf_scikit-rf_pr672 +scikit-rf_scikit-rf_pr676 +scikit-rf_scikit-rf_pr678 +scikit-rf_scikit-rf_pr682 +scikit-rf_scikit-rf_pr705 +scikit-rf_scikit-rf_pr714 +scikit-rf_scikit-rf_pr720 +scikit-rf_scikit-rf_pr725 +scikit-rf_scikit-rf_pr729 +scikit-rf_scikit-rf_pr732 +scikit-rf_scikit-rf_pr738 +scikit-rf_scikit-rf_pr746 +scikit-rf_scikit-rf_pr747 +scikit-rf_scikit-rf_pr760 +scikit-rf_scikit-rf_pr761 +scikit-rf_scikit-rf_pr765 +scikit-rf_scikit-rf_pr768 +scitokens_scitokens_pr36 +scitokens_scitokens_pr50 +sciunto-org_python-bibtexparser_pr20 +sciunto-org_python-bibtexparser_pr28 +sciunto-org_python-bibtexparser_pr29 +sciunto-org_python-bibtexparser_pr290 +sciunto-org_python-bibtexparser_pr299 +sciunto-org_python-bibtexparser_pr30 +sciunto-org_python-bibtexparser_pr312 +sciunto-org_python-bibtexparser_pr317 +sciunto-org_python-bibtexparser_pr32 +sciunto-org_python-bibtexparser_pr33 +sciunto-org_python-bibtexparser_pr334 +sciunto-org_python-bibtexparser_pr34 +sciunto-org_python-bibtexparser_pr348 +sciunto-org_python-bibtexparser_pr377 +sciunto-org_python-bibtexparser_pr381 +sciunto-org_python-bibtexparser_pr382 +sciunto-org_python-bibtexparser_pr385 +sciunto-org_python-bibtexparser_pr387 +sciunto-org_python-bibtexparser_pr398 +sciunto-org_python-bibtexparser_pr416 +sciunto-org_python-bibtexparser_pr422 +sciunto-org_python-bibtexparser_pr423 +sciunto-org_python-bibtexparser_pr424 +sciunto-org_python-bibtexparser_pr442 +sciunto-org_python-bibtexparser_pr443 +sciunto-org_python-bibtexparser_pr444 +sciunto-org_python-bibtexparser_pr466 +sciunto-org_python-bibtexparser_pr476 +sciunto-org_python-bibtexparser_pr49 +sciunto-org_python-bibtexparser_pr53 +sciunto-org_python-bibtexparser_pr7 +sciunto-org_python-bibtexparser_pr73 +sciunto-org_python-bibtexparser_pr77 +sciunto-org_python-bibtexparser_pr79 +sciunto-org_python-bibtexparser_pr83 +sciunto-org_python-bibtexparser_pr91 +sco1_flake8-annotations_pr104 +sco1_flake8-annotations_pr136 +sco1_flake8-annotations_pr165 +sco1_flake8-annotations_pr73 +sco1_flake8-annotations_pr83 +sco1_flake8-annotations_pr91 +scott-griffiths_bitstring_pr244 +scott-griffiths_bitstring_pr271 +scott-griffiths_bitstring_pr275 +scott-griffiths_bitstring_pr287 +scottwernervt_favicon_pr28 +scour-project_scour_pr255 +scour-project_scour_pr264 +scour-project_scour_pr268 +scrapinghub_andi_pr14 +scrapinghub_andi_pr19 +scrapinghub_andi_pr3 +scrapinghub_number-parser_pr19 +scrapinghub_number-parser_pr23 +scrapinghub_number-parser_pr38 +scrapinghub_number-parser_pr47 +scrapinghub_number-parser_pr49 +scrapinghub_number-parser_pr50 +scrapinghub_price-parser_pr42 +scrapinghub_price-parser_pr43 +scrapinghub_price-parser_pr59 +scrapinghub_price-parser_pr66 +scrapinghub_web-poet_pr101 +scrapinghub_web-poet_pr191 +scrapinghub_web-poet_pr205 +scrapinghub_web-poet_pr213 +scrapinghub_web-poet_pr223 +scrapinghub_web-poet_pr230 +scrapinghub_web-poet_pr232 +scrapinghub_web-poet_pr238 +scrapinghub_web-poet_pr240 +scrapinghub_web-poet_pr30 +scrapinghub_web-poet_pr33 +scrapinghub_web-poet_pr38 +scrapinghub_web-poet_pr52 +scrapinghub_web-poet_pr62 +scrapinghub_web-poet_pr81 +scrapinghub_web-poet_pr85 +scrapinghub_web-poet_pr96 +scrapy_itemadapter_pr101 +scrapy_itemadapter_pr18 +scrapy_itemadapter_pr29 +scrapy_itemadapter_pr31 +scrapy_itemadapter_pr44 +scrapy_itemadapter_pr54 +scrapy_itemadapter_pr56 +scrapy_itemadapter_pr57 +scrapy_itemadapter_pr60 +scrapy_itemadapter_pr61 +scrapy_itemadapter_pr64 +scrapy_itemadapter_pr69 +scrapy_itemadapter_pr74 +scrapy_itemadapter_pr79 +scrapy_itemloaders_pr51 +scrapy_itemloaders_pr57 +scrapy_itemloaders_pr68 +scrapy_itemloaders_pr70 +scrapy_itemloaders_pr80 +scrapy_itemloaders_pr81 +scrapy_itemloaders_pr88 +scrapy_itemloaders_pr94 +scrapy_protego_pr25 +scrapy_protego_pr34 +scrapy_queuelib_pr40 +scrapy_queuelib_pr8 +scrapy_w3lib_pr118 +scrapy_w3lib_pr119 +scrapy_w3lib_pr126 +scrapy_w3lib_pr127 +scrapy_w3lib_pr136 +scrapy_w3lib_pr141 +scrapy_w3lib_pr148 +scrapy_w3lib_pr169 +scrapy_w3lib_pr170 +scrapy_w3lib_pr174 +scrapy_w3lib_pr175 +scrapy_w3lib_pr179 +scrapy_w3lib_pr191 +scrapy_w3lib_pr196 +scrapy_w3lib_pr202 +scrapy_w3lib_pr203 +scrapy_w3lib_pr207 +scrapy_w3lib_pr22 +scrapy_w3lib_pr23 +scrapy_w3lib_pr230 +scrapy_w3lib_pr243 +scrapy_w3lib_pr26 +scrapy_w3lib_pr29 +scrapy_w3lib_pr30 +scrapy_w3lib_pr33 +scrapy_w3lib_pr37 +scrapy_w3lib_pr38 +scrapy_w3lib_pr39 +scrapy_w3lib_pr40 +scrapy_w3lib_pr45 +scrapy_w3lib_pr48 +scrapy_w3lib_pr77 +scverse_mudata_pr7 +secynic_ipwhois_pr145 +secynic_ipwhois_pr15 +secynic_ipwhois_pr30 +seequent_properties_pr183 +seequent_properties_pr238 +seequent_properties_pr246 +seequent_properties_pr256 +seequent_properties_pr263 +seequent_properties_pr278 +seequent_properties_pr287 +seequent_properties_pr290 +semuconsulting_pynmeagps_pr24 +semuconsulting_pynmeagps_pr26 +semuconsulting_pynmeagps_pr39 +semuconsulting_pynmeagps_pr62 +semuconsulting_pynmeagps_pr78 +semuconsulting_pynmeagps_pr84 +semuconsulting_pynmeagps_pr9 +semuconsulting_pyrtcm_pr16 +semuconsulting_pyubx2_pr176 +semuconsulting_pyubx2_pr24 +semuconsulting_pyubx2_pr26 +semuconsulting_pyubx2_pr70 +semuconsulting_pyubx2_pr77 +sendgrid_python-http-client_pr123 +sendgrid_python-http-client_pr145 +sendgrid_python-http-client_pr19 +sendgrid_sendgrid-python_pr137 +serge-sans-paille_beniget_pr100 +serge-sans-paille_beniget_pr114 +serge-sans-paille_beniget_pr121 +serge-sans-paille_beniget_pr68 +serge-sans-paille_beniget_pr69 +serge-sans-paille_beniget_pr70 +serge-sans-paille_beniget_pr73 +serge-sans-paille_beniget_pr75 +serge-sans-paille_beniget_pr77 +serge-sans-paille_beniget_pr78 +serge-sans-paille_beniget_pr80 +serge-sans-paille_beniget_pr87 +serge-sans-paille_beniget_pr96 +serge-sans-paille_beniget_pr97 +serge-sans-paille_beniget_pr99 +serge-sans-paille_gast_pr62 +serge-sans-paille_gast_pr65 +serge-sans-paille_gast_pr67 +serge-sans-paille_gast_pr72 +serge-sans-paille_gast_pr80 +serge-sans-paille_gast_pr89 +serge-sans-paille_gast_pr96 +serhatbolsu_robotframework-appiumlibrary_pr329 +serhatbolsu_robotframework-appiumlibrary_pr354 +serhatbolsu_robotframework-appiumlibrary_pr356 +sethmlarson_socksio_pr12 +sethmlarson_socksio_pr46 +sethmlarson_truststore_pr100 +sethmlarson_truststore_pr113 +sethmlarson_truststore_pr120 +sethmlarson_truststore_pr132 +sethmlarson_truststore_pr149 +sethmlarson_truststore_pr152 +sethmlarson_truststore_pr157 +sethmlarson_truststore_pr164 +sethmlarson_truststore_pr83 +severb_graypy_pr52 +severb_graypy_pr66 +severb_graypy_pr87 +severb_graypy_pr89 +shinichi-takii_ddlparse_pr47 +shinichi-takii_ddlparse_pr49 +shinichi-takii_ddlparse_pr62 +shiphero_skippy-cov_pr14 +shiphero_skippy-cov_pr6 +si-23_py-import-cycles_pr13 +si-23_py-import-cycles_pr16 +si-23_py-import-cycles_pr18 +si-23_py-import-cycles_pr19 +si-23_py-import-cycles_pr29 +si-23_py-import-cycles_pr30 +si-23_py-import-cycles_pr36 +si-23_py-import-cycles_pr38 +si-23_py-import-cycles_pr41 +si-23_py-import-cycles_pr44 +si-23_py-import-cycles_pr48 +si-23_py-import-cycles_pr50 +si-23_py-import-cycles_pr52 +si-23_py-import-cycles_pr55 +si-23_py-import-cycles_pr60 +si-23_py-import-cycles_pr63 +si-23_py-import-cycles_pr69 +sifive_pydevicetree_pr14 +sifive_pydevicetree_pr20 +sifive_pydevicetree_pr22 +sifive_pydevicetree_pr26 +sifive_pydevicetree_pr31 +sifive_pydevicetree_pr34 +sigma-py_npx_pr11 +sigma-py_npx_pr20 +sigma-py_npx_pr23 +sigma-py_npx_pr29 +sigma-py_npx_pr3 +sigma-py_npx_pr4 +sigma-py_npx_pr5 +sigma-py_npx_pr6 +sigma-py_npx_pr7 +sigma-py_npx_pr8 +sigma-py_npx_pr9 +sigmavirus24_github3.py_pr1101 +sigmavirus24_github3.py_pr1139 +sigmavirus24_github3.py_pr1142 +sigmavirus24_github3.py_pr1162 +sigmavirus24_github3.py_pr1199 +sigmavirus24_rush_pr2 +siliconcompiler_lambdalib_pr102 +siliconcompiler_lambdalib_pr57 +siliconcompiler_lambdalib_pr60 +siliconcompiler_lambdalib_pr63 +siliconcompiler_lambdalib_pr73 +siliconcompiler_lambdalib_pr83 +siliconcompiler_lambdalib_pr87 +siliconcompiler_lambdalib_pr98 +siliconcompiler_lambdapdk_pr102 +siliconcompiler_lambdapdk_pr105 +siliconcompiler_lambdapdk_pr108 +siliconcompiler_lambdapdk_pr114 +siliconcompiler_lambdapdk_pr117 +siliconcompiler_lambdapdk_pr122 +siliconcompiler_lambdapdk_pr123 +siliconcompiler_lambdapdk_pr152 +siliconcompiler_lambdapdk_pr155 +siliconcompiler_lambdapdk_pr190 +siliconcompiler_lambdapdk_pr192 +siliconcompiler_lambdapdk_pr71 +siliconcompiler_lambdapdk_pr78 +siliconcompiler_lambdapdk_pr79 +siliconcompiler_lambdapdk_pr94 +simonw_asgi-csrf_pr5 +singingwolfboy_flask-dance_pr121 +singingwolfboy_flask-dance_pr153 +singingwolfboy_flask-dance_pr161 +singingwolfboy_flask-dance_pr162 +singingwolfboy_flask-dance_pr166 +singingwolfboy_flask-dance_pr170 +singingwolfboy_flask-dance_pr185 +singingwolfboy_flask-dance_pr200 +singingwolfboy_flask-dance_pr209 +singingwolfboy_flask-dance_pr227 +singingwolfboy_flask-dance_pr259 +singingwolfboy_flask-dance_pr266 +singingwolfboy_flask-dance_pr288 +singingwolfboy_flask-dance_pr310 +singingwolfboy_flask-dance_pr327 +singingwolfboy_flask-dance_pr330 +singingwolfboy_flask-dance_pr331 +singingwolfboy_flask-dance_pr334 +singingwolfboy_flask-dance_pr339 +singingwolfboy_flask-dance_pr340 +singingwolfboy_flask-dance_pr345 +singingwolfboy_flask-dance_pr346 +singingwolfboy_flask-dance_pr350 +singingwolfboy_flask-dance_pr353 +singingwolfboy_flask-dance_pr356 +singingwolfboy_flask-dance_pr360 +singingwolfboy_flask-dance_pr361 +singingwolfboy_flask-dance_pr398 +singingwolfboy_flask-dance_pr403 +singingwolfboy_flask-dance_pr406 +singingwolfboy_flask-dance_pr433 +sissaschool_elementpath_pr2 +sissaschool_elementpath_pr20 +sissaschool_elementpath_pr21 +sissaschool_elementpath_pr22 +sissaschool_elementpath_pr26 +sissaschool_elementpath_pr43 +sissaschool_elementpath_pr86 +sissaschool_xmlschema_pr118 +sissaschool_xmlschema_pr194 +sissaschool_xmlschema_pr288 +sissaschool_xmlschema_pr295 +sissaschool_xmlschema_pr297 +sklarsa_django-sendgrid-v5_pr101 +sklarsa_django-sendgrid-v5_pr103 +sklarsa_django-sendgrid-v5_pr121 +sklarsa_django-sendgrid-v5_pr16 +sklarsa_django-sendgrid-v5_pr24 +sklarsa_django-sendgrid-v5_pr27 +sklarsa_django-sendgrid-v5_pr49 +sklarsa_django-sendgrid-v5_pr50 +sklearn-compat_sklearn-compat_pr21 +sklearn-compat_sklearn-compat_pr25 +sktime_skbase_pr111 +sktime_skbase_pr117 +sktime_skbase_pr126 +sktime_skbase_pr13 +sktime_skbase_pr130 +sktime_skbase_pr136 +sktime_skbase_pr137 +sktime_skbase_pr138 +sktime_skbase_pr140 +sktime_skbase_pr155 +sktime_skbase_pr156 +sktime_skbase_pr16 +sktime_skbase_pr161 +sktime_skbase_pr167 +sktime_skbase_pr171 +sktime_skbase_pr179 +sktime_skbase_pr183 +sktime_skbase_pr191 +sktime_skbase_pr195 +sktime_skbase_pr206 +sktime_skbase_pr229 +sktime_skbase_pr237 +sktime_skbase_pr238 +sktime_skbase_pr243 +sktime_skbase_pr246 +sktime_skbase_pr257 +sktime_skbase_pr259 +sktime_skbase_pr263 +sktime_skbase_pr268 +sktime_skbase_pr273 +sktime_skbase_pr285 +sktime_skbase_pr286 +sktime_skbase_pr303 +sktime_skbase_pr310 +sktime_skbase_pr314 +sktime_skbase_pr328 +sktime_skbase_pr329 +sktime_skbase_pr331 +sktime_skbase_pr335 +sktime_skbase_pr338 +sktime_skbase_pr345 +sktime_skbase_pr350 +sktime_skbase_pr353 +sktime_skbase_pr355 +sktime_skbase_pr37 +sktime_skbase_pr370 +sktime_skbase_pr389 +sktime_skbase_pr414 +sktime_skbase_pr417 +sktime_skbase_pr418 +sktime_skbase_pr427 +sktime_skbase_pr441 +sktime_skbase_pr454 +sktime_skbase_pr457 +sktime_skbase_pr464 +sktime_skbase_pr467 +sktime_skbase_pr62 +sktime_skbase_pr69 +sktime_skbase_pr79 +sktime_skbase_pr80 +sktime_skbase_pr86 +sktime_skbase_pr87 +sktime_skbase_pr88 +sktime_skbase_pr96 +sktime_skpro_pr151 +sktime_skpro_pr388 +slackapi_python-slack-events-api_pr71 +slackapi_python-slack-events-api_pr91 +slackapi_python-slack-sdk_pr100 +slackapi_python-slack-sdk_pr106 +slackapi_python-slack-sdk_pr119 +slackapi_python-slack-sdk_pr152 +slackapi_python-slack-sdk_pr160 +slackapi_python-slack-sdk_pr161 +slackapi_python-slack-sdk_pr162 +slackapi_python-slack-sdk_pr167 +slackapi_python-slack-sdk_pr173 +slackapi_python-slack-sdk_pr210 +slackapi_python-slack-sdk_pr215 +slackapi_python-slack-sdk_pr247 +slackapi_python-slack-sdk_pr30 +slackapi_python-slack-sdk_pr74 +slackapi_python-slack-sdk_pr97 +slank_awsgi_pr27 +smtg-ucl_sumo_pr212 +snok_django-guid_pr21 +snok_django-guid_pr31 +snok_django-guid_pr38 +snok_flake8-type-checking_pr103 +snok_flake8-type-checking_pr104 +snok_flake8-type-checking_pr107 +snok_flake8-type-checking_pr109 +snok_flake8-type-checking_pr112 +snok_flake8-type-checking_pr118 +snok_flake8-type-checking_pr122 +snok_flake8-type-checking_pr123 +snok_flake8-type-checking_pr124 +snok_flake8-type-checking_pr125 +snok_flake8-type-checking_pr126 +snok_flake8-type-checking_pr133 +snok_flake8-type-checking_pr138 +snok_flake8-type-checking_pr140 +snok_flake8-type-checking_pr142 +snok_flake8-type-checking_pr145 +snok_flake8-type-checking_pr15 +snok_flake8-type-checking_pr155 +snok_flake8-type-checking_pr157 +snok_flake8-type-checking_pr16 +snok_flake8-type-checking_pr161 +snok_flake8-type-checking_pr165 +snok_flake8-type-checking_pr166 +snok_flake8-type-checking_pr167 +snok_flake8-type-checking_pr17 +snok_flake8-type-checking_pr173 +snok_flake8-type-checking_pr174 +snok_flake8-type-checking_pr176 +snok_flake8-type-checking_pr183 +snok_flake8-type-checking_pr184 +snok_flake8-type-checking_pr187 +snok_flake8-type-checking_pr193 +snok_flake8-type-checking_pr195 +snok_flake8-type-checking_pr198 +snok_flake8-type-checking_pr199 +snok_flake8-type-checking_pr200 +snok_flake8-type-checking_pr4 +snok_flake8-type-checking_pr5 +snok_flake8-type-checking_pr66 +snok_flake8-type-checking_pr67 +snok_flake8-type-checking_pr78 +snok_flake8-type-checking_pr80 +snok_flake8-type-checking_pr87 +snok_flake8-type-checking_pr88 +snowflakedb_snowflake-cli_pr195 +snowflakedb_snowflake-cli_pr204 +snowflakedb_snowflake-cli_pr206 +snowflakedb_snowflake-cli_pr209 +snowflakedb_snowflake-cli_pr237 +snowflakedb_snowflake-cli_pr289 +snowflakedb_snowflake-cli_pr545 +snowflakedb_snowflake-cli_pr581 +snowflakedb_snowflake-cli_pr606 +snowflakedb_snowflake-cli_pr607 +snowflakedb_snowflake-cli_pr703 +snowflakedb_snowflake-cli_pr705 +snowflakedb_snowflake-cli_pr720 +snowflakedb_snowflake-cli_pr725 +snowflakedb_snowflake-ingest-python_pr8 +snowflakedb_snowflake-telemetry-python_pr31 +snowplow_snowplow-python-tracker_pr349 +snyk-labs_pysnyk_pr26 +sobolevn_django-split-settings_pr174 +socialwifi_jsonapi-requests_pr11 +socialwifi_jsonapi-requests_pr14 +spacetelescope_pysiaf_pr177 +spacetelescope_pysiaf_pr231 +spacetelescope_pysiaf_pr277 +spacetelescope_pysiaf_pr293 +spacetelescope_pysiaf_pr294 +spacetelescope_pysiaf_pr296 +spacetelescope_pysiaf_pr318 +spacetelescope_pysiaf_pr331 +spacetelescope_tweakwcs_pr136 +spacetelescope_tweakwcs_pr139 +spacetelescope_tweakwcs_pr143 +spacetelescope_tweakwcs_pr144 +spacetelescope_tweakwcs_pr147 +spacetelescope_tweakwcs_pr154 +spatial-image_spatial-image_pr6 +spdx_tools-python_pr107 +spdx_tools-python_pr173 +spdx_tools-python_pr187 +spdx_tools-python_pr188 +spdx_tools-python_pr195 +spdx_tools-python_pr236 +spdx_tools-python_pr245 +spdx_tools-python_pr254 +spdx_tools-python_pr266 +spdx_tools-python_pr276 +spdx_tools-python_pr279 +spdx_tools-python_pr283 +spdx_tools-python_pr286 +spdx_tools-python_pr292 +spdx_tools-python_pr303 +spdx_tools-python_pr308 +spdx_tools-python_pr311 +spdx_tools-python_pr318 +spdx_tools-python_pr329 +spdx_tools-python_pr331 +spdx_tools-python_pr334 +spdx_tools-python_pr343 +spdx_tools-python_pr352 +spdx_tools-python_pr450 +spdx_tools-python_pr452 +spdx_tools-python_pr480 +spdx_tools-python_pr499 +spdx_tools-python_pr520 +spdx_tools-python_pr62 +spdx_tools-python_pr695 +spdx_tools-python_pr697 +spdx_tools-python_pr698 +spdx_tools-python_pr699 +spdx_tools-python_pr71 +spdx_tools-python_pr719 +spdx_tools-python_pr724 +spdx_tools-python_pr728 +spdx_tools-python_pr73 +spdx_tools-python_pr733 +spdx_tools-python_pr74 +spdx_tools-python_pr78 +spdx_tools-python_pr855 +sphinx-contrib_confluencebuilder_pr1002 +sphinx-contrib_confluencebuilder_pr1006 +sphinx-contrib_confluencebuilder_pr1007 +sphinx-contrib_confluencebuilder_pr1010 +sphinx-contrib_confluencebuilder_pr1033 +sphinx-contrib_confluencebuilder_pr1034 +sphinx-contrib_confluencebuilder_pr1044 +sphinx-contrib_confluencebuilder_pr1047 +sphinx-contrib_confluencebuilder_pr1049 +sphinx-contrib_confluencebuilder_pr1055 +sphinx-contrib_confluencebuilder_pr1060 +sphinx-contrib_confluencebuilder_pr1066 +sphinx-contrib_confluencebuilder_pr1084 +sphinx-contrib_confluencebuilder_pr1093 +sphinx-contrib_confluencebuilder_pr1099 +sphinx-contrib_confluencebuilder_pr1113 +sphinx-contrib_confluencebuilder_pr1114 +sphinx-contrib_confluencebuilder_pr1117 +sphinx-contrib_confluencebuilder_pr1125 +sphinx-contrib_confluencebuilder_pr1128 +sphinx-contrib_confluencebuilder_pr1134 +sphinx-contrib_confluencebuilder_pr1136 +sphinx-contrib_confluencebuilder_pr1140 +sphinx-contrib_confluencebuilder_pr1142 +sphinx-contrib_confluencebuilder_pr58 +sphinx-contrib_confluencebuilder_pr677 +sphinx-contrib_confluencebuilder_pr737 +sphinx-contrib_confluencebuilder_pr741 +sphinx-contrib_confluencebuilder_pr749 +sphinx-contrib_confluencebuilder_pr752 +sphinx-contrib_confluencebuilder_pr756 +sphinx-contrib_confluencebuilder_pr768 +sphinx-contrib_confluencebuilder_pr769 +sphinx-contrib_confluencebuilder_pr774 +sphinx-contrib_confluencebuilder_pr780 +sphinx-contrib_confluencebuilder_pr784 +sphinx-contrib_confluencebuilder_pr785 +sphinx-contrib_confluencebuilder_pr793 +sphinx-contrib_confluencebuilder_pr795 +sphinx-contrib_confluencebuilder_pr796 +sphinx-contrib_confluencebuilder_pr811 +sphinx-contrib_confluencebuilder_pr816 +sphinx-contrib_confluencebuilder_pr818 +sphinx-contrib_confluencebuilder_pr824 +sphinx-contrib_confluencebuilder_pr833 +sphinx-contrib_confluencebuilder_pr838 +sphinx-contrib_confluencebuilder_pr841 +sphinx-contrib_confluencebuilder_pr855 +sphinx-contrib_confluencebuilder_pr859 +sphinx-contrib_confluencebuilder_pr889 +sphinx-contrib_confluencebuilder_pr895 +sphinx-contrib_confluencebuilder_pr898 +sphinx-contrib_confluencebuilder_pr899 +sphinx-contrib_confluencebuilder_pr900 +sphinx-contrib_confluencebuilder_pr906 +sphinx-contrib_confluencebuilder_pr907 +sphinx-contrib_confluencebuilder_pr910 +sphinx-contrib_confluencebuilder_pr919 +sphinx-contrib_confluencebuilder_pr922 +sphinx-contrib_confluencebuilder_pr938 +sphinx-contrib_confluencebuilder_pr950 +sphinx-contrib_confluencebuilder_pr979 +sphinx-contrib_confluencebuilder_pr984 +sphinx-contrib_confluencebuilder_pr989 +sphinx-contrib_confluencebuilder_pr993 +sphinx-contrib_confluencebuilder_pr994 +sphinx-contrib_confluencebuilder_pr998 +sphinx-contrib_confluencebuilder_pr999 +sphinx-contrib_openapi_pr50 +sphinx-contrib_openapi_pr74 +sphinx-contrib_openapi_pr87 +sphinx-contrib_openapi_pr95 +sphinx-contrib_openapi_pr98 +sphinx-contrib_sphinxcontrib-towncrier_pr86 +sphinx-doc_sphinx-argparse_pr49 +sphinx-doc_sphinx-autobuild_pr192 +sphinx-gallery_sphinx-gallery_pr1115 +sphinx-gallery_sphinx-gallery_pr1122 +sphinx-gallery_sphinx-gallery_pr890 +sphinx-gallery_sphinx-gallery_pr922 +sphinx-gallery_sphinx-gallery_pr944 +sphinx-gallery_sphinx-gallery_pr961 +sphinx-gallery_sphinx-gallery_pr986 +sphinx-gallery_sphinx-gallery_pr993 +splitio_python-client_pr104 +splitio_python-client_pr110 +splitio_python-client_pr112 +splitio_python-client_pr117 +splitio_python-client_pr127 +splitio_python-client_pr143 +splitio_python-client_pr153 +splitio_python-client_pr174 +splitio_python-client_pr41 +splitio_python-client_pr44 +splitio_python-client_pr46 +splitio_python-client_pr55 +splitio_python-client_pr83 +splitio_python-client_pr97 +spulec_freezegun_pr105 +spulec_freezegun_pr108 +spulec_freezegun_pr109 +spulec_freezegun_pr115 +spulec_freezegun_pr119 +spulec_freezegun_pr144 +spulec_freezegun_pr145 +spulec_freezegun_pr149 +spulec_freezegun_pr161 +spulec_freezegun_pr163 +spulec_freezegun_pr17 +spulec_freezegun_pr231 +spulec_freezegun_pr232 +spulec_freezegun_pr233 +spulec_freezegun_pr24 +spulec_freezegun_pr25 +spulec_freezegun_pr28 +spulec_freezegun_pr297 +spulec_freezegun_pr305 +spulec_freezegun_pr316 +spulec_freezegun_pr328 +spulec_freezegun_pr329 +spulec_freezegun_pr357 +spulec_freezegun_pr363 +spulec_freezegun_pr369 +spulec_freezegun_pr370 +spulec_freezegun_pr395 +spulec_freezegun_pr42 +spulec_freezegun_pr429 +spulec_freezegun_pr475 +spulec_freezegun_pr49 +spulec_freezegun_pr52 +spulec_freezegun_pr525 +spulec_freezegun_pr53 +spulec_freezegun_pr530 +spulec_freezegun_pr533 +spulec_freezegun_pr538 +spulec_freezegun_pr539 +spulec_freezegun_pr540 +spulec_freezegun_pr542 +spulec_freezegun_pr543 +spulec_freezegun_pr546 +spulec_freezegun_pr574 +spulec_freezegun_pr576 +spulec_freezegun_pr582 +spulec_freezegun_pr583 +spulec_freezegun_pr72 +spulec_freezegun_pr74 +spulec_freezegun_pr78 +spulec_freezegun_pr83 +spulec_freezegun_pr86 +spulec_freezegun_pr88 +spyoungtech_json-five_pr19 +spyoungtech_json-five_pr2 +spyoungtech_json-five_pr45 +stac-utils_stac-pydantic_pr100 +stac-utils_stac-pydantic_pr102 +stac-utils_stac-pydantic_pr103 +stac-utils_stac-pydantic_pr108 +stac-utils_stac-pydantic_pr11 +stac-utils_stac-pydantic_pr114 +stac-utils_stac-pydantic_pr131 +stac-utils_stac-pydantic_pr133 +stac-utils_stac-pydantic_pr138 +stac-utils_stac-pydantic_pr149 +stac-utils_stac-pydantic_pr156 +stac-utils_stac-pydantic_pr161 +stac-utils_stac-pydantic_pr165 +stac-utils_stac-pydantic_pr172 +stac-utils_stac-pydantic_pr177 +stac-utils_stac-pydantic_pr178 +stac-utils_stac-pydantic_pr180 +stac-utils_stac-pydantic_pr182 +stac-utils_stac-pydantic_pr35 +stac-utils_stac-pydantic_pr43 +stac-utils_stac-pydantic_pr47 +stac-utils_stac-pydantic_pr52 +stac-utils_stac-pydantic_pr69 +stac-utils_stac-pydantic_pr70 +stac-utils_stac-pydantic_pr75 +stac-utils_stac-pydantic_pr81 +stac-utils_stac-pydantic_pr90 +stanford-crfm_haliax_pr11 +stanford-crfm_haliax_pr117 +stanford-crfm_haliax_pr123 +stanford-crfm_haliax_pr125 +stanford-crfm_haliax_pr127 +stanford-crfm_haliax_pr128 +stanford-crfm_haliax_pr130 +stanford-crfm_haliax_pr133 +stanford-crfm_haliax_pr134 +stanford-crfm_haliax_pr135 +stanford-crfm_haliax_pr14 +stanford-crfm_haliax_pr140 +stanford-crfm_haliax_pr142 +stanford-crfm_haliax_pr147 +stanford-crfm_haliax_pr15 +stanford-crfm_haliax_pr157 +stanford-crfm_haliax_pr168 +stanford-crfm_haliax_pr169 +stanford-crfm_haliax_pr170 +stanford-crfm_haliax_pr176 +stanford-crfm_haliax_pr180 +stanford-crfm_haliax_pr184 +stanford-crfm_haliax_pr190 +stanford-crfm_haliax_pr193 +stanford-crfm_haliax_pr194 +stanford-crfm_haliax_pr195 +stanford-crfm_haliax_pr202 +stanford-crfm_haliax_pr203 +stanford-crfm_haliax_pr206 +stanford-crfm_haliax_pr207 +stanford-crfm_haliax_pr208 +stanford-crfm_haliax_pr209 +stanford-crfm_haliax_pr211 +stanford-crfm_haliax_pr213 +stanford-crfm_haliax_pr214 +stanford-crfm_haliax_pr215 +stanford-crfm_haliax_pr216 +stanford-crfm_haliax_pr218 +stanford-crfm_haliax_pr219 +stanford-crfm_haliax_pr221 +stanford-crfm_haliax_pr224 +stanford-crfm_haliax_pr29 +stanford-crfm_haliax_pr30 +stanford-crfm_haliax_pr33 +stanford-crfm_haliax_pr38 +stanford-crfm_haliax_pr39 +stanford-crfm_haliax_pr40 +stanford-crfm_haliax_pr44 +stanford-crfm_haliax_pr48 +stanford-crfm_haliax_pr49 +stanford-crfm_haliax_pr55 +stanford-crfm_haliax_pr59 +stanford-crfm_haliax_pr61 +stanford-crfm_haliax_pr68 +stanford-crfm_haliax_pr69 +stanford-crfm_haliax_pr71 +stchris_untangle_pr68 +stchris_untangle_pr90 +stefan-jansen_empyrical-reloaded_pr7 +stefan6419846_pip-licenses-cli_pr132 +stephrdev_pytest-isort_pr40 +stphivos_django-mock-queries_pr121 +stphivos_django-mock-queries_pr127 +stphivos_django-mock-queries_pr128 +stphivos_django-mock-queries_pr129 +stphivos_django-mock-queries_pr139 +stphivos_django-mock-queries_pr147 +stphivos_django-mock-queries_pr153 +stphivos_django-mock-queries_pr155 +stphivos_django-mock-queries_pr156 +stphivos_django-mock-queries_pr164 +stphivos_django-mock-queries_pr166 +stphivos_django-mock-queries_pr172 +stphivos_django-mock-queries_pr174 +stphivos_django-mock-queries_pr183 +stphivos_django-mock-queries_pr184 +stphivos_django-mock-queries_pr185 +stphivos_django-mock-queries_pr187 +stravalib_stravalib_pr592 +strawberry-graphql_strawberry-django_pr415 +strawberry-graphql_strawberry-django_pr417 +strawberry-graphql_strawberry-django_pr421 +strawberry-graphql_strawberry-django_pr430 +strawberry-graphql_strawberry-django_pr437 +strawberry-graphql_strawberry-django_pr449 +strawberry-graphql_strawberry-django_pr465 +strawberry-graphql_strawberry-django_pr466 +strawberry-graphql_strawberry-django_pr469 +strawberry-graphql_strawberry-django_pr474 +strawberry-graphql_strawberry-django_pr478 +strawberry-graphql_strawberry-django_pr480 +strawberry-graphql_strawberry-django_pr481 +strawberry-graphql_strawberry-django_pr490 +strawberry-graphql_strawberry-django_pr493 +strawberry-graphql_strawberry-django_pr494 +strawberry-graphql_strawberry-django_pr497 +strawberry-graphql_strawberry-django_pr498 +strawberry-graphql_strawberry-django_pr510 +strawberry-graphql_strawberry-django_pr515 +strawberry-graphql_strawberry-django_pr522 +strawberry-graphql_strawberry-django_pr601 +strawberry-graphql_strawberry-django_pr622 +strawberry-graphql_strawberry-django_pr638 +strawberry-graphql_strawberry-django_pr642 +strawberry-graphql_strawberry-django_pr643 +strawberry-graphql_strawberry-django_pr646 +strawberry-graphql_strawberry-django_pr659 +strawberry-graphql_strawberry-django_pr666 +strawberry-graphql_strawberry-django_pr673 +strawberry-graphql_strawberry-django_pr674 +strawberry-graphql_strawberry-django_pr675 +strawberry-graphql_strawberry-django_pr681 +strawberry-graphql_strawberry-sqlalchemy_pr10 +summernote_django-summernote_pr466 +swagger-api_swagger-codegen_pr2765 +swagger-api_swagger-codegen_pr2796 +swagger-api_swagger-codegen_pr2801 +swagger-api_swagger-codegen_pr2831 +swagger-api_swagger-codegen_pr2861 +swagger-api_swagger-codegen_pr2863 +swagger-api_swagger-codegen_pr2878 +swagger-api_swagger-codegen_pr2899 +swagger-api_swagger-codegen_pr2917 +swagger-api_swagger-codegen_pr2930 +swagger-api_swagger-codegen_pr2979 +swagger-api_swagger-codegen_pr2987 +swagger-api_swagger-codegen_pr2988 +swagger-api_swagger-codegen_pr2989 +swagger-api_swagger-codegen_pr3015 +swagger-api_swagger-codegen_pr3016 +swagger-api_swagger-codegen_pr3034 +swagger-api_swagger-codegen_pr3038 +swagger-api_swagger-codegen_pr3039 +swagger-api_swagger-codegen_pr3075 +swagger-api_swagger-codegen_pr3090 +swagger-api_swagger-codegen_pr3124 +swagger-api_swagger-codegen_pr3126 +swagger-api_swagger-codegen_pr3130 +t3rn0_ast-comments_pr12 +t3rn0_ast-comments_pr25 +t3rn0_ast-comments_pr8 +tartley_colorama_pr260 +tartley_colorama_pr328 +tartley_colorama_pr5 +tbielawa_bitmath_pr21 +tconbeer_sqlfmt_pr111 +tconbeer_sqlfmt_pr112 +tconbeer_sqlfmt_pr125 +tconbeer_sqlfmt_pr126 +tconbeer_sqlfmt_pr127 +tconbeer_sqlfmt_pr13 +tconbeer_sqlfmt_pr14 +tconbeer_sqlfmt_pr143 +tconbeer_sqlfmt_pr146 +tconbeer_sqlfmt_pr148 +tconbeer_sqlfmt_pr15 +tconbeer_sqlfmt_pr16 +tconbeer_sqlfmt_pr160 +tconbeer_sqlfmt_pr166 +tconbeer_sqlfmt_pr17 +tconbeer_sqlfmt_pr173 +tconbeer_sqlfmt_pr181 +tconbeer_sqlfmt_pr185 +tconbeer_sqlfmt_pr194 +tconbeer_sqlfmt_pr2 +tconbeer_sqlfmt_pr21 +tconbeer_sqlfmt_pr210 +tconbeer_sqlfmt_pr216 +tconbeer_sqlfmt_pr22 +tconbeer_sqlfmt_pr221 +tconbeer_sqlfmt_pr223 +tconbeer_sqlfmt_pr226 +tconbeer_sqlfmt_pr228 +tconbeer_sqlfmt_pr23 +tconbeer_sqlfmt_pr233 +tconbeer_sqlfmt_pr238 +tconbeer_sqlfmt_pr24 +tconbeer_sqlfmt_pr25 +tconbeer_sqlfmt_pr3 +tconbeer_sqlfmt_pr4 +tconbeer_sqlfmt_pr43 +tconbeer_sqlfmt_pr46 +tconbeer_sqlfmt_pr47 +tconbeer_sqlfmt_pr49 +tconbeer_sqlfmt_pr6 +tconbeer_sqlfmt_pr667 +tconbeer_sqlfmt_pr668 +tconbeer_sqlfmt_pr7 +tconbeer_sqlfmt_pr703 +tconbeer_sqlfmt_pr711 +tconbeer_sqlfmt_pr8 +tconbeer_sqlfmt_pr9 +team23_pydantic-partial_pr46 +team23_pydantic-partial_pr51 +teamtomo_starfile_pr41 +teamtomo_starfile_pr42 +teamtomo_starfile_pr60 +teamtomo_starfile_pr69 +teamtomo_starfile_pr76 +teamtomo_starfile_pr83 +teamtomo_starfile_pr85 +tedder_requests-aws4auth_pr2 +tefra_xsdata_pr101 +tefra_xsdata_pr107 +tefra_xsdata_pr109 +tefra_xsdata_pr119 +tefra_xsdata_pr123 +tefra_xsdata_pr131 +tefra_xsdata_pr134 +tefra_xsdata_pr140 +tefra_xsdata_pr141 +tefra_xsdata_pr144 +tefra_xsdata_pr146 +tefra_xsdata_pr147 +tefra_xsdata_pr149 +tefra_xsdata_pr152 +tefra_xsdata_pr156 +tefra_xsdata_pr160 +tefra_xsdata_pr161 +tefra_xsdata_pr162 +tefra_xsdata_pr163 +tefra_xsdata_pr167 +tefra_xsdata_pr44 +tefra_xsdata_pr48 +tefra_xsdata_pr53 +tefra_xsdata_pr62 +tefra_xsdata_pr63 +tefra_xsdata_pr65 +tefra_xsdata_pr68 +tefra_xsdata_pr70 +tefra_xsdata_pr78 +tefra_xsdata_pr80 +tefra_xsdata_pr84 +tefra_xsdata_pr86 +tefra_xsdata_pr87 +tefra_xsdata_pr89 +tefra_xsdata_pr90 +tefra_xsdata_pr91 +tefra_xsdata_pr95 +telefonica_toolium_pr100 +telefonica_toolium_pr102 +telefonica_toolium_pr106 +telefonica_toolium_pr114 +telefonica_toolium_pr115 +telefonica_toolium_pr117 +telefonica_toolium_pr124 +telefonica_toolium_pr128 +telefonica_toolium_pr129 +telefonica_toolium_pr136 +telefonica_toolium_pr148 +telefonica_toolium_pr153 +telefonica_toolium_pr156 +telefonica_toolium_pr173 +telefonica_toolium_pr177 +telefonica_toolium_pr179 +telefonica_toolium_pr184 +telefonica_toolium_pr185 +telefonica_toolium_pr186 +telefonica_toolium_pr188 +telefonica_toolium_pr193 +telefonica_toolium_pr194 +telefonica_toolium_pr197 +telefonica_toolium_pr216 +telefonica_toolium_pr217 +telefonica_toolium_pr222 +telefonica_toolium_pr226 +telefonica_toolium_pr227 +telefonica_toolium_pr228 +telefonica_toolium_pr229 +telefonica_toolium_pr231 +telefonica_toolium_pr234 +telefonica_toolium_pr240 +telefonica_toolium_pr241 +telefonica_toolium_pr244 +telefonica_toolium_pr245 +telefonica_toolium_pr246 +telefonica_toolium_pr247 +telefonica_toolium_pr256 +telefonica_toolium_pr257 +telefonica_toolium_pr260 +telefonica_toolium_pr262 +telefonica_toolium_pr263 +telefonica_toolium_pr270 +telefonica_toolium_pr271 +telefonica_toolium_pr275 +telefonica_toolium_pr276 +telefonica_toolium_pr281 +telefonica_toolium_pr283 +telefonica_toolium_pr284 +telefonica_toolium_pr285 +telefonica_toolium_pr289 +telefonica_toolium_pr290 +telefonica_toolium_pr293 +telefonica_toolium_pr294 +telefonica_toolium_pr301 +telefonica_toolium_pr305 +telefonica_toolium_pr321 +telefonica_toolium_pr322 +telefonica_toolium_pr324 +telefonica_toolium_pr327 +telefonica_toolium_pr329 +telefonica_toolium_pr337 +telefonica_toolium_pr338 +telefonica_toolium_pr341 +telefonica_toolium_pr342 +telefonica_toolium_pr343 +telefonica_toolium_pr344 +telefonica_toolium_pr348 +telefonica_toolium_pr353 +telefonica_toolium_pr357 +telefonica_toolium_pr361 +telefonica_toolium_pr368 +telefonica_toolium_pr380 +telefonica_toolium_pr383 +telefonica_toolium_pr394 +telefonica_toolium_pr396 +telefonica_toolium_pr397 +telefonica_toolium_pr403 +telefonica_toolium_pr404 +telefonica_toolium_pr406 +telefonica_toolium_pr41 +telefonica_toolium_pr416 +telefonica_toolium_pr423 +telefonica_toolium_pr424 +telefonica_toolium_pr427 +telefonica_toolium_pr43 +telefonica_toolium_pr433 +telefonica_toolium_pr435 +telefonica_toolium_pr436 +telefonica_toolium_pr437 +telefonica_toolium_pr44 +telefonica_toolium_pr440 +telefonica_toolium_pr441 +telefonica_toolium_pr442 +telefonica_toolium_pr445 +telefonica_toolium_pr448 +telefonica_toolium_pr47 +telefonica_toolium_pr48 +telefonica_toolium_pr49 +telefonica_toolium_pr50 +telefonica_toolium_pr55 +telefonica_toolium_pr56 +telefonica_toolium_pr59 +telefonica_toolium_pr67 +telefonica_toolium_pr68 +telefonica_toolium_pr71 +telefonica_toolium_pr72 +telefonica_toolium_pr73 +telefonica_toolium_pr75 +telefonica_toolium_pr76 +telefonica_toolium_pr77 +telefonica_toolium_pr84 +telefonica_toolium_pr85 +telefonica_toolium_pr86 +telefonica_toolium_pr88 +telefonica_toolium_pr89 +telefonica_toolium_pr91 +telefonica_toolium_pr92 +telefonica_toolium_pr94 +telefonica_toolium_pr95 +telefonica_toolium_pr97 +tfoxy_graphene-django-optimizer_pr56 +thebjorn_pydeps_pr100 +thebjorn_pydeps_pr116 +thebjorn_pydeps_pr131 +thebjorn_pydeps_pr180 +thesimj_envyaml_pr10 +thesimj_envyaml_pr5 +thobbs_pure-sasl_pr19 +thobbs_pure-sasl_pr24 +thobbs_pure-sasl_pr30 +tilezen_mapbox-vector-tile_pr125 +tilezen_mapbox-vector-tile_pr127 +tilezen_mapbox-vector-tile_pr21 +tilezen_mapbox-vector-tile_pr23 +tilezen_mapbox-vector-tile_pr36 +tilezen_mapbox-vector-tile_pr38 +tilezen_mapbox-vector-tile_pr46 +tilezen_mapbox-vector-tile_pr51 +tilezen_mapbox-vector-tile_pr55 +tilezen_mapbox-vector-tile_pr59 +tilezen_mapbox-vector-tile_pr68 +tilezen_mapbox-vector-tile_pr69 +tilezen_mapbox-vector-tile_pr70 +tilezen_mapbox-vector-tile_pr74 +tilezen_mapbox-vector-tile_pr75 +tilezen_mapbox-vector-tile_pr77 +tilezen_mapbox-vector-tile_pr79 +tilezen_mapbox-vector-tile_pr85 +tilezen_mapbox-vector-tile_pr86 +tilezen_mapbox-vector-tile_pr92 +timkpaine_ipydagred3_pr111 +timkpaine_ipydagred3_pr32 +timsainb_noisereduce_pr112 +tinytag_tinytag_pr111 +tinytag_tinytag_pr115 +tinytag_tinytag_pr131 +tinytag_tinytag_pr132 +tinytag_tinytag_pr133 +tinytag_tinytag_pr154 +tinytag_tinytag_pr157 +tinytag_tinytag_pr164 +tinytag_tinytag_pr181 +tinytag_tinytag_pr182 +tinytag_tinytag_pr186 +tinytag_tinytag_pr188 +tinytag_tinytag_pr194 +tinytag_tinytag_pr197 +tinytag_tinytag_pr198 +tinytag_tinytag_pr224 +tinytag_tinytag_pr231 +tinytag_tinytag_pr238 +tinytag_tinytag_pr251 +tinytag_tinytag_pr252 +tlambert03_mkdocs-api-autonav_pr12 +tlambert03_mkdocs-api-autonav_pr5 +tmux-python_tmuxp_pr911 +tmux-python_tmuxp_pr912 +tmux-python_tmuxp_pr931 +tmux-python_tmuxp_pr957 +tmux-python_tmuxp_pr965 +tobgu_pyrsistent_pr157 +tobgu_pyrsistent_pr179 +tobgu_pyrsistent_pr209 +tobgu_pyrsistent_pr234 +tobgu_pyrsistent_pr243 +tobgu_pyrsistent_pr281 +tobgu_pyrsistent_pr282 +tomasvotava_fastapi-sso_pr102 +tomasvotava_fastapi-sso_pr118 +tomasvotava_fastapi-sso_pr139 +tomasvotava_fastapi-sso_pr152 +tomasvotava_fastapi-sso_pr153 +tomasvotava_fastapi-sso_pr166 +tomasvotava_fastapi-sso_pr189 +tomasvotava_fastapi-sso_pr207 +tomasvotava_fastapi-sso_pr50 +tomasvotava_fastapi-sso_pr59 +tomasvotava_fastapi-sso_pr99 +tompollard_tableone_pr164 +tompollard_tableone_pr170 +tompollard_tableone_pr175 +tompollard_tableone_pr187 +tompollard_tableone_pr191 +tompollard_tableone_pr194 +tortoise_pypika-tortoise_pr29 +tortoise_pypika-tortoise_pr37 +tox-dev_pipdeptree_pr125 +transferwise_pipelinewise-singer-python_pr17 +treasure-data_pytd_pr11 +treasure-data_pytd_pr128 +treasure-data_pytd_pr134 +treasure-data_pytd_pr138 +treasure-data_pytd_pr142 +treasure-data_pytd_pr163 +treasure-data_pytd_pr23 +treasure-data_pytd_pr24 +treasure-data_pytd_pr32 +treasure-data_pytd_pr37 +treasure-data_pytd_pr38 +treasure-data_pytd_pr41 +treasure-data_pytd_pr45 +treasure-data_pytd_pr46 +treasure-data_pytd_pr47 +treasure-data_pytd_pr51 +treasure-data_pytd_pr53 +treasure-data_pytd_pr57 +treasure-data_pytd_pr63 +treasure-data_pytd_pr68 +treasure-data_pytd_pr72 +treasure-data_pytd_pr8 +treasure-data_pytd_pr81 +treasure-data_pytd_pr86 +treasure-data_pytd_pr94 +treasure-data_td-client-python_pr10 +treasure-data_td-client-python_pr107 +treasure-data_td-client-python_pr116 +treasure-data_td-client-python_pr119 +treasure-data_td-client-python_pr120 +treasure-data_td-client-python_pr123 +treasure-data_td-client-python_pr127 +treasure-data_td-client-python_pr129 +treasure-data_td-client-python_pr132 +treasure-data_td-client-python_pr14 +treasure-data_td-client-python_pr145 +treasure-data_td-client-python_pr22 +treasure-data_td-client-python_pr25 +treasure-data_td-client-python_pr28 +treasure-data_td-client-python_pr44 +treasure-data_td-client-python_pr59 +treasure-data_td-client-python_pr63 +treasure-data_td-client-python_pr67 +treasure-data_td-client-python_pr71 +treasure-data_td-client-python_pr75 +treasure-data_td-client-python_pr77 +treasure-data_td-client-python_pr78 +treasure-data_td-client-python_pr79 +treasure-data_td-client-python_pr80 +treasure-data_td-client-python_pr82 +treasure-data_td-client-python_pr84 +treasure-data_td-client-python_pr96 +trezor_python-mnemonic_pr69 +trufont_uharfbuzz_pr107 +trufont_uharfbuzz_pr119 +trufont_uharfbuzz_pr91 +trufont_uharfbuzz_pr93 +turner-townsend_flask-pydantic-spec_pr12 +turner-townsend_flask-pydantic-spec_pr25 +turner-townsend_flask-pydantic-spec_pr28 +turner-townsend_flask-pydantic-spec_pr39 +turner-townsend_flask-pydantic-spec_pr4 +turner-townsend_flask-pydantic-spec_pr48 +turner-townsend_flask-pydantic-spec_pr59 +turner-townsend_flask-pydantic-spec_pr62 +turner-townsend_flask-pydantic-spec_pr84 +turner-townsend_flask-pydantic-spec_pr87 +turner-townsend_flask-pydantic-spec_pr88 +turner-townsend_flask-pydantic-spec_pr90 +turner-townsend_flask-pydantic-spec_pr92 +tus_tus-py-client_pr105 +tus_tus-py-client_pr78 +tus_tus-py-client_pr92 +twitterdev_twitter-python-ads-sdk_pr104 +twitterdev_twitter-python-ads-sdk_pr119 +twitterdev_twitter-python-ads-sdk_pr120 +twitterdev_twitter-python-ads-sdk_pr122 +twitterdev_twitter-python-ads-sdk_pr131 +twitterdev_twitter-python-ads-sdk_pr135 +twitterdev_twitter-python-ads-sdk_pr137 +twitterdev_twitter-python-ads-sdk_pr138 +twitterdev_twitter-python-ads-sdk_pr142 +twitterdev_twitter-python-ads-sdk_pr151 +twitterdev_twitter-python-ads-sdk_pr152 +twitterdev_twitter-python-ads-sdk_pr157 +twitterdev_twitter-python-ads-sdk_pr160 +twitterdev_twitter-python-ads-sdk_pr161 +twitterdev_twitter-python-ads-sdk_pr174 +twitterdev_twitter-python-ads-sdk_pr183 +twitterdev_twitter-python-ads-sdk_pr191 +twitterdev_twitter-python-ads-sdk_pr193 +twitterdev_twitter-python-ads-sdk_pr198 +twitterdev_twitter-python-ads-sdk_pr203 +twitterdev_twitter-python-ads-sdk_pr210 +twitterdev_twitter-python-ads-sdk_pr211 +twitterdev_twitter-python-ads-sdk_pr212 +twitterdev_twitter-python-ads-sdk_pr213 +twitterdev_twitter-python-ads-sdk_pr223 +twitterdev_twitter-python-ads-sdk_pr251 +twitterdev_twitter-python-ads-sdk_pr252 +twitterdev_twitter-python-ads-sdk_pr275 +twitterdev_twitter-python-ads-sdk_pr281 +twitterdev_twitter-python-ads-sdk_pr36 +twitterdev_twitter-python-ads-sdk_pr56 +twitterdev_twitter-python-ads-sdk_pr62 +twitterdev_twitter-python-ads-sdk_pr86 +uiri_toml_pr128 +ultrabug_mkdocs-static-i18n_pr139 +ultrabug_mkdocs-static-i18n_pr147 +ultrabug_mkdocs-static-i18n_pr163 +ultrabug_mkdocs-static-i18n_pr183 +ultrabug_mkdocs-static-i18n_pr203 +ultrabug_mkdocs-static-i18n_pr290 +ultrabug_mkdocs-static-i18n_pr317 +untitaker_click-repl_pr102 +untitaker_click-repl_pr105 +untitaker_click-repl_pr106 +untitaker_click-repl_pr118 +untitaker_click-repl_pr28 +untitaker_click-repl_pr41 +untitaker_click-repl_pr55 +untitaker_click-repl_pr86 +untitaker_click-repl_pr88 +untitaker_click-repl_pr96 +us-irs_spacepackets-py_pr1 +us-irs_spacepackets-py_pr10 +us-irs_spacepackets-py_pr107 +us-irs_spacepackets-py_pr109 +us-irs_spacepackets-py_pr113 +us-irs_spacepackets-py_pr114 +us-irs_spacepackets-py_pr13 +us-irs_spacepackets-py_pr15 +us-irs_spacepackets-py_pr16 +us-irs_spacepackets-py_pr18 +us-irs_spacepackets-py_pr19 +us-irs_spacepackets-py_pr21 +us-irs_spacepackets-py_pr23 +us-irs_spacepackets-py_pr25 +us-irs_spacepackets-py_pr26 +us-irs_spacepackets-py_pr27 +us-irs_spacepackets-py_pr31 +us-irs_spacepackets-py_pr33 +us-irs_spacepackets-py_pr37 +us-irs_spacepackets-py_pr38 +us-irs_spacepackets-py_pr40 +us-irs_spacepackets-py_pr44 +us-irs_spacepackets-py_pr46 +us-irs_spacepackets-py_pr49 +us-irs_spacepackets-py_pr5 +us-irs_spacepackets-py_pr50 +us-irs_spacepackets-py_pr51 +us-irs_spacepackets-py_pr54 +us-irs_spacepackets-py_pr55 +us-irs_spacepackets-py_pr57 +us-irs_spacepackets-py_pr69 +us-irs_spacepackets-py_pr70 +us-irs_spacepackets-py_pr73 +us-irs_spacepackets-py_pr75 +us-irs_spacepackets-py_pr79 +us-irs_spacepackets-py_pr83 +us-irs_spacepackets-py_pr87 +us-irs_spacepackets-py_pr88 +us-irs_spacepackets-py_pr9 +us-irs_spacepackets-py_pr90 +us-irs_spacepackets-py_pr91 +us-irs_spacepackets-py_pr97 +vacanza_holidays_pr1024 +vacanza_holidays_pr1186 +vacanza_holidays_pr1355 +vacanza_holidays_pr1437 +vacanza_holidays_pr585 +vacanza_holidays_pr716 +vacanza_holidays_pr806 +valohai_gitignorant_pr7 +valohai_laituri_pr11 +valohai_laituri_pr15 +valohai_laituri_pr17 +valohai_laituri_pr20 +valohai_valohai-cli_pr11 +valohai_valohai-cli_pr12 +valohai_valohai-cli_pr15 +valohai_valohai-cli_pr157 +valohai_valohai-cli_pr163 +valohai_valohai-cli_pr166 +valohai_valohai-cli_pr171 +valohai_valohai-cli_pr176 +valohai_valohai-cli_pr178 +valohai_valohai-cli_pr179 +valohai_valohai-cli_pr18 +valohai_valohai-cli_pr180 +valohai_valohai-cli_pr186 +valohai_valohai-cli_pr190 +valohai_valohai-cli_pr192 +valohai_valohai-cli_pr195 +valohai_valohai-cli_pr200 +valohai_valohai-cli_pr205 +valohai_valohai-cli_pr210 +valohai_valohai-cli_pr212 +valohai_valohai-cli_pr213 +valohai_valohai-cli_pr234 +valohai_valohai-cli_pr239 +valohai_valohai-cli_pr243 +valohai_valohai-cli_pr273 +valohai_valohai-cli_pr278 +valohai_valohai-cli_pr281 +valohai_valohai-cli_pr285 +valohai_valohai-cli_pr287 +valohai_valohai-cli_pr290 +valohai_valohai-cli_pr292 +valohai_valohai-cli_pr298 +valohai_valohai-cli_pr3 +valohai_valohai-cli_pr305 +valohai_valohai-cli_pr31 +valohai_valohai-cli_pr310 +valohai_valohai-cli_pr319 +valohai_valohai-cli_pr321 +valohai_valohai-cli_pr322 +valohai_valohai-cli_pr323 +valohai_valohai-cli_pr324 +valohai_valohai-cli_pr328 +valohai_valohai-cli_pr332 +valohai_valohai-cli_pr338 +valohai_valohai-cli_pr340 +valohai_valohai-cli_pr5 +valohai_valohai-cli_pr51 +valohai_valohai-cli_pr52 +valohai_valohai-cli_pr54 +valohai_valohai-cli_pr57 +valohai_valohai-cli_pr62 +valohai_valohai-cli_pr71 +valohai_valohai-cli_pr72 +valohai_valohai-cli_pr75 +valohai_valohai-cli_pr88 +valohai_valohai-cli_pr9 +valohai_valohai-yaml_pr101 +valohai_valohai-yaml_pr103 +valohai_valohai-yaml_pr104 +valohai_valohai-yaml_pr105 +valohai_valohai-yaml_pr111 +valohai_valohai-yaml_pr112 +valohai_valohai-yaml_pr113 +valohai_valohai-yaml_pr115 +valohai_valohai-yaml_pr118 +valohai_valohai-yaml_pr12 +valohai_valohai-yaml_pr124 +valohai_valohai-yaml_pr126 +valohai_valohai-yaml_pr128 +valohai_valohai-yaml_pr13 +valohai_valohai-yaml_pr131 +valohai_valohai-yaml_pr132 +valohai_valohai-yaml_pr133 +valohai_valohai-yaml_pr135 +valohai_valohai-yaml_pr136 +valohai_valohai-yaml_pr137 +valohai_valohai-yaml_pr138 +valohai_valohai-yaml_pr139 +valohai_valohai-yaml_pr144 +valohai_valohai-yaml_pr147 +valohai_valohai-yaml_pr149 +valohai_valohai-yaml_pr152 +valohai_valohai-yaml_pr153 +valohai_valohai-yaml_pr157 +valohai_valohai-yaml_pr159 +valohai_valohai-yaml_pr164 +valohai_valohai-yaml_pr166 +valohai_valohai-yaml_pr167 +valohai_valohai-yaml_pr173 +valohai_valohai-yaml_pr174 +valohai_valohai-yaml_pr175 +valohai_valohai-yaml_pr20 +valohai_valohai-yaml_pr22 +valohai_valohai-yaml_pr23 +valohai_valohai-yaml_pr25 +valohai_valohai-yaml_pr29 +valohai_valohai-yaml_pr3 +valohai_valohai-yaml_pr31 +valohai_valohai-yaml_pr32 +valohai_valohai-yaml_pr34 +valohai_valohai-yaml_pr40 +valohai_valohai-yaml_pr43 +valohai_valohai-yaml_pr48 +valohai_valohai-yaml_pr5 +valohai_valohai-yaml_pr50 +valohai_valohai-yaml_pr51 +valohai_valohai-yaml_pr54 +valohai_valohai-yaml_pr57 +valohai_valohai-yaml_pr59 +valohai_valohai-yaml_pr61 +valohai_valohai-yaml_pr66 +valohai_valohai-yaml_pr7 +valohai_valohai-yaml_pr75 +valohai_valohai-yaml_pr79 +valohai_valohai-yaml_pr8 +valohai_valohai-yaml_pr85 +valohai_valohai-yaml_pr87 +valohai_valohai-yaml_pr94 +valohai_valohai-yaml_pr98 +vasp-dev_py4vasp_pr100 +vasp-dev_py4vasp_pr103 +vasp-dev_py4vasp_pr108 +vasp-dev_py4vasp_pr110 +vasp-dev_py4vasp_pr114 +vasp-dev_py4vasp_pr119 +vasp-dev_py4vasp_pr120 +vasp-dev_py4vasp_pr123 +vasp-dev_py4vasp_pr139 +vasp-dev_py4vasp_pr142 +vasp-dev_py4vasp_pr144 +vasp-dev_py4vasp_pr146 +vasp-dev_py4vasp_pr154 +vasp-dev_py4vasp_pr158 +vasp-dev_py4vasp_pr159 +vasp-dev_py4vasp_pr162 +vasp-dev_py4vasp_pr166 +vasp-dev_py4vasp_pr172 +vasp-dev_py4vasp_pr173 +vasp-dev_py4vasp_pr182 +vasp-dev_py4vasp_pr183 +vasp-dev_py4vasp_pr184 +vasp-dev_py4vasp_pr186 +vasp-dev_py4vasp_pr188 +vasp-dev_py4vasp_pr189 +vasp-dev_py4vasp_pr191 +vasp-dev_py4vasp_pr192 +vasp-dev_py4vasp_pr194 +vasp-dev_py4vasp_pr202 +vasp-dev_py4vasp_pr205 +vasp-dev_py4vasp_pr207 +vasp-dev_py4vasp_pr208 +vasp-dev_py4vasp_pr213 +vasp-dev_py4vasp_pr214 +vasp-dev_py4vasp_pr215 +vasp-dev_py4vasp_pr216 +vasp-dev_py4vasp_pr219 +vasp-dev_py4vasp_pr225 +vasp-dev_py4vasp_pr233 +vasp-dev_py4vasp_pr234 +vasp-dev_py4vasp_pr236 +vasp-dev_py4vasp_pr237 +vasp-dev_py4vasp_pr238 +vasp-dev_py4vasp_pr36 +vasp-dev_py4vasp_pr41 +vasp-dev_py4vasp_pr44 +vasp-dev_py4vasp_pr45 +vasp-dev_py4vasp_pr51 +vasp-dev_py4vasp_pr54 +vasp-dev_py4vasp_pr55 +vasp-dev_py4vasp_pr56 +vasp-dev_py4vasp_pr84 +vasp-dev_py4vasp_pr86 +vasp-dev_py4vasp_pr87 +vasp-dev_py4vasp_pr95 +vasp-dev_py4vasp_pr97 +vasp-dev_py4vasp_pr98 +vberlier_nbtlib_pr148 +vedro-universe_vedro_pr11 +vedro-universe_vedro_pr13 +vedro-universe_vedro_pr15 +vedro-universe_vedro_pr16 +vedro-universe_vedro_pr24 +vedro-universe_vedro_pr27 +vedro-universe_vedro_pr34 +vedro-universe_vedro_pr9 +venmo_business-rules_pr17 +venmo_business-rules_pr4 +vertica_dbt-vertica_pr10 +vertica_dbt-vertica_pr45 +vespa-engine_pyvespa_pr10 +vespa-engine_pyvespa_pr11 +vespa-engine_pyvespa_pr23 +vespa-engine_pyvespa_pr25 +vespa-engine_pyvespa_pr3 +vespa-engine_pyvespa_pr33 +vespa-engine_pyvespa_pr8 +vidstige_ar_pr10 +visgl_deck.gl_pr5256 +visgl_deck.gl_pr5486 +vmware_pyvmomi_pr555 +vmware_pyvmomi_pr715 +vmware_pyvmomi_pr799 +wayfair-incubator_pygitops_pr129 +wayfair-incubator_pygitops_pr251 +wayfair-incubator_pygitops_pr31 +wayfair-incubator_pygitops_pr97 +wbond_asn1crypto_pr138 +wbond_asn1crypto_pr148 +wbond_asn1crypto_pr156 +wbond_asn1crypto_pr165 +wbond_asn1crypto_pr171 +wbond_asn1crypto_pr174 +wbond_asn1crypto_pr202 +wbond_asn1crypto_pr205 +wbond_asn1crypto_pr215 +wbond_asn1crypto_pr218 +wbond_asn1crypto_pr219 +wbond_asn1crypto_pr226 +wbond_asn1crypto_pr238 +wbond_asn1crypto_pr240 +wbond_asn1crypto_pr25 +wbond_asn1crypto_pr258 +wbond_asn1crypto_pr265 +wbond_asn1crypto_pr266 +wbond_asn1crypto_pr270 +wbond_asn1crypto_pr271 +wbond_asn1crypto_pr31 +wbond_asn1crypto_pr4 +wbond_asn1crypto_pr53 +wbond_asn1crypto_pr79 +wbond_asn1crypto_pr81 +wbond_asn1crypto_pr82 +wbond_asn1crypto_pr9 +weaviate_weaviate-python-client_pr112 +weaviate_weaviate-python-client_pr113 +weaviate_weaviate-python-client_pr115 +weaviate_weaviate-python-client_pr117 +weaviate_weaviate-python-client_pr118 +weaviate_weaviate-python-client_pr119 +weaviate_weaviate-python-client_pr120 +weaviate_weaviate-python-client_pr123 +weaviate_weaviate-python-client_pr125 +weaviate_weaviate-python-client_pr136 +weaviate_weaviate-python-client_pr70 +weaviate_weaviate-python-client_pr76 +weaviate_weaviate-python-client_pr78 +weaviate_weaviate-python-client_pr81 +weaviate_weaviate-python-client_pr84 +weaviate_weaviate-python-client_pr86 +weblyzard_inscriptis_pr24 +weblyzard_inscriptis_pr27 +weblyzard_inscriptis_pr28 +weblyzard_inscriptis_pr31 +weblyzard_inscriptis_pr34 +weblyzard_inscriptis_pr35 +weblyzard_inscriptis_pr43 +weblyzard_inscriptis_pr49 +webrecorder_warcio_pr13 +webrecorder_warcio_pr36 +webrecorder_warcio_pr4 +websocket-client_websocket-client_pr116 +websocket-client_websocket-client_pr91 +wemake-services_dotenv-linter_pr641 +widgetti_reacton_pr22 +will-ockmore_httpx-retries_pr30 +will-ockmore_httpx-retries_pr38 +will-ockmore_httpx-retries_pr46 +wimglenn_djangorestframework-queryfields_pr5 +wimglenn_pytest-structlog_pr31 +wimglenn_pytest-structlog_pr40 +wireservice_agate-excel_pr18 +wireservice_agate-sql_pr26 +wireservice_agate_pr740 +wireservice_agate_pr753 +wireservice_agate_pr770 +wireservice_agate_pr776 +wireservice_agate_pr785 +wireservice_csvkit_pr1037 +wireservice_csvkit_pr1095 +wireservice_csvkit_pr1096 +wireservice_csvkit_pr1140 +wireservice_csvkit_pr1163 +wireservice_csvkit_pr1180 +wireservice_csvkit_pr1193 +wireservice_csvkit_pr1200 +wireservice_csvkit_pr1241 +wireservice_csvkit_pr1257 +wireservice_csvkit_pr1274 +wireservice_csvkit_pr713 +wireservice_csvkit_pr731 +wireservice_csvkit_pr739 +wireservice_csvkit_pr741 +wireservice_csvkit_pr744 +wireservice_csvkit_pr770 +wireservice_csvkit_pr771 +wireservice_csvkit_pr772 +wireservice_csvkit_pr773 +wireservice_csvkit_pr775 +wireservice_csvkit_pr776 +wireservice_csvkit_pr777 +wireservice_csvkit_pr779 +wireservice_csvkit_pr783 +wireservice_csvkit_pr784 +wireservice_csvkit_pr800 +wireservice_csvkit_pr801 +wireservice_csvkit_pr808 +wireservice_csvkit_pr809 +wireservice_csvkit_pr815 +wireservice_csvkit_pr836 +wireservice_csvkit_pr860 +wireservice_csvkit_pr869 +wireservice_csvkit_pr891 +wireservice_csvkit_pr900 +wireservice_csvkit_pr915 +wireservice_csvkit_pr924 +wireservice_csvkit_pr960 +wireservice_csvkit_pr964 +wireservice_csvkit_pr979 +wjohnson_pyapacheatlas_pr10 +wjohnson_pyapacheatlas_pr12 +wjohnson_pyapacheatlas_pr14 +wjohnson_pyapacheatlas_pr19 +wjohnson_pyapacheatlas_pr21 +wjohnson_pyapacheatlas_pr25 +wjohnson_pyapacheatlas_pr32 +wjohnson_pyapacheatlas_pr37 +wjohnson_pyapacheatlas_pr38 +wjohnson_pyapacheatlas_pr39 +wjohnson_pyapacheatlas_pr40 +wjohnson_pyapacheatlas_pr41 +wjohnson_pyapacheatlas_pr43 +wjohnson_pyapacheatlas_pr45 +wjohnson_pyapacheatlas_pr47 +wjohnson_pyapacheatlas_pr53 +wjohnson_pyapacheatlas_pr55 +wjohnson_pyapacheatlas_pr56 +wkentaro_imgviz_pr24 +woodgern_confusables_pr14 +woodgern_confusables_pr6 +workalendar_workalendar_pr14 +workalendar_workalendar_pr16 +workalendar_workalendar_pr17 +workalendar_workalendar_pr22 +workalendar_workalendar_pr24 +workalendar_workalendar_pr32 +workalendar_workalendar_pr34 +workalendar_workalendar_pr36 +workalendar_workalendar_pr37 +workalendar_workalendar_pr41 +workalendar_workalendar_pr42 +workalendar_workalendar_pr43 +workalendar_workalendar_pr44 +workalendar_workalendar_pr46 +workalendar_workalendar_pr51 +workalendar_workalendar_pr60 +workalendar_workalendar_pr61 +workalendar_workalendar_pr63 +workhorsy_py-cpuinfo_pr103 +workhorsy_py-cpuinfo_pr114 +workhorsy_py-cpuinfo_pr116 +workhorsy_py-cpuinfo_pr121 +workhorsy_py-cpuinfo_pr123 +workhorsy_py-cpuinfo_pr129 +workhorsy_py-cpuinfo_pr131 +workhorsy_py-cpuinfo_pr145 +workhorsy_py-cpuinfo_pr148 +workhorsy_py-cpuinfo_pr151 +workhorsy_py-cpuinfo_pr156 +workhorsy_py-cpuinfo_pr165 +workhorsy_py-cpuinfo_pr167 +workhorsy_py-cpuinfo_pr173 +workhorsy_py-cpuinfo_pr182 +workhorsy_py-cpuinfo_pr194 +workhorsy_py-cpuinfo_pr47 +workhorsy_py-cpuinfo_pr57 +workhorsy_py-cpuinfo_pr64 +workhorsy_py-cpuinfo_pr67 +workhorsy_py-cpuinfo_pr73 +workhorsy_py-cpuinfo_pr83 +wwrechard_pydlm_pr78 +wwrechard_pydlm_pr82 +wyfo_apischema_pr1 +wyfo_apischema_pr10 +wyfo_apischema_pr12 +wyfo_apischema_pr13 +wyfo_apischema_pr16 +wyfo_apischema_pr18 +wyfo_apischema_pr19 +wyfo_apischema_pr26 +wyfo_apischema_pr3 +wyfo_apischema_pr30 +wyfo_apischema_pr31 +wyfo_apischema_pr33 +wyfo_apischema_pr386 +wyfo_apischema_pr4 +wyfo_apischema_pr412 +wyfo_apischema_pr501 +wyfo_apischema_pr521 +wyfo_apischema_pr596 +wyfo_apischema_pr597 +wyfo_apischema_pr6 +wyfo_apischema_pr604 +wyfo_apischema_pr640 +xarray-contrib_cf-xarray_pr103 +xarray-contrib_cf-xarray_pr104 +xarray-contrib_cf-xarray_pr108 +xarray-contrib_cf-xarray_pr11 +xarray-contrib_cf-xarray_pr110 +xarray-contrib_cf-xarray_pr115 +xarray-contrib_cf-xarray_pr117 +xarray-contrib_cf-xarray_pr118 +xarray-contrib_cf-xarray_pr131 +xarray-contrib_cf-xarray_pr14 +xarray-contrib_cf-xarray_pr146 +xarray-contrib_cf-xarray_pr148 +xarray-contrib_cf-xarray_pr150 +xarray-contrib_cf-xarray_pr151 +xarray-contrib_cf-xarray_pr158 +xarray-contrib_cf-xarray_pr159 +xarray-contrib_cf-xarray_pr16 +xarray-contrib_cf-xarray_pr162 +xarray-contrib_cf-xarray_pr164 +xarray-contrib_cf-xarray_pr167 +xarray-contrib_cf-xarray_pr169 +xarray-contrib_cf-xarray_pr173 +xarray-contrib_cf-xarray_pr180 +xarray-contrib_cf-xarray_pr181 +xarray-contrib_cf-xarray_pr185 +xarray-contrib_cf-xarray_pr192 +xarray-contrib_cf-xarray_pr196 +xarray-contrib_cf-xarray_pr198 +xarray-contrib_cf-xarray_pr205 +xarray-contrib_cf-xarray_pr206 +xarray-contrib_cf-xarray_pr213 +xarray-contrib_cf-xarray_pr214 +xarray-contrib_cf-xarray_pr22 +xarray-contrib_cf-xarray_pr221 +xarray-contrib_cf-xarray_pr222 +xarray-contrib_cf-xarray_pr224 +xarray-contrib_cf-xarray_pr227 +xarray-contrib_cf-xarray_pr234 +xarray-contrib_cf-xarray_pr240 +xarray-contrib_cf-xarray_pr243 +xarray-contrib_cf-xarray_pr250 +xarray-contrib_cf-xarray_pr252 +xarray-contrib_cf-xarray_pr255 +xarray-contrib_cf-xarray_pr264 +xarray-contrib_cf-xarray_pr27 +xarray-contrib_cf-xarray_pr287 +xarray-contrib_cf-xarray_pr293 +xarray-contrib_cf-xarray_pr294 +xarray-contrib_cf-xarray_pr298 +xarray-contrib_cf-xarray_pr302 +xarray-contrib_cf-xarray_pr304 +xarray-contrib_cf-xarray_pr315 +xarray-contrib_cf-xarray_pr321 +xarray-contrib_cf-xarray_pr324 +xarray-contrib_cf-xarray_pr327 +xarray-contrib_cf-xarray_pr328 +xarray-contrib_cf-xarray_pr331 +xarray-contrib_cf-xarray_pr343 +xarray-contrib_cf-xarray_pr347 +xarray-contrib_cf-xarray_pr359 +xarray-contrib_cf-xarray_pr370 +xarray-contrib_cf-xarray_pr376 +xarray-contrib_cf-xarray_pr38 +xarray-contrib_cf-xarray_pr394 +xarray-contrib_cf-xarray_pr42 +xarray-contrib_cf-xarray_pr53 +xarray-contrib_cf-xarray_pr54 +xarray-contrib_cf-xarray_pr56 +xarray-contrib_cf-xarray_pr60 +xarray-contrib_cf-xarray_pr62 +xarray-contrib_cf-xarray_pr63 +xarray-contrib_cf-xarray_pr64 +xarray-contrib_cf-xarray_pr65 +xarray-contrib_cf-xarray_pr66 +xarray-contrib_cf-xarray_pr68 +xarray-contrib_cf-xarray_pr85 +xarray-contrib_cf-xarray_pr86 +xarray-contrib_cf-xarray_pr93 +xarray-contrib_cf-xarray_pr95 +xarray-contrib_cf-xarray_pr96 +xarray-contrib_cf-xarray_pr98 +xarray-contrib_datatree_pr105 +xarray-contrib_datatree_pr106 +xarray-contrib_datatree_pr107 +xarray-contrib_datatree_pr109 +xarray-contrib_datatree_pr115 +xarray-contrib_datatree_pr13 +xarray-contrib_datatree_pr156 +xarray-contrib_datatree_pr159 +xarray-contrib_datatree_pr160 +xarray-contrib_datatree_pr169 +xarray-contrib_datatree_pr170 +xarray-contrib_datatree_pr172 +xarray-contrib_datatree_pr175 +xarray-contrib_datatree_pr177 +xarray-contrib_datatree_pr178 +xarray-contrib_datatree_pr185 +xarray-contrib_datatree_pr201 +xarray-contrib_datatree_pr208 +xarray-contrib_datatree_pr263 +xarray-contrib_datatree_pr267 +xarray-contrib_datatree_pr269 +xarray-contrib_datatree_pr32 +xarray-contrib_datatree_pr34 +xarray-contrib_datatree_pr40 +xarray-contrib_datatree_pr78 +xarray-contrib_datatree_pr86 +xarray-contrib_datatree_pr88 +xarray-contrib_datatree_pr98 +xarray-contrib_datatree_pr99 +xarray-contrib_flox_pr104 +xarray-contrib_flox_pr114 +xarray-contrib_flox_pr115 +xarray-contrib_flox_pr131 +xarray-contrib_flox_pr135 +xarray-contrib_flox_pr158 +xarray-contrib_flox_pr164 +xarray-contrib_flox_pr176 +xarray-contrib_flox_pr177 +xarray-contrib_flox_pr186 +xarray-contrib_flox_pr219 +xarray-contrib_flox_pr225 +xarray-contrib_flox_pr228 +xarray-contrib_flox_pr235 +xarray-contrib_flox_pr241 +xarray-contrib_flox_pr283 +xarray-contrib_flox_pr383 +xarray-contrib_flox_pr389 +xarray-contrib_flox_pr412 +xarray-contrib_flox_pr424 +xarray-contrib_flox_pr425 +xarray-contrib_flox_pr434 +xarray-contrib_flox_pr445 +xarray-contrib_flox_pr451 +xarray-contrib_flox_pr455 +xarray-contrib_flox_pr457 +xarray-contrib_flox_pr56 +xarray-contrib_flox_pr58 +xarray-contrib_flox_pr76 +xarray-contrib_flox_pr78 +xarray-contrib_pint-xarray_pr126 +xarray-contrib_pint-xarray_pr163 +xarray-contrib_pint-xarray_pr168 +xarray-contrib_pint-xarray_pr174 +xarray-contrib_pint-xarray_pr241 +xarray-contrib_pint-xarray_pr304 +xarray-contrib_pint-xarray_pr31 +xarray-contrib_pint-xarray_pr316 +xarray-contrib_pint-xarray_pr324 +xarray-contrib_pint-xarray_pr325 +xarray-contrib_pint-xarray_pr329 +xarray-contrib_pint-xarray_pr43 +xarray-contrib_pint-xarray_pr49 +xarray-contrib_pint-xarray_pr56 +xarray-contrib_pint-xarray_pr60 +xarray-contrib_pint-xarray_pr63 +xarray-contrib_pint-xarray_pr69 +xarray-contrib_pint-xarray_pr72 +xarray-contrib_pint-xarray_pr73 +xarray-contrib_pint-xarray_pr76 +xarray-contrib_pint-xarray_pr82 +xarray-contrib_pint-xarray_pr85 +xarray-contrib_pint-xarray_pr92 +xarray-contrib_pint-xarray_pr97 +xgcm_xrft_pr100 +xgcm_xrft_pr103 +xgcm_xrft_pr112 +xgcm_xrft_pr118 +xgcm_xrft_pr122 +xgcm_xrft_pr126 +xgcm_xrft_pr128 +xgcm_xrft_pr129 +xgcm_xrft_pr134 +xgcm_xrft_pr139 +xgcm_xrft_pr143 +xgcm_xrft_pr149 +xgcm_xrft_pr152 +xgcm_xrft_pr157 +xgcm_xrft_pr161 +xgcm_xrft_pr163 +xgcm_xrft_pr174 +xgcm_xrft_pr179 +xgcm_xrft_pr186 +xgcm_xrft_pr190 +xgcm_xrft_pr195 +xgcm_xrft_pr197 +xgcm_xrft_pr209 +xgcm_xrft_pr54 +xgcm_xrft_pr66 +xgcm_xrft_pr70 +xgcm_xrft_pr80 +xgcm_xrft_pr88 +xgcm_xrft_pr89 +xgcm_xrft_pr90 +xgcm_xrft_pr95 +xhtml2pdf_xhtml2pdf_pr604 +xhtml2pdf_xhtml2pdf_pr712 +xhtml2pdf_xhtml2pdf_pr717 +xhtml2pdf_xhtml2pdf_pr725 +xhtml2pdf_xhtml2pdf_pr734 +xhtml2pdf_xhtml2pdf_pr784 +xmunoz_sodapy_pr23 +xmunoz_sodapy_pr53 +xnuinside_simple-ddl-parser_pr100 +xnuinside_simple-ddl-parser_pr104 +xnuinside_simple-ddl-parser_pr113 +xnuinside_simple-ddl-parser_pr114 +xnuinside_simple-ddl-parser_pr129 +xnuinside_simple-ddl-parser_pr13 +xnuinside_simple-ddl-parser_pr132 +xnuinside_simple-ddl-parser_pr136 +xnuinside_simple-ddl-parser_pr15 +xnuinside_simple-ddl-parser_pr152 +xnuinside_simple-ddl-parser_pr2 +xnuinside_simple-ddl-parser_pr20 +xnuinside_simple-ddl-parser_pr202 +xnuinside_simple-ddl-parser_pr21 +xnuinside_simple-ddl-parser_pr214 +xnuinside_simple-ddl-parser_pr217 +xnuinside_simple-ddl-parser_pr219 +xnuinside_simple-ddl-parser_pr220 +xnuinside_simple-ddl-parser_pr224 +xnuinside_simple-ddl-parser_pr228 +xnuinside_simple-ddl-parser_pr23 +xnuinside_simple-ddl-parser_pr230 +xnuinside_simple-ddl-parser_pr231 +xnuinside_simple-ddl-parser_pr233 +xnuinside_simple-ddl-parser_pr237 +xnuinside_simple-ddl-parser_pr24 +xnuinside_simple-ddl-parser_pr241 +xnuinside_simple-ddl-parser_pr242 +xnuinside_simple-ddl-parser_pr244 +xnuinside_simple-ddl-parser_pr256 +xnuinside_simple-ddl-parser_pr26 +xnuinside_simple-ddl-parser_pr266 +xnuinside_simple-ddl-parser_pr274 +xnuinside_simple-ddl-parser_pr277 +xnuinside_simple-ddl-parser_pr283 +xnuinside_simple-ddl-parser_pr287 +xnuinside_simple-ddl-parser_pr289 +xnuinside_simple-ddl-parser_pr33 +xnuinside_simple-ddl-parser_pr45 +xnuinside_simple-ddl-parser_pr49 +xnuinside_simple-ddl-parser_pr51 +xnuinside_simple-ddl-parser_pr52 +xnuinside_simple-ddl-parser_pr56 +xnuinside_simple-ddl-parser_pr58 +xnuinside_simple-ddl-parser_pr67 +xnuinside_simple-ddl-parser_pr7 +xnuinside_simple-ddl-parser_pr8 +xnuinside_simple-ddl-parser_pr82 +xnuinside_simple-ddl-parser_pr84 +xnuinside_simple-ddl-parser_pr86 +xnuinside_simple-ddl-parser_pr93 +xnuinside_simple-ddl-parser_pr97 +xnuinside_simple-ddl-parser_pr98 +yeraydiazdiaz_lunr.py_pr6 +yeraydiazdiaz_lunr.py_pr63 +ynqa_pandavro_pr10 +ynqa_pandavro_pr12 +ynqa_pandavro_pr22 +ynqa_pandavro_pr31 +ynqa_pandavro_pr34 +ynqa_pandavro_pr41 +ynqa_pandavro_pr8 +your-tools_python-cli-ui_pr106 +your-tools_python-cli-ui_pr58 +your-tools_python-cli-ui_pr65 +your-tools_python-cli-ui_pr74 +yt-project_unyt_pr102 +yt-project_unyt_pr103 +yt-project_unyt_pr106 +yt-project_unyt_pr108 +yt-project_unyt_pr109 +yt-project_unyt_pr111 +yt-project_unyt_pr114 +yt-project_unyt_pr115 +yt-project_unyt_pr122 +yt-project_unyt_pr129 +yt-project_unyt_pr131 +yt-project_unyt_pr133 +yt-project_unyt_pr134 +yt-project_unyt_pr135 +yt-project_unyt_pr137 +yt-project_unyt_pr140 +yt-project_unyt_pr151 +yt-project_unyt_pr152 +yt-project_unyt_pr153 +yt-project_unyt_pr155 +yt-project_unyt_pr160 +yt-project_unyt_pr162 +yt-project_unyt_pr164 +yt-project_unyt_pr170 +yt-project_unyt_pr172 +yt-project_unyt_pr174 +yt-project_unyt_pr176 +yt-project_unyt_pr185 +yt-project_unyt_pr188 +yt-project_unyt_pr19 +yt-project_unyt_pr191 +yt-project_unyt_pr197 +yt-project_unyt_pr2 +yt-project_unyt_pr20 +yt-project_unyt_pr204 +yt-project_unyt_pr21 +yt-project_unyt_pr211 +yt-project_unyt_pr217 +yt-project_unyt_pr219 +yt-project_unyt_pr22 +yt-project_unyt_pr225 +yt-project_unyt_pr228 +yt-project_unyt_pr23 +yt-project_unyt_pr231 +yt-project_unyt_pr242 +yt-project_unyt_pr250 +yt-project_unyt_pr277 +yt-project_unyt_pr278 +yt-project_unyt_pr3 +yt-project_unyt_pr31 +yt-project_unyt_pr35 +yt-project_unyt_pr41 +yt-project_unyt_pr44 +yt-project_unyt_pr5 +yt-project_unyt_pr52 +yt-project_unyt_pr54 +yt-project_unyt_pr56 +yt-project_unyt_pr58 +yt-project_unyt_pr62 +yt-project_unyt_pr64 +yt-project_unyt_pr65 +yt-project_unyt_pr72 +yt-project_unyt_pr73 +yt-project_unyt_pr78 +yt-project_unyt_pr79 +yt-project_unyt_pr80 +yt-project_unyt_pr81 +yt-project_unyt_pr82 +yt-project_unyt_pr86 +yt-project_unyt_pr93 +yt-project_unyt_pr96 +yu-iskw_dbt-artifacts-parser_pr16 +yu-iskw_dbt-artifacts-parser_pr172 +yu-iskw_dbt-artifacts-parser_pr182 +yu-iskw_dbt-artifacts-parser_pr19 +yu-iskw_dbt-artifacts-parser_pr48 +yu-iskw_dbt-artifacts-parser_pr79 +yu-iskw_dbt-artifacts-parser_pr8 +yurymalkov_hnsw_pr16 +yurymalkov_hnsw_pr27 +yurymalkov_hnsw_pr85 +yuvipanda_ipynb_pr19 +zabbix_python-zabbix-utils_pr13 +zabuldon_teslajsonpy_pr105 +zabuldon_teslajsonpy_pr108 +zabuldon_teslajsonpy_pr122 +zabuldon_teslajsonpy_pr393 +zabuldon_teslajsonpy_pr409 +zabuldon_teslajsonpy_pr418 +zabuldon_teslajsonpy_pr425 +zabuldon_teslajsonpy_pr432 +zabuldon_teslajsonpy_pr451 +zabuldon_teslajsonpy_pr457 +zabuldon_teslajsonpy_pr458 +zabuldon_teslajsonpy_pr464 +zabuldon_teslajsonpy_pr467 +zabuldon_teslajsonpy_pr469 +zabuldon_teslajsonpy_pr476 +zabuldon_teslajsonpy_pr79 +zabuldon_teslajsonpy_pr99 +zapier_email-reply-parser_pr14 +zapier_email-reply-parser_pr31 +zeth_inputs_pr33 +zeth_inputs_pr41 +zeth_inputs_pr47 +zeth_inputs_pr49 +zeth_inputs_pr57 +zfit_zfit_pr6 +zheller_flake8-quotes_pr27 +zheller_flake8-quotes_pr32 +zheller_flake8-quotes_pr34 +zheller_flake8-quotes_pr52 +zheller_flake8-quotes_pr54 +zheller_flake8-quotes_pr57 +zheller_flake8-quotes_pr78 +zheller_flake8-quotes_pr81 +zheller_flake8-quotes_pr94 +zheller_flake8-quotes_pr96 +zheller_flake8-quotes_pr99 +zhelyabuzhsky_stockfish_pr11 +zhelyabuzhsky_stockfish_pr19 +zhelyabuzhsky_stockfish_pr2 +zhelyabuzhsky_stockfish_pr23 +zhelyabuzhsky_stockfish_pr24 +zhelyabuzhsky_stockfish_pr26 +zhelyabuzhsky_stockfish_pr30 +zhelyabuzhsky_stockfish_pr33 +zhelyabuzhsky_stockfish_pr48 +zhelyabuzhsky_stockfish_pr61 +zhelyabuzhsky_stockfish_pr63 +zhelyabuzhsky_stockfish_pr64 +zhelyabuzhsky_stockfish_pr7 +zhelyabuzhsky_stockfish_pr80 diff --git a/resources_servers/scale_swe/diagnose_failures.py b/resources_servers/scale_swe/diagnose_failures.py new file mode 100644 index 00000000000..1ccaf9e38be --- /dev/null +++ b/resources_servers/scale_swe/diagnose_failures.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Separate golden-patch failures caused by the sandbox from failures of the row itself. + +This exists because `evaluation_completed` does not answer the question. A build that is +OOM-killed, or a test suite that runs out of disk, still produces a parsed log and a verdict -- +the tests simply failed. That grades identically to a genuinely broken golden patch, so raising +the memory limit would silently change the "supported" set. + +The signatures below are read out of the captured test output, so a failure is attributed to +resources only on direct evidence, never inferred from the fact that it failed. + + python resources_servers/scale_swe/diagnose_failures.py results/.../pass1_job_X.jsonl +""" + +from __future__ import annotations + +import argparse +import json +import sys +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +# Ordered: the first match wins, so the most specific cause is reported. +RESOURCE_SIGNATURES: tuple[tuple[str, tuple[str, ...]], ...] = ( + ( + "disk_full", + ("no space left on device", "enospc", "disk quota exceeded", "write error: no space"), + ), + ( + "oom", + ( + "out of memory", + "outofmemoryerror", + "cannot allocate memory", + "oom-kill", + "oom killed", + "killed process", + "memoryerror", + "signal: killed", + "runtime: out of memory", + "fatal error: out of memory", + "std::bad_alloc", + "exit status 137", + "javaheapspace", + "java heap space", + "gc overhead limit exceeded", + ), + ), + ( + "process_killed", + # A bare SIGKILL with no allocator message. Usually the cgroup OOM killer, but the + # evidence is weaker, so it is reported separately rather than folded into `oom`. + ("killed", "sigkill", "terminated by signal 9"), + ), + ( + "too_many_files", + ("too many open files", "emfile"), + ), + ( + "network", + # An egress fault -- pip/git failing to reach a registry -- rather than evidence the + # golden patch is wrong. Confirm against the actual output before trusting a raised + # limit or a retry policy change: SWE-rebench's version of this bucket turned out to be + # one specific unreachable host, not a sandbox-wide restriction (see that server's + # diagnose_failures.py history for the false starts before the real cause was found). + ( + "could not resolve host", + "connection refused", + "network is unreachable", + "temporary failure in name resolution", + "etimedout", + "econnreset", + "proxyconnect", + ), + ), +) + + +def classify_output(text: str) -> str | None: + """Return the resource cause evidenced in the output, or None.""" + lowered = text.lower() + for label, needles in RESOURCE_SIGNATURES: + if any(needle in lowered for needle in needles): + return label + return None + + +def _rows(path: Path): + with path.open(encoding="utf-8") as handle: + for line in handle: + line = line.strip() + if line: + try: + yield json.loads(line) + except json.JSONDecodeError: + continue + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("rollouts_jsonl", type=Path) + parser.add_argument( + "--timeout-s", + type=float, + default=1200.0, + help="The configured evaluation timeout; runs within --near of it are treated as timing out.", + ) + parser.add_argument("--near", type=float, default=0.9, help="Fraction of the timeout that counts as 'near'.") + parser.add_argument("--show", type=int, default=4, help="Example instance ids to print per cause.") + args = parser.parse_args() + + if not args.rollouts_jsonl.exists(): + print(f"no such file: {args.rollouts_jsonl}", file=sys.stderr) + return 2 + + total = 0 + resolved = 0 + failures: list[dict[str, Any]] = [] + durations: list[float] = [] + + for row in _rows(args.rollouts_jsonl): + total += 1 + duration = float(row.get("patch_verification_time_taken") or 0.0) + durations.append(duration) + if row.get("resolved"): + resolved += 1 + continue + failures.append(row) + + if total == 0: + print("no rows", file=sys.stderr) + return 2 + + causes: Counter[str] = Counter() + examples: dict[str, list[str]] = defaultdict(list) + by_language: dict[str, Counter[str]] = defaultdict(Counter) + + for row in failures: + instance_id = str(row.get("instance_id") or "?") + language = str(row.get("language") or "unknown") + duration = float(row.get("patch_verification_time_taken") or 0.0) + output = str(row.get("test_output") or "") + error = str(row.get("error") or "") + + if not row.get("evaluation_completed", False): + cause = "no_verdict" + elif duration >= args.timeout_s * args.near: + # Ran to (or near) the ceiling. With CPU requests well below limits this is the + # shape CPU starvation takes: the work is not wrong, it just never finished. + cause = "timeout" + elif (row.get("test_results") or {}).get("tests_observed", 0) == 0 and (row.get("test_results") is not None): + # pytest saw zero tests, so nothing ran: pre_commands or the patch/f2p-script + # apply died before the suite started, or the named test files never exist in + # this checkout. A different thing from "the tests failed" -- the golden patch is + # not implicated either way, so this is not scored as evidence against the row. + cause = classify_output(output + "\n" + error) or "no_tests_ran" + else: + cause = classify_output(output + "\n" + error) or "row_failure" + + causes[cause] += 1 + by_language[language][cause] += 1 + if len(examples[cause]) < args.show: + examples[cause].append(f"{instance_id} ({language}, {duration:.0f}s)") + + # Causes that are about the environment rather than the row. `no_tests_ran` is included: + # a suite that never started says nothing about whether the golden patch is correct. + resource_causes = { + "oom", + "disk_full", + "process_killed", + "too_many_files", + "network", + "timeout", + "no_verdict", + "no_tests_ran", + } + resource_total = sum(count for cause, count in causes.items() if cause in resource_causes) + + print(f"rows: {total} resolved: {resolved} ({100 * resolved / total:.1f}%) failures: {len(failures)}") + if durations: + ordered = sorted(durations) + p50 = ordered[len(ordered) // 2] + p95 = ordered[min(len(ordered) - 1, int(len(ordered) * 0.95))] + print( + f"verification seconds: p50={p50:.0f} p95={p95:.0f} max={ordered[-1]:.0f} (timeout {args.timeout_s:.0f})" + ) + print() + print("failure attribution:") + for cause, count in causes.most_common(): + marker = "ENV" if cause in resource_causes else "row" + share = 100 * count / max(len(failures), 1) + print(f" {cause:<16} {count:>5} ({share:5.1f}% of failures) [{marker}]") + for example in examples[cause]: + print(f" e.g. {example}") + + print() + if not failures: + print("VERDICT: no failures to attribute") + elif resource_total == 0: + print("VERDICT: no failure shows resource evidence — these look like genuine row failures.") + print(" Raising sandbox limits would not change the supported set.") + else: + share = 100 * resource_total / len(failures) + print( + f"VERDICT: {resource_total}/{len(failures)} failures ({share:.1f}%) show resource or environment evidence." + ) + print(" Raise the relevant limit and re-measure before treating these rows as broken.") + + if by_language: + print("\n per-language failure causes:") + for language, counts in sorted(by_language.items(), key=lambda kv: -sum(kv[1].values())): + summary = " ".join(f"{cause}={count}" for cause, count in counts.most_common()) + print(f" {language:<10} {summary}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/resources_servers/scale_swe/requirements.txt b/resources_servers/scale_swe/requirements.txt new file mode 100644 index 00000000000..2c9ef83ea2a --- /dev/null +++ b/resources_servers/scale_swe/requirements.txt @@ -0,0 +1 @@ +-e nemo-gym[dev,sandbox] @ ../.. diff --git a/resources_servers/scale_swe/tests/__init__.py b/resources_servers/scale_swe/tests/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/scale_swe/tests/test_app.py b/resources_servers/scale_swe/tests/test_app.py new file mode 100644 index 00000000000..c102aea15c4 --- /dev/null +++ b/resources_servers/scale_swe/tests/test_app.py @@ -0,0 +1,386 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tests for the Scale-SWE resources server's grading and script construction. + +These cover the parts that decide whether a task counts as resolved. The sandbox lifecycle +itself is exercised by the golden-patch run, which needs a live OpenSandbox endpoint. + +Several tests here pin bugs that were actually hit building resources_servers/swe_rebench (the +sibling server): a verify response missing the echoed request fields, and a multi-worker +entrypoint with no module-level `app`. Both looked fine locally and both only failed once real +traffic hit them. Writing the same tests here from the start is cheaper than re-discovering the +same two bugs on a second dataset. +""" + +from types import SimpleNamespace + +import pytest + +from resources_servers.scale_swe.verification import ( + F2P_SCRIPT_NAME, + TEST_OUTPUT_BEGIN, + TEST_OUTPUT_END, + VerificationInputs, + as_id_list, + build_eval_script, + extract_statuses, + grade, + run_verification, + slice_test_output, + unique_test_files, + verification_files, +) + + +def _inputs(**overrides) -> VerificationInputs: + base = dict( + instance_id="auth0_auth0-python_pr671", + workdir="/workspace/auth0-python", + patch="diff --git a/a b/a\n", + pre_commands="git checkout deadbeef -f && git reset --hard HEAD", + f2p_patch="", + f2p_script="import pytest\ndef test_thing(): assert True\n", + fail_to_pass=[f"{F2P_SCRIPT_NAME}::test_thing"], + pass_to_pass=["tests/test_base.py::TestBase::test_get"], + ) + base.update(overrides) + return VerificationInputs(**base) + + +class TestAsIdList: + def test_decodes_the_json_encoded_string_the_dataset_ships(self) -> None: + # FAIL_TO_PASS / PASS_TO_PASS arrive as JSON-encoded strings in this dataset, not lists. + assert as_id_list('["a::b", "c::d"]') == ["a::b", "c::d"] + + def test_accepts_an_already_decoded_list(self) -> None: + assert as_id_list(["a::b"]) == ["a::b"] + + @pytest.mark.parametrize("value", [None, "", "[]"]) + def test_empty_inputs_yield_no_ids(self, value) -> None: + assert as_id_list(value) == [] + + def test_malformed_json_falls_back_to_a_single_literal_id_rather_than_crashing(self) -> None: + # A row-level data error must degrade to "one id that will not match anything" (and + # so masks/fails safely) rather than raise and take the whole verification down with it. + assert as_id_list("not json") == ["not json"] + + +class TestTestFilesFor: + def test_extracts_unique_files_preserving_first_seen_order(self) -> None: + ids = ["b/test.py::test_1", "a/test.py::test_2", "b/test.py::test_3"] + assert unique_test_files(ids) == ["b/test.py", "a/test.py"] + + def test_a_row_with_dozens_of_node_ids_still_yields_one_entry_per_file(self) -> None: + # A real row can carry up to ~69 files across hundreds of node ids; pytest is pointed + # at files, not the full id list, specifically to avoid a huge command line. + ids = [f"pkg/test_{i}.py::test_case_{j}" for i in range(5) for j in range(20)] + assert len(unique_test_files(ids)) == 5 + + +class TestExtractStatuses: + """extract_statuses matches against the row's OWN known ids rather than parsing an id out + of free text -- see the docstring on the function for why a whitespace-delimited regex is + wrong for this dataset. These tests are built from a real failure: one row in a 200-row + validation pass had 954/954 tests pass, but the naive parser truncated every parametrized + id at its first space and scored the row as a near-total regression.""" + + def test_reads_passed_and_failed_for_plain_ids(self) -> None: + log = "PASSED test_a.py::test_1\nFAILED test_a.py::test_2 - AssertionError\n" + statuses = extract_statuses(log, ["test_a.py::test_1", "test_a.py::test_2"]) + assert statuses["test_a.py::test_1"] == "PASSED" + assert statuses["test_a.py::test_2"] == "FAILED" + + def test_only_reports_the_ids_it_was_asked_about(self) -> None: + log = "PASSED test_a.py::test_1\nPASSED test_a.py::test_unrelated\n" + assert extract_statuses(log, ["test_a.py::test_1"]) == {"test_a.py::test_1": "PASSED"} + + def test_handles_a_parametrized_id_containing_a_literal_space(self) -> None: + # The actual bug: a whitespace-delimited regex truncates this at "[No". + node_id = "tests/test_parser.py::test_parse_address[No address here-None]" + log = f"PASSED {node_id}\n" + assert extract_statuses(log, [node_id]) == {node_id: "PASSED"} + + def test_handles_a_failed_id_whose_own_text_contains_the_reason_delimiter(self) -> None: + # A real dataset id: "...[2590 Elm Road NE - Warren, OH 44483-expected1]" contains a + # literal " - " inside its brackets, so splitting a FAILED line on " - " to find where + # the id ends and the reason begins is ambiguous in general. Matching against the known + # id directly sidesteps that. + node_id = "tests/test_parser.py::test_parse_address[2590 Elm Road NE - Warren, OH 44483-expected1]" + log = f"FAILED {node_id} - AssertionError: mismatch\n" + assert extract_statuses(log, [node_id]) == {node_id: "FAILED"} + + def test_a_short_id_is_not_mistaken_for_a_prefix_of_a_longer_unrelated_one(self) -> None: + # "test_foo" must not match inside a line reporting "test_foo_extra", and trying the + # longer candidate id first is what prevents it. + log = "PASSED test_a.py::test_foo_extra\n" + assert extract_statuses(log, ["test_a.py::test_foo"]) == {} + + def test_longer_ids_are_preferred_when_both_are_targets(self) -> None: + log = "PASSED test_a.py::test_foo_extra\n" + statuses = extract_statuses(log, ["test_a.py::test_foo", "test_a.py::test_foo_extra"]) + assert statuses == {"test_a.py::test_foo_extra": "PASSED"} + + def test_later_lines_win_when_a_test_id_appears_twice(self) -> None: + # pytest prints progress dots/lines first and the short summary last; the summary is + # authoritative. + log = "FAILED test_a.py::test_1\nsome retry output\nPASSED test_a.py::test_1\n" + assert extract_statuses(log, ["test_a.py::test_1"]) == {"test_a.py::test_1": "PASSED"} + + def test_unrecognised_output_yields_no_statuses(self) -> None: + assert extract_statuses("collecting ... \ninternal error\n", ["test_a.py::test_1"]) == {} + + def test_an_id_that_never_appears_is_absent_not_a_crash(self) -> None: + assert extract_statuses("PASSED test_a.py::test_1\n", ["test_a.py::test_missing"]) == {} + + +class TestSliceTestOutput: + def test_keeps_only_the_graded_region(self) -> None: + log = f"pip installing\nFAILED bogus\n{TEST_OUTPUT_BEGIN}\nPASSED real\n{TEST_OUTPUT_END}\ncleanup" + sliced = slice_test_output(log) + assert "PASSED real" in sliced + assert "FAILED bogus" not in sliced + assert "cleanup" not in sliced + + def test_falls_back_to_the_whole_log_when_markers_are_absent(self) -> None: + assert slice_test_output("PASSED a") == "PASSED a" + + +class TestGrade: + def test_resolves_only_when_every_required_test_passes(self) -> None: + report = grade({"f2p": "PASSED", "p2p": "PASSED"}, ["f2p"], ["p2p"]) + assert report["resolved"] is True + + def test_a_failing_fail_to_pass_does_not_resolve(self) -> None: + report = grade({"f2p": "FAILED", "p2p": "PASSED"}, ["f2p"], ["p2p"]) + assert report["resolved"] is False + assert report["FAIL_TO_PASS"]["failure"] == ["f2p"] + + def test_a_regressed_pass_to_pass_does_not_resolve(self) -> None: + report = grade({"f2p": "PASSED", "p2p": "FAILED"}, ["f2p"], ["p2p"]) + assert report["resolved"] is False + + def test_a_missing_test_counts_as_not_passing(self) -> None: + """A test id that never appears in the output (a collection error, e.g.) must not read + as success or an empty pytest run scores as a resolved instance.""" + report = grade({}, ["f2p"], ["p2p"]) + assert report["resolved"] is False + assert report["tests_observed"] == 0 + + def test_skipped_is_not_passed(self) -> None: + assert grade({"f2p": "SKIPPED"}, ["f2p"], [])["resolved"] is False + + +class TestBuildEvalScript: + def test_runs_pre_commands_before_anything_else(self) -> None: + # pre_commands performs the checkout of parent_commit and scrubs the fix commit out of + # git history; applying a patch before it would be immediately discarded. + script = build_eval_script(_inputs()) + assert script.index("git checkout deadbeef") < script.index("nemo_gym_patch.diff") + + def test_signals_a_missing_workdir(self) -> None: + script = build_eval_script(_inputs()) + assert "exit 97" in script + assert any(line.startswith("cd ") and "/workspace/auth0-python" in line for line in script.splitlines()) + + def test_omits_the_patch_step_when_there_is_no_patch(self) -> None: + script = build_eval_script(_inputs(patch="")) + assert "nemo_gym_patch.diff" not in script + + def test_installs_f2p_script_from_tmp_not_by_writing_into_the_repo_first(self) -> None: + # f2p_script cannot be written into the repo before pre_commands: `git clean -fd` (part + # of every row's pre_commands) would delete it. It is uploaded to /tmp and copied in + # afterwards instead. + script = build_eval_script(_inputs()) + assert f"cp /tmp/nemo_gym_f2p_script.py {F2P_SCRIPT_NAME}" in script + copy_at = script.index("cp /tmp/nemo_gym_f2p_script.py") + pre_at = script.index("git checkout deadbeef") + assert pre_at < copy_at + + def test_omits_the_f2p_script_step_when_the_row_has_none(self) -> None: + script = build_eval_script(_inputs(f2p_script="")) + assert "nemo_gym_f2p_script.py" not in script + + def test_applies_f2p_patch_when_present(self) -> None: + script = build_eval_script(_inputs(f2p_patch="diff --git a/t b/t\n")) + assert "nemo_gym_f2p.diff" in script + + def test_targets_only_the_files_named_by_fail_to_pass_and_pass_to_pass(self) -> None: + script = build_eval_script(_inputs(fail_to_pass=["a/test_x.py::t1"], pass_to_pass=["b/test_y.py::t2"])) + assert "a/test_x.py" in script + assert "b/test_y.py" in script + + def test_brackets_the_test_command_with_markers(self) -> None: + script = build_eval_script(_inputs()) + assert script.index(TEST_OUTPUT_BEGIN) < script.index("pytest") < script.index(TEST_OUTPUT_END) + + def test_propagates_the_test_exit_code_not_the_setup_ones(self) -> None: + script = build_eval_script(_inputs()) + assert "__test_exit=$?" in script and "exit $__test_exit" in script + # pre_commands and the patch steps must not abort the script (`set +e`) or a row whose + # history-scrub emits a nonzero exit never reaches the tests at all. + assert "set +e" in script + + +class TestVerificationFiles: + def test_ships_the_script_and_only_the_pieces_that_exist(self) -> None: + files = verification_files(_inputs(patch="", f2p_patch="")) + assert "/tmp/nemo_gym_eval.sh" in files + assert "/tmp/nemo_gym_patch.diff" not in files + assert "/tmp/nemo_gym_f2p.diff" not in files + assert "/tmp/nemo_gym_f2p_script.py" in files + + def test_ships_the_f2p_patch_when_the_row_has_one(self) -> None: + files = verification_files(_inputs(f2p_patch="diff --git a/t b/t\n")) + assert "/tmp/nemo_gym_f2p.diff" in files + + +class _FakeSandbox: + def __init__(self, stdout: str, return_code: int = 0) -> None: + self._result = SimpleNamespace(stdout=stdout, stderr="", return_code=return_code) + self.commands: list[str] = [] + + async def exec(self, command: str, timeout_s=None): + self.commands.append(command) + return self._result + + +class TestRunVerification: + @pytest.mark.asyncio + async def test_grades_a_passing_run(self) -> None: + log = f"{TEST_OUTPUT_BEGIN}\nPASSED {F2P_SCRIPT_NAME}::test_thing\n{TEST_OUTPUT_END}" + sandbox = _FakeSandbox(log) + # Isolate the thing under test (marker slicing + grading of one passing id) from the + # unrelated PASS_TO_PASS id the shared fixture carries by default. + result = await run_verification(sandbox=sandbox, inputs=_inputs(pass_to_pass=[])) + assert result.completed and result.resolved + assert sandbox.commands == ["bash /tmp/nemo_gym_eval.sh"] + + @pytest.mark.asyncio + async def test_missing_workdir_is_incomplete_not_a_zero(self) -> None: + result = await run_verification(sandbox=_FakeSandbox("", return_code=97), inputs=_inputs()) + assert result.completed is False + assert result.resolved is False + assert "not present in the image" in result.error + + @pytest.mark.asyncio + async def test_only_the_marked_region_reaches_the_parser(self) -> None: + log = ( + f"pip: FAILED to fetch\n{TEST_OUTPUT_BEGIN}\n" + f"PASSED {F2P_SCRIPT_NAME}::test_thing\n{TEST_OUTPUT_END}\ntrailing" + ) + result = await run_verification(sandbox=_FakeSandbox(log), inputs=_inputs(pass_to_pass=[])) + assert result.resolved is True # would be masked by the install-time "FAILED" if unsliced + + +class TestVerifyResponseShape: + """BaseVerifyResponse extends BaseVerifyRequest, so the request fields are REQUIRED on the + way out. Building the response from scratch drops them and the resulting ValidationError + surfaces to the caller as a bare JSON string -- which is how a fully successful verification + can still fail the whole sweep. (Hit for real in resources_servers/swe_rebench/app.py.)""" + + @staticmethod + def _body() -> dict: + return { + "instance_id": "auth0_auth0-python_pr671", + "workdir": "/workspace/auth0-python", + "image_url": "aweaiteam/scaleswe:auth0_auth0-python_pr671", + "language": "python", + "FAIL_TO_PASS": [], + "PASS_TO_PASS": [], + "responses_create_params": {"input": []}, + "response": { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], + }, + } + + def test_spreading_the_request_body_satisfies_the_response_model(self) -> None: + from resources_servers.scale_swe.app import ScaleSWEVerifyResponse + + response = ScaleSWEVerifyResponse.model_validate( + self._body() + | { + "reward": 1.0, + "evaluation_completed": True, + "resolved": True, + "patch_applied": True, + "test_results": {"resolved": True}, + "test_output": "", + "error": None, + "eval_sandbox_start_time_taken": 1.0, + "patch_verification_time_taken": 2.0, + } + ) + assert response.reward == 1.0 and response.resolved + + def test_omitting_the_request_fields_is_rejected(self) -> None: + import pydantic + + from resources_servers.scale_swe.app import ScaleSWEVerifyResponse + + with pytest.raises(pydantic.ValidationError, match="responses_create_params|response"): + ScaleSWEVerifyResponse.model_validate( + { + "reward": 1.0, + "evaluation_completed": True, + "resolved": True, + "patch_applied": True, + "instance_id": "i", + "language": "python", + "test_results": None, + "test_output": "", + "error": None, + "eval_sandbox_start_time_taken": 0.0, + "patch_verification_time_taken": 0.0, + } + ) + + +class TestMultiWorkerEntrypoint: + """num_workers > 1 makes uvicorn re-import this entrypoint by path in each forked child. + Without a module-level `app`, every child exits and uvicorn stops the parent, so the server + never binds -- the symptom is a flood of connection errors from clients talking to a dead + port, not an ImportError. (Hit for real in resources_servers/swe_rebench/app.py.)""" + + @staticmethod + def _source() -> str: + from pathlib import Path + + return (Path(__file__).resolve().parent.parent / "app.py").read_text() + + def test_exposes_a_module_level_app_for_forked_workers(self) -> None: + source = self._source() + assert "is_nemo_gym_fastapi_entrypoint(__file__)" in source + assert "app = ScaleSWEResourcesServer.run_webserver()" in source + + def test_the_config_that_needs_it_still_sets_num_workers(self) -> None: + """Pins the pair: if num_workers is configured, the entrypoint branch must exist.""" + from pathlib import Path + + import yaml + + config = yaml.safe_load((Path(__file__).resolve().parent.parent / "configs" / "scale_swe.yaml").read_text()) + for name, block in config.items(): + workers = block["resources_servers"]["scale_swe"].get("num_workers") + if workers and workers > 1: + assert "is_nemo_gym_fastapi_entrypoint(__file__)" in self._source(), ( + f"{name} sets num_workers={workers} but the entrypoint has no module-level app" + ) diff --git a/resources_servers/scale_swe/verification.py b/resources_servers/scale_swe/verification.py new file mode 100644 index 00000000000..6e5f8ae444a --- /dev/null +++ b/resources_servers/scale_swe/verification.py @@ -0,0 +1,275 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Run one AweAI-Team/Scale-SWE instance's tests in a sandbox and grade the result. + +Scale-SWE is 20,181 rows and entirely Python, so unlike the multi-language sets there is one +test runner (pytest) and one log format. That removes the parser-dispatch problem completely. + +Each row carries its own image, an explicit ``workdir``, and a ``pre_commands`` string that +performs the checkout of ``parent_commit`` and scrubs the repo's git history so the fix commit +is not reachable. The failing tests arrive one of two ways -- a literal test file in +``f2p_script`` (92% of rows) or a patch in ``f2p_patch`` (69%) -- and many rows have both. +""" + +from __future__ import annotations + +import asyncio +import json +import shlex +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any, Iterable, Sequence + + +TEST_OUTPUT_BEGIN = "___NEMO_GYM_SCALE_SWE_TEST_BEGIN___" +TEST_OUTPUT_END = "___NEMO_GYM_SCALE_SWE_TEST_END___" + +# Where f2p_script is written. The dataset's own FAIL_TO_PASS ids name this file, so the path +# is part of the data contract rather than a choice. +F2P_SCRIPT_NAME = "test_fail_to_pass.py" + +PASSED = "PASSED" + +_STATUS_WORDS = ("PASSED", "FAILED", "ERROR", "XFAIL", "XPASS") + + +def extract_statuses(log: str, target_ids: Iterable[str]) -> dict[str, str]: + """Map each of ``target_ids`` to its pytest status, read from a ``-rA`` short summary. + + A naive ``STATUS `` regex (``\\S+`` up to the first whitespace) is wrong here: this + dataset parametrizes tests over literal address strings, so a real summary line looks like + ``PASSED tests/test_parser.py::test_parse_address[No address here-None]`` -- the id itself + contains spaces. Worse, ``FAILED``/``ERROR`` lines append `` - ``, and some of the + same ids ALSO contain a literal `` - `` inside their brackets (e.g. + ``test_parse_address[2590 Elm Road NE - Warren, OH 44483-expected1]``), so no fixed + delimiter reliably separates "the id" from "the reason" in general. + + Measured cost of getting this wrong: one row in a 200-row sample had 954/954 tests pass, + with every PASSED line truncated at the first space by the naive parser -- 494 of that + row's PASS_TO_PASS ids then read as "absent" (not passing), scoring a fully green run as a + near-total regression. + + The fix sidesteps the ambiguity: rather than parsing an id out of free text, check whether + the text after the status word STARTS WITH one of the ids we already know we need (the + row's own FAIL_TO_PASS/PASS_TO_PASS). Real ids always end at a syntactic boundary -- + ``]`` for a parametrized id, an identifier character otherwise -- so a full-string + ``startswith`` match is exact there; it is only ambiguous for two candidate ids where one + is a literal prefix of the other (e.g. ``test_foo`` vs. ``test_foo_extra``), which trying + the longest ids first resolves. + """ + ids_by_length = sorted(set(target_ids), key=len, reverse=True) + statuses: dict[str, str] = {} + for line in log.splitlines(): + for status in _STATUS_WORDS: + prefix = status + " " + if not line.startswith(prefix): + continue + rest = line[len(prefix) :] + for node_id in ids_by_length: + if rest.startswith(node_id) and (len(rest) == len(node_id) or rest[len(node_id)] in " \t-"): + # Later occurrences win: pytest prints progress first and the summary + # last, and the summary is authoritative. + statuses[node_id] = status + break + break + return statuses + + +def as_id_list(value: Any) -> list[str]: + """FAIL_TO_PASS / PASS_TO_PASS arrive as JSON-encoded strings in this dataset.""" + if not value: + return [] + if isinstance(value, str): + try: + decoded = json.loads(value) + except json.JSONDecodeError: + return [value] + return [str(item) for item in decoded] if isinstance(decoded, list) else [] + return [str(item) for item in value] + + +def unique_test_files(node_ids: Iterable[str]) -> list[str]: + """Unique test files named by a set of node ids, order preserved. + + pytest is pointed at files rather than the ids themselves: a row can carry hundreds of ids + across up to ~69 files, which risks the command-line length limit, and running the file and + grading by id afterwards gives the same verdict without that fragility. + """ + files: list[str] = [] + for node_id in node_ids: + path = node_id.split("::", 1)[0].strip() + if path and path not in files: + files.append(path) + return files + + +@dataclass +class VerificationInputs: + instance_id: str + workdir: str + patch: str + pre_commands: str = "" + f2p_patch: str = "" + f2p_script: str = "" + fail_to_pass: Sequence[str] = field(default_factory=tuple) + pass_to_pass: Sequence[str] = field(default_factory=tuple) + + +@dataclass +class VerificationResult: + completed: bool + resolved: bool + patch_applied: bool + test_results: dict[str, Any] | None + test_output: str + error: str | None = None + + +def _clean_commands(value: str) -> str: + """``pre_commands`` ends with a literal backslash-n in the published data.""" + return value.replace("\\n", "\n").strip() + + +def build_eval_script(inputs: VerificationInputs) -> str: + """The script run inside the sandbox. + + ``pre_commands`` runs FIRST and unconditionally: it performs the checkout of parent_commit + and rewrites git history, so applying a patch before it would be undone immediately. + """ + files = unique_test_files(list(inputs.fail_to_pass) + list(inputs.pass_to_pass)) + pytest_targets = " ".join(shlex.quote(path) for path in files) + + pre = _clean_commands(inputs.pre_commands) + apply_patch = ( + "git apply --reject --recount --ignore-space-change --whitespace=nowarn /tmp/nemo_gym_patch.diff || true" + if inputs.patch.strip() + else "" + ) + apply_f2p_patch = ( + "git apply --reject --recount --ignore-space-change --whitespace=nowarn /tmp/nemo_gym_f2p.diff || true" + if inputs.f2p_patch.strip() + else "" + ) + # The script is uploaded to /tmp and copied in, rather than written into the repo before + # pre_commands, because `git clean -fd` there would delete it. + install_f2p_script = ( + f"cp /tmp/nemo_gym_f2p_script.py {shlex.quote(F2P_SCRIPT_NAME)}" if inputs.f2p_script.strip() else "" + ) + + return f"""#!/bin/bash +cd {shlex.quote(inputs.workdir)} || exit 97 + +# Checkout and history scrub, from the dataset. Non-fatal: a partial setup that still reaches +# the tests yields a real verdict, which is more informative than an unexplained infra error. +set +e +{pre} + +{apply_patch} +{apply_f2p_patch} +{install_f2p_script} + +echo "{TEST_OUTPUT_BEGIN}" +python -m pytest -rA --tb=no -p no:cacheprovider {pytest_targets} +__test_exit=$? +echo "{TEST_OUTPUT_END}" +exit $__test_exit +""" + + +def slice_test_output(log: str) -> str: + start = log.find(TEST_OUTPUT_BEGIN) + if start == -1: + return log + start += len(TEST_OUTPUT_BEGIN) + end = log.find(TEST_OUTPUT_END, start) + return log[start:end] if end != -1 else log[start:] + + +def grade(statuses: dict[str, str], fail_to_pass: Iterable[str], pass_to_pass: Iterable[str]) -> dict[str, Any]: + """Resolved only when every required test is observed AND passing. + + A test absent from the output counts as not passing: treating "absent" as success is how a + test command that never ran scores as a resolved instance. + """ + + def split(names: Iterable[str]) -> tuple[list[str], list[str]]: + passed, failed = [], [] + for name in names: + (passed if statuses.get(name) == PASSED else failed).append(name) + return passed, failed + + f2p_passed, f2p_failed = split(fail_to_pass) + p2p_passed, p2p_failed = split(pass_to_pass) + return { + "FAIL_TO_PASS": {"success": f2p_passed, "failure": f2p_failed}, + "PASS_TO_PASS": {"success": p2p_passed, "failure": p2p_failed}, + "tests_observed": len(statuses), + "resolved": not f2p_failed and not p2p_failed, + } + + +def verification_files(inputs: VerificationInputs) -> dict[str, str]: + """Files the sandbox is created with; see build_eval_script for why they live in /tmp.""" + files = {"/tmp/nemo_gym_eval.sh": build_eval_script(inputs)} + if inputs.patch.strip(): + files["/tmp/nemo_gym_patch.diff"] = inputs.patch + if inputs.f2p_patch.strip(): + files["/tmp/nemo_gym_f2p.diff"] = inputs.f2p_patch + if inputs.f2p_script.strip(): + files["/tmp/nemo_gym_f2p_script.py"] = inputs.f2p_script + return files + + +async def run_verification( + sandbox: Any, + inputs: VerificationInputs, + timeout_s: float | None = None, + log_dir: Path | None = None, +) -> VerificationResult: + """Run the eval script in a sandbox already seeded with ``verification_files``.""" + result = await sandbox.exec("bash /tmp/nemo_gym_eval.sh", timeout_s=timeout_s) + output = (result.stdout or "") + (("\n" + result.stderr) if result.stderr else "") + + if log_dir is not None: + # Off the loop: a shared-filesystem write per task stalls every concurrent verification. + def _persist() -> None: + try: + log_dir.mkdir(parents=True, exist_ok=True) + (log_dir / "test_output.log").write_text(output, errors="replace") + except OSError: + pass + + await asyncio.to_thread(_persist) + + if result.return_code == 97: + return VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output=output, + error=f"workdir {inputs.workdir} not present in the image", + ) + + target_ids = list(inputs.fail_to_pass) + list(inputs.pass_to_pass) + statuses = await asyncio.to_thread(extract_statuses, slice_test_output(output), target_ids) + report = grade(statuses, inputs.fail_to_pass, inputs.pass_to_pass) + return VerificationResult( + completed=True, + resolved=bool(report["resolved"]), + patch_applied=True, + test_results=report, + test_output=output, + ) diff --git a/resources_servers/swe_rebench/.gitignore b/resources_servers/swe_rebench/.gitignore new file mode 100644 index 00000000000..c39f6d3d27c --- /dev/null +++ b/resources_servers/swe_rebench/.gitignore @@ -0,0 +1,2 @@ +# This is where verification logs are stored locally +logs diff --git a/resources_servers/swe_rebench/README.md b/resources_servers/swe_rebench/README.md new file mode 100644 index 00000000000..ffa2e5b0833 --- /dev/null +++ b/resources_servers/swe_rebench/README.md @@ -0,0 +1,81 @@ +# SWE-rebench-V2 resources server + +Verification for [nebius/SWE-rebench-V2](https://huggingface.co/datasets/nebius/SWE-rebench-V2): +32,079 software-engineering tasks across 20 languages. + +Unlike the SWE-bench servers, there is no image repository or per-language configuration here. +Every row ships its own prebuilt image (`docker.io/swerebenchv2/...`), the commands to install +and to test it, and the name of the upstream parser for its test log. Verification therefore +reduces to: start the row's image, apply the patches, run the row's test command, parse, grade. + +Sandboxes come from `nemo_gym.sandbox`, so the same server runs on OpenSandbox or any other +configured provider. + +## Grading + +An instance resolves only when **every** `FAIL_TO_PASS` and `PASS_TO_PASS` test is observed and +passing. A test that is missing from the parsed output counts as not passing — treating absent +as success is the standard way a broken test command scores as a resolved instance. + +Test names are normalised to strip per-run timings (`[123 ms]`, `(1.5 s)`, `in 2.0 sec`) before +comparison, matching the existing `swe_agents` SWE-rebench grader so the two agree. + +The graded region of the log is delimited by markers, so install-time noise never reaches the +parser. Several parsers are line-oriented and would otherwise read dependency-resolver output +as test results. + +## Log parsers + +The dataset names one of 34 upstream parsers per row. Rather than reimplement that set, the +MIT-licensed `log_parsers.py` from +[SWE-rebench/SWE-rebench-V2](https://github.com/SWE-rebench/SWE-rebench-V2) is fetched on first +use and called directly; see `log_parsers.py`. An unknown parser name is an error, never a +fallback: a wrong parser returns an empty result, which grades as "nothing passed" and is +indistinguishable from a real failure. + +## Prepare the data + +```bash +# The whole set, or a subset: +SWE_REBENCH_LANGUAGES=python,go SWE_REBENCH_LIMIT=200 \ + python benchmarks/swe_rebench/prepare.py +``` + +## Golden-patch validation + +Grades each task with the dataset's own patch, which measures the dataset rather than a model. +A row whose golden patch does not resolve cannot be used for evaluation or training. + +```bash +gym env start \ + --config resources_servers/swe_rebench/configs/swe_rebench.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml + +python resources_servers/swe_rebench/apply_golden_patch.py \ + +benchmark_jsonl=benchmarks/swe_rebench/data/swe_rebench_benchmark.jsonl \ + +limit=40 +concurrency=8 +``` + +It prints a resolved rate overall and per language, and writes one row per task. + +On a Slurm cluster where OpenSandbox is only reachable from inside, use +`temp_launch_swe_rebench_golden_patch.sh`, which runs the same thing on the **cpu** partition — +the workload needs no GPU, since the containers run remotely. + +`aggregate_golden_patch.py` joins repeated golden-patch passes (e.g. a 3x sweep) into +supported / flaky / broken / inconclusive buckets, keeping an infra fault (no verdict) separate +from a genuinely nondeterministic test so neither silently corrupts the other's label. +`data/supported_instance_ids.txt` is the result of one such sweep over the full set: 22,684 of +32,079 instances whose golden patch resolved in all three passes -- a separate +artifact for training use, not consumed by `prepare.py` or the eval benchmark. The other 9,395 +are excluded from that list because none can be scored either way: 6,813 never resolve +(concentrated in the compiled-language rows -- java, kotlin, scala, cpp), 2,376 resolve +inconsistently across passes (flaky tests), and 206 never produced a verdict in any pass (image +pull / setup failures, not row failures -- see `diagnose_failures.py`). + +## Running an agent + +`benchmarks/swe_rebench/opencode.yaml` wires this server to the opencode sandboxed agent, in the +same shape as the swebench verified/pro/multilingual benchmarks. + +Upstream SWE-rebench code is MIT licensed. This adapter is Apache-2.0. diff --git a/resources_servers/swe_rebench/__init__.py b/resources_servers/swe_rebench/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/swe_rebench/aggregate_golden_patch.py b/resources_servers/swe_rebench/aggregate_golden_patch.py new file mode 100644 index 00000000000..7ae7eac45e4 --- /dev/null +++ b/resources_servers/swe_rebench/aggregate_golden_patch.py @@ -0,0 +1,136 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Join repeated golden-patch passes into the set of rows that are actually usable. + +A row is SUPPORTED when its golden patch resolved in every pass. That is the point of +repeating: a row that resolves only sometimes has a nondeterministic test, and its reward is +noise whether it is used for evaluation or for training. + +The one distinction that matters, and the reason this is not a single boolean: a pass can fail +to produce a verdict at all (image pull, timeout, provider fault). That is evidence about the +infrastructure, not about the row. Collapsing the two would discard good tasks for an unrelated +hiccup, so incomplete passes are counted separately and those rows are reported as needing more +evidence rather than as broken. + + python resources_servers/swe_rebench/aggregate_golden_patch.py \ + +runs=results/swe_rebench_golden_patch_full \ + +output_jsonl=results/swe_rebench_supported.jsonl +""" + +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + +from nemo_gym.global_config import get_global_config_dict + + +def _rows(path: Path): + with path.open(encoding="utf-8") as handle: + for line in handle: + line = line.strip() + if line: + try: + yield json.loads(line) + except json.JSONDecodeError: + continue + + +def classify(observations: list[dict[str, Any]], expected_passes: int) -> str: + """Bucket one row from its per-pass observations.""" + completed = [o for o in observations if o.get("evaluation_completed")] + resolved = sum(1 for o in completed if o.get("resolved")) + + if len(completed) < expected_passes: + # Not enough verdicts to judge the row. Distinguished from a genuine failure so an + # image-pull fault does not quietly delete a usable task. + return "inconclusive" + if resolved == len(completed): + return "supported" + if resolved == 0: + return "broken" + return "flaky" + + +def main() -> None: + config = get_global_config_dict() + runs_dir = Path(config["runs"]) + output_fpath = Path(config.get("output_jsonl") or "results/swe_rebench_supported.jsonl") + + pass_files = sorted(p for p in runs_dir.glob("*.jsonl") if p.is_file()) + if not pass_files: + raise SystemExit(f"no pass jsonl files under {runs_dir}") + + by_instance: dict[str, list[dict[str, Any]]] = defaultdict(list) + language: dict[str, str] = {} + for pass_file in pass_files: + for row in _rows(pass_file): + instance_id = row.get("instance_id") + if not instance_id or instance_id == "?": + continue + by_instance[instance_id].append(row) + if row.get("language"): + language[instance_id] = row["language"] + + expected = len(pass_files) + buckets: Counter[str] = Counter() + per_language: dict[str, Counter[str]] = defaultdict(Counter) + + output_fpath.parent.mkdir(parents=True, exist_ok=True) + with output_fpath.open("w", encoding="utf-8") as out: + for instance_id, observations in sorted(by_instance.items()): + verdict = classify(observations, expected) + buckets[verdict] += 1 + per_language[language.get(instance_id, "unknown")][verdict] += 1 + out.write( + json.dumps( + { + "instance_id": instance_id, + "language": language.get(instance_id, ""), + "verdict": verdict, + "passes_observed": len(observations), + "passes_completed": sum(1 for o in observations if o.get("evaluation_completed")), + "passes_resolved": sum(1 for o in observations if o.get("resolved")), + "expected_passes": expected, + } + ) + + "\n" + ) + + total = sum(buckets.values()) + print(f"golden-patch aggregation over {total} row(s) from {expected} pass(es)\n") + for verdict, description in ( + ("supported", "resolved in every pass - usable"), + ("flaky", "resolved in some passes only - nondeterministic test"), + ("broken", "never resolved - golden patch does not work"), + ("inconclusive", "too few verdicts - re-run before judging"), + ): + count = buckets.get(verdict, 0) + print(f" {verdict:<13} {count:>6} ({100 * count / max(total, 1):5.1f}%) {description}") + + print("\n by language (supported / total):") + for lang, counts in sorted(per_language.items(), key=lambda kv: -sum(kv[1].values())): + rows_total = sum(counts.values()) + supported = counts.get("supported", 0) + print( + f" {lang:<10} {supported:>5} / {rows_total:<6} ({100 * supported / rows_total:5.1f}%)" + f" flaky={counts.get('flaky', 0)} broken={counts.get('broken', 0)}" + f" inconclusive={counts.get('inconclusive', 0)}" + ) + print(f"\nper-row verdicts: {output_fpath}") + + +if __name__ == "__main__": + main() diff --git a/resources_servers/swe_rebench/app.py b/resources_servers/swe_rebench/app.py new file mode 100644 index 00000000000..1a397ca5d15 --- /dev/null +++ b/resources_servers/swe_rebench/app.py @@ -0,0 +1,325 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Resources server for nebius/SWE-rebench-V2. + +Each dataset row ships its own prebuilt image plus the commands to install and test it, so this +server does not build environments — it starts the row's image in a sandbox, applies patches, +runs the row's test command, and grades the output with the row's named upstream parser. + +Set ``is_verifying_golden_patch: true`` to grade the dataset's own patch instead of an agent's. +That is the dataset-health check: a row whose golden patch does not resolve is a broken row, and +scoring an agent against it is measuring noise. +""" + +import sys +from pathlib import Path +from time import time +from traceback import format_exc +from typing import Any + +from fastapi import Request +from pydantic import BaseModel, ConfigDict + +from nemo_gym.base_resources_server import ( + BaseResourcesServerConfig, + BaseSeedSessionRequest, + BaseSeedSessionResponse, + BaseVerifyRequest, + BaseVerifyResponse, + SimpleResourcesServer, +) +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.sandbox import AsyncSandbox, SandboxResources, SandboxSpec +from nemo_gym.sandbox.config import resolve_provider_config, resolve_provider_metadata +from nemo_gym.sandbox.utils import cpu_cap_env +from nemo_gym.server_utils import SESSION_ID_KEY, is_nemo_gym_fastapi_entrypoint +from resources_servers.swe_rebench.log_parsers import default_cache_dir, resolve_parser +from resources_servers.swe_rebench.verification import ( + VerificationInputs, + VerificationResult, + as_command_list, + repo_directory, + run_verification, + verification_files, +) + + +# Gradle only auto-loads init scripts from $GRADLE_USER_HOME/init.d, so the mirror script +# shipped by verification._mirror_files() is invisible unless this points at the same home. +# Maven needs no equivalent: it reads ~/.m2/settings.xml by default. +# +# An earlier attempt set -Djava.net.preferIPv6Addresses=false here on the theory that the JVM +# was misrouting over IPv6. It changed nothing -- the failures were identical -- so the cause is +# Maven Central being unreachable from this network rather than an IP-version problem. Removed +# rather than left in place, since an ineffective workaround invites the same dead end later. +JVM_MIRROR_ENV = { + "GRADLE_USER_HOME": "/root/.gradle", +} + + +class SWERebenchResourcesServerConfig(BaseResourcesServerConfig): + is_verifying_golden_patch: bool = False + evaluation_timeout: int | None = 3600 + # A verdict-less run is retried on a fresh sandbox: an image pull or a flaky provider start + # is not evidence about the patch. + inconclusive_verification_retries: int = 1 + # Where the upstream log-parser repo is cloned. Empty uses the shared nemo_gym cache. + log_parser_cache_dir: str = "" + sandbox_provider: str + sandbox_config: dict[str, Any] + + +class SWERebenchInstanceRequest(BaseModel): + """One row of nebius/SWE-rebench-V2.""" + + model_config = ConfigDict(extra="allow") + + instance_id: str + repo: str + base_commit: str + patch: str = "" + test_patch: str = "" + problem_statement: str = "" + language: str = "" + image_name: str + install_config: dict[str, Any] = {} + # Upstream spells these in caps; keep the dataset's own names so a row round-trips unchanged. + FAIL_TO_PASS: list[str] = [] + PASS_TO_PASS: list[str] = [] + + +class SWERebenchSeedSessionRequest(SWERebenchInstanceRequest, BaseSeedSessionRequest): + sandbox_spec: dict[str, Any] | None = None + + +class SWERebenchSeedSessionResponse(BaseSeedSessionResponse): + sandbox_handle: str + + +class SWERebenchVerifyRequest(SWERebenchInstanceRequest, BaseVerifyRequest): + pass + + +class SWERebenchVerifyResponse(BaseVerifyResponse): + evaluation_completed: bool + resolved: bool + patch_applied: bool + instance_id: str + language: str + test_results: dict[str, Any] | None + test_output: str + error: str | None + eval_sandbox_start_time_taken: float + patch_verification_time_taken: float + + +class SWERebenchResourcesServer(SimpleResourcesServer): + config: SWERebenchResourcesServerConfig + + def model_post_init(self, context: Any, /) -> None: + super().model_post_init(context) + self._session_id_to_sandbox: dict[str, AsyncSandbox] = {} + + @property + def _parser_cache_dir(self) -> Path: + return Path(self.config.log_parser_cache_dir) if self.config.log_parser_cache_dir else default_cache_dir() + + def _inputs(self, body: SWERebenchInstanceRequest, patch: str) -> VerificationInputs: + install_config = body.install_config or {} + return VerificationInputs( + instance_id=body.instance_id, + repo=body.repo, + base_commit=body.base_commit, + patch=patch, + test_patch=body.test_patch, + install=as_command_list(install_config.get("install")), + test_cmd=as_command_list(install_config.get("test_cmd")), + log_parser=str(install_config.get("log_parser") or ""), + fail_to_pass=list(body.FAIL_TO_PASS or []), + pass_to_pass=list(body.PASS_TO_PASS or []), + ) + + async def _create_sandbox( + self, body: SWERebenchInstanceRequest, files: dict[str, str] | None = None + ) -> AsyncSandbox: + global_config_dict = get_global_config_dict() + provider_config = resolve_provider_config(self.config.sandbox_provider, global_config_dict) + provider_metadata = resolve_provider_metadata(self.config.sandbox_provider, global_config_dict) + + # Cap build/test parallelism to the CPU limit. A container sees the HOST core count (96 + # here), so `make -j$(nproc)`, cargo, gradle and `go test` fan out ~96 workers against a + # 4-CPU quota and spend most of their time CFS-throttled. This matters more for this set + # than any other: it is the compile-heaviest, with 6144 Go, 3123 Rust, 1716 Java, 411 + # Scala and 182 C++ rows. Explicit sandbox_config.env keys still win. + sandbox_resources = SandboxResources.from_mapping(self.config.sandbox_config.get("resources", {})) + env = dict(self.config.sandbox_config.get("env", {})) + if self.config.sandbox_config.get("derive_cpu_env", True): + env = cpu_cap_env(sandbox_resources.cpu) | env + if self.config.sandbox_config.get("use_maven_mirror", True): + # See verification._mirror_files(): Maven Central is unreachable from this network + # while other registries are, so both build tools are pointed at the Google mirror. + env = JVM_MIRROR_ENV | env + + spec = SandboxSpec( + # The row names its own image; there is no repository template to apply. + image=body.image_name, + ttl_s=self.config.sandbox_config.get("ttl_s"), + ready_timeout_s=self.config.sandbox_config.get("ready_timeout_s"), + workdir=repo_directory(body.repo), + env=env, + files=files or {}, + metadata=provider_metadata + | self.config.sandbox_config.get("metadata", {}) + | { + "nemo_gym_agent": self.config.name, + "instance_id": body.instance_id[:63], + "language": body.language[:63], + }, + resources=sandbox_resources, + provider_options=self.config.sandbox_config.get("provider_options", {}), + ) + sandbox = AsyncSandbox(provider_config) + await sandbox.start(spec) + return sandbox + + async def _stop_sandbox(self, sandbox: AsyncSandbox | None) -> None: + if sandbox is None: + return + try: + await sandbox.stop() + except Exception: + print("Failed to stop SWE-rebench sandbox", format_exc(), file=sys.stderr) + + async def seed_session( + self, request: Request, body: SWERebenchSeedSessionRequest + ) -> SWERebenchSeedSessionResponse: + """Start the instance's image so an agent can work in it.""" + session_id = request.session[SESSION_ID_KEY] + await self._stop_sandbox(self._session_id_to_sandbox.pop(session_id, None)) + sandbox = await self._create_sandbox(body) + self._session_id_to_sandbox[session_id] = sandbox + return SWERebenchSeedSessionResponse(sandbox_handle=str(sandbox.sandbox_id)) + + async def verify(self, request: Request, body: SWERebenchVerifyRequest) -> SWERebenchVerifyResponse: + if self.config.is_verifying_golden_patch: + patch = body.patch + else: + patch = str(getattr(body, "model_patch", "") or "") + + inputs = self._inputs(body, patch) + log_dir = Path(__file__).parent / "logs" / body.instance_id + + # Resolve the parser before spending a sandbox on the run: an unknown parser name means + # this row can never be graded, and finding that out after the tests have run wastes the + # most expensive part. + try: + parser = resolve_parser(inputs.log_parser, self._parser_cache_dir) + except Exception as exc: + # Spread the request: BaseVerifyResponse extends BaseVerifyRequest, so + # responses_create_params and response are required and must be echoed back. + return SWERebenchVerifyResponse.model_validate( + body.model_dump() + | { + "reward": 0.0, + "evaluation_completed": False, + "resolved": False, + "patch_applied": False, + "instance_id": body.instance_id, + "language": body.language, + "test_results": None, + "test_output": "", + "error": f"{exc}", + "eval_sandbox_start_time_taken": 0.0, + "patch_verification_time_taken": 0.0, + } + ) + + files = verification_files(inputs) + attempts = 1 + max(self.config.inconclusive_verification_retries, 0) + start_time_taken = 0.0 + verification_time_taken = 0.0 + result = VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output="", + error="unattempted", + ) + for attempt in range(1, attempts + 1): + sandbox: AsyncSandbox | None = None + started = time() + try: + sandbox = await self._create_sandbox(body, files=files) + start_time_taken = time() - started + verification_started = time() + result = await run_verification( + sandbox=sandbox, + inputs=inputs, + parser=parser, + timeout_s=self.config.evaluation_timeout, + log_dir=log_dir, + ) + verification_time_taken = time() - verification_started + except Exception as exc: + start_time_taken = time() - started + verification_time_taken = 0.0 + result = VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output="", + error=f"Verification failed: {exc}", + ) + finally: + await self._stop_sandbox(sandbox) + if result.completed: + break + if attempt < attempts: + print( + f"[swe_rebench] {body.instance_id}: inconclusive ({result.error}); " + f"retrying on a fresh sandbox ({attempt}/{attempts - 1})", + flush=True, + ) + + return SWERebenchVerifyResponse.model_validate( + body.model_dump() + | { + # An unresolved-but-completed run is a real 0. An incomplete run is also 0, but + # evaluation_completed distinguishes them so a broken row is not read as a hard task. + "reward": 1.0 if result.resolved else 0.0, + "evaluation_completed": result.completed, + "resolved": result.resolved, + "patch_applied": result.patch_applied, + "instance_id": body.instance_id, + "language": body.language, + "test_results": result.test_results, + "test_output": result.test_output[-100_000:], + "error": result.error, + "eval_sandbox_start_time_taken": start_time_taken, + "patch_verification_time_taken": verification_time_taken, + } + ) + + +if __name__ == "__main__": + SWERebenchResourcesServer.run_webserver() +elif is_nemo_gym_fastapi_entrypoint(__file__): + # Required whenever num_workers > 1. Multi-worker uvicorn re-imports this entrypoint BY PATH + # in each forked child and expects a module-level `app`; without it every child exits, and + # uvicorn responds by stopping the parent. The server then never binds, so the symptom is not + # an import error but a flood of connection failures from clients talking to a dead port. + app = SWERebenchResourcesServer.run_webserver() # noqa: F401 diff --git a/resources_servers/swe_rebench/apply_golden_patch.py b/resources_servers/swe_rebench/apply_golden_patch.py new file mode 100644 index 00000000000..ffd44f18a46 --- /dev/null +++ b/resources_servers/swe_rebench/apply_golden_patch.py @@ -0,0 +1,165 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Grade every task with the dataset's own golden patch. + +This measures the dataset, not a model. A row whose golden patch does not make FAIL_TO_PASS +pass is unusable for evaluation or training, so this is the check to run before trusting any +score from SWE-rebench-V2. + + gym env start --config resources_servers/swe_rebench/configs/swe_rebench.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml + + python resources_servers/swe_rebench/apply_golden_patch.py \ + +benchmark_jsonl=benchmarks/swe_rebench/data/swe_rebench_benchmark.jsonl \ + +output_jsonl=results/swe_rebench_golden_patch.jsonl \ + +concurrency=32 +limit=100 +""" + +import asyncio +import json +from collections import Counter +from pathlib import Path + +from tqdm.auto import tqdm + +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.server_utils import ServerClient + + +EMPTY_RESPONSE = { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], +} + +SERVER_NAME = "swe_rebench_golden_patch_resources_server" + + +def _stream_examples(path: Path, limit: int): + """Yield rows lazily. + + The full set is 2.4 GB on disk and ~6.1 GB once parsed into dicts. Materialising it just to + feed a bounded worker pool wastes that memory for the whole run, and the peak lands hours in + when results have also accumulated. + """ + with open(path, encoding="utf-8") as benchmark: + for index, line in enumerate(benchmark): + if limit and index >= limit: + return + line = line.strip() + if line: + yield json.loads(line) + + +async def main() -> None: + config = get_global_config_dict() + limit = int(config.get("limit") or 0) + concurrency = int(config.get("concurrency") or 16) + benchmark_fpath = Path(config["benchmark_jsonl"]) + output_fpath = Path(config.get("output_jsonl") or "results/swe_rebench_golden_patch.jsonl") + + total = sum(1 for _ in _stream_examples(benchmark_fpath, limit)) + client = ServerClient.load_from_global_config() + + # Bounded: the queue holds at most one row per worker, so resident rows track concurrency + # rather than dataset size. + queue: asyncio.Queue = asyncio.Queue(maxsize=concurrency) + resolved = 0 + incomplete = 0 + by_language: Counter[str] = Counter() + resolved_by_language: Counter[str] = Counter() + finished = 0 + + output_fpath.parent.mkdir(parents=True, exist_ok=True) + progress = tqdm(total=total, desc="golden patch") + + with output_fpath.open("w", encoding="utf-8") as output: + + async def worker() -> None: + nonlocal resolved, incomplete, finished + while True: + example = await queue.get() + if example is None: + queue.task_done() + return + try: + payload = example | {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} + try: + response = await client.post(server_name=SERVER_NAME, url_path="/verify", json=payload) + result = await response.json() + except Exception as exc: + # One unreachable task must not abandon the sweep; record it and carry on. + result = { + "instance_id": example.get("instance_id", "?"), + "language": example.get("language", ""), + "resolved": False, + "evaluation_completed": False, + "error": f"request failed: {exc}", + } + if not isinstance(result, dict): + # Gym middleware returns repr(exc) as a bare JSON string when a handler + # raises, so a server-side fault arrives as a str. + result = { + "instance_id": example.get("instance_id", "?"), + "language": example.get("language", ""), + "resolved": False, + "evaluation_completed": False, + "error": f"server returned a non-object response: {str(result)[:300]}", + } + + language = str(result.get("language") or example.get("language") or "unknown") + by_language[language] += 1 + if result.get("resolved"): + resolved += 1 + resolved_by_language[language] += 1 + if not result.get("evaluation_completed", False): + incomplete += 1 + output.write(json.dumps(result) + "\n") + finished += 1 + if finished % 50 == 0: + output.flush() # a multi-hour run must leave usable rows if it is cut short + progress.update(1) + progress.set_description( + f"resolved {resolved}/{finished} ({100 * resolved / max(finished, 1):.1f}%) " + f"incomplete={incomplete}" + ) + finally: + queue.task_done() + + workers = [asyncio.create_task(worker()) for _ in range(concurrency)] + for example in _stream_examples(benchmark_fpath, limit): + await queue.put(example) + for _ in workers: + await queue.put(None) + await asyncio.gather(*workers) + + progress.close() + print(f"\ngolden-patch validation over {total} task(s)") + print(f" resolved: {resolved}/{total} ({100 * resolved / max(total, 1):.1f}%)") + print(f" incomplete: {incomplete}/{total} (no verdict: image, timeout or parser failure)") + print("\n by language (resolved / total):") + for language, count in by_language.most_common(): + got = resolved_by_language[language] + print(f" {language:<10} {got:>5} / {count:<6} ({100 * got / count:5.1f}%)") + print(f"\nper-task rows: {output_fpath}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/resources_servers/swe_rebench/client.py b/resources_servers/swe_rebench/client.py new file mode 100644 index 00000000000..39c7b10224f --- /dev/null +++ b/resources_servers/swe_rebench/client.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Verify a single SWE-rebench row, for a quick smoke test of the server.""" + +import asyncio +import json + +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.server_utils import ServerClient + + +EMPTY_RESPONSE = { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], +} + + +async def main() -> None: + config = get_global_config_dict() + with open(config["benchmark_jsonl"], encoding="utf-8") as benchmark: + example = json.loads(next(benchmark)) + example |= {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} + + client = ServerClient.load_from_global_config() + result = await client.post( + server_name=config.get("resources_server_name", "swe_rebench_golden_patch_resources_server"), + url_path="/verify", + json=example, + ) + print(json.dumps(await result.json(), indent=4)) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/resources_servers/swe_rebench/configs/swe_rebench.yaml b/resources_servers/swe_rebench/configs/swe_rebench.yaml new file mode 100644 index 00000000000..3a8ce39f534 --- /dev/null +++ b/resources_servers/swe_rebench/configs/swe_rebench.yaml @@ -0,0 +1,79 @@ +# Resources server for nebius/SWE-rebench-V2. +# +# Every row carries its own prebuilt image (docker.io/swerebenchv2/...), its install and test +# commands, and the name of the upstream parser for its test log — so there is no image +# repository or per-language configuration here. 32,079 rows across 20 languages. +swe_rebench_resources_server: + resources_servers: + swe_rebench: + allowed_agents: [opencode_sandboxed_agent] + entrypoint: app.py + domain: coding + verified: false + + evaluation_timeout: 3600 + is_verifying_golden_patch: false + + sandbox_provider: sandbox + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + # Limits are the BURST ceiling; requests are the guaranteed floor. cpu_cap_env sizes + # build tools to the limit, so a wider limit means faster compiles when a node has room. + resources: + # Wider than SWE-bench Verified: the set spans Go, Rust, Java, Scala and C++ builds, + # which are compile-bound where the Python rows are not. + cpu: 8 + memory_mib: 30720 + disk_gib: 30 + provider_options: + # Requests well below limits so pods bin-pack on a loaded cluster. At the concurrency + # a full-set sweep needs, requests == limits would reserve the cluster up front. + # + # 1 full vCPU, not less: measured elsewhere on this infra, a 0.25 request left 22% of + # rollouts (228/1022) hitting their timeout outright from CPU starvation under + # contention. CPU is compressible so bursting is safe; memory is not, hence a 4 GiB + # floor with headroom to 30 GiB for the JVM and Go/Rust link steps. + resource_requests: + cpu: 1 + memory_mib: 4096 + disk_gib: 30 + metadata: + benchmark: swe-rebench-v2 + +# Golden-patch validation: grade the dataset's own patch instead of an agent's. A row whose +# golden patch does not resolve is a broken row, and scoring an agent against it measures noise. +# Run it with resources_servers/swe_rebench/apply_golden_patch.py. +swe_rebench_golden_patch_resources_server: + resources_servers: + swe_rebench: + entrypoint: app.py + domain: coding + verified: false + + # 20 minutes: the pilot averaged ~6 min/task with nothing near the old 60-minute ceiling, + # so this caps the tail without truncating honest work. + evaluation_timeout: 1200 + is_verifying_golden_patch: true + + # A full-set sweep runs ~2000 verifications concurrently against this one server. Each is + # mostly awaiting a remote sandbox, but the per-task log parse and result encode are real + # CPU, and one event loop cannot absorb 2000 of them. Spreading across workers keeps the + # accept queue short; the file-based parser cache is shared, so each worker loads it once. + num_workers: 8 + + sandbox_provider: sandbox + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + resources: + cpu: 8 + memory_mib: 30720 + disk_gib: 30 + provider_options: + resource_requests: + cpu: 1 + memory_mib: 4096 + disk_gib: 30 + metadata: + benchmark: swe-rebench-v2-golden-patch diff --git a/resources_servers/swe_rebench/data/supported_instance_ids.txt b/resources_servers/swe_rebench/data/supported_instance_ids.txt new file mode 100644 index 00000000000..dd771a02ce4 --- /dev/null +++ b/resources_servers/swe_rebench/data/supported_instance_ids.txt @@ -0,0 +1,22684 @@ +0xpolygonhermez__zkevm-node-1044 +0xpolygonhermez__zkevm-node-1127 +0xpolygonhermez__zkevm-node-1312 +0xpolygonhermez__zkevm-node-1321 +0xpolygonhermez__zkevm-node-1326 +0xpolygonhermez__zkevm-node-1329 +0xpolygonhermez__zkevm-node-1336 +0xpolygonhermez__zkevm-node-1399 +0xpolygonhermez__zkevm-node-3782 +0xpolygonhermez__zkevm-node-983 +0xpolygonhermez__zkevm-node-987 +0xs34n__starknet.js-490 +0xs34n__starknet.js-495 +0xs34n__starknet.js-496 +0xs34n__starknet.js-508 +0xs34n__starknet.js-520 +0xs34n__starknet.js-538 +100phlecs__tailwind_formatter-19 +100phlecs__tailwind_formatter-22 +100phlecs__tailwind_formatter-33 +100phlecs__tailwind_formatter-64 +11ty__eleventy-120 +11ty__eleventy-1749 +11ty__eleventy-1876 +11ty__eleventy-200 +11ty__eleventy-2111 +11ty__eleventy-226 +11ty__eleventy-2358 +11ty__eleventy-2468 +11ty__eleventy-3120 +11ty__eleventy-3430 +11ty__eleventy-735 +11ty__eleventy-798 +11ty__eleventy-821 +11ty__eleventy-827 +1password__typeshare-109 +1password__typeshare-119 +1password__typeshare-122 +1password__typeshare-128 +1password__typeshare-131 +1password__typeshare-134 +1password__typeshare-242 +1password__typeshare-39 +1password__typeshare-51 +1password__typeshare-61 +1password__typeshare-82 +1password__typeshare-95 +1password__typeshare-97 +33cn__plugin-599 +33cn__plugin-813 +3hren__msgpack-rust-218 +3hren__msgpack-rust-267 +3hren__msgpack-rust-282 +3yourmind__django-migration-linter-113 +3yourmind__django-migration-linter-186 +3yourmind__django-migration-linter-222 +3yourmind__django-migration-linter-258 +3yourmind__django-migration-linter-300 +8398a7__action-slack-111 +8398a7__action-slack-120 +8398a7__action-slack-131 +8398a7__action-slack-184 +8398a7__action-slack-61 +8398a7__action-slack-83 +8398a7__action-slack-89 +8398a7__action-slack-98 +99designs__aws-vault-1178 +99designs__aws-vault-1196 +99designs__aws-vault-440 +99designs__aws-vault-657 +99designs__aws-vault-662 +99designs__aws-vault-685 +99designs__gqlgen-1725 +99designs__gqlgen-3276 +a-h__templ-1026 +a-h__templ-1028 +a-h__templ-1107 +a-h__templ-1111 +a-h__templ-1139 +a-h__templ-1159 +a-h__templ-871 +a-h__templ-887 +aaugustin__websockets-374 +aaugustin__websockets-413 +aaugustin__websockets-467 +aaugustin__websockets-483 +aaugustin__websockets-543 +aaugustin__websockets-568 +aaugustin__websockets-627 +aaugustin__websockets-629 +aaugustin__websockets-641 +aaugustin__websockets-675 +aaugustin__websockets-981 +aaugustin__websockets-983 +aave__aave-v3-core-743 +aave__aave-v3-core-745 +aave__aave-v3-core-747 +aave__aave-v3-core-773 +aave__aave-v3-core-831 +abahmed__kwatch-189 +abahmed__kwatch-205 +abahmed__kwatch-270 +abhinav__doc2go-211 +abhinavsingh__proxy.py-321 +abice__go-enum-105 +abice__go-enum-230 +ably__ably-go-433 +ably__ably-go-481 +ably__ably-go-549 +ably__ably-go-614 +ably__ably-go-629 +ably__ably-python-407 +ably__ably-python-421 +ably__ably-python-429 +ably__ably-python-457 +ably__ably-python-465 +ably__ably-python-474 +ably__ably-python-482 +ably__ably-python-500 +abridoux__scout-255 +abs-lang__abs-325 +absinthe-graphql__absinthe-1005 +absinthe-graphql__absinthe-1015 +absinthe-graphql__absinthe-1131 +absinthe-graphql__absinthe-1155 +absinthe-graphql__absinthe-1158 +absinthe-graphql__absinthe-1195 +absinthe-graphql__absinthe-1211 +absinthe-graphql__absinthe-1291 +absinthe-graphql__absinthe-1334 +absinthe-graphql__absinthe-1336 +absinthe-graphql__absinthe-738 +absinthe-graphql__absinthe-797 +absinthe-graphql__absinthe-816 +absinthe-graphql__absinthe-822 +absinthe-graphql__absinthe-848 +absinthe-graphql__absinthe-858 +absinthe-graphql__absinthe-865 +absinthe-graphql__absinthe-878 +absinthe-graphql__absinthe-910 +absinthe-graphql__absinthe-944 +absinthe-graphql__absinthe-998 +absinthe-graphql__absinthe_plug-243 +absinthe-graphql__absinthe_plug-249 +absmach__magistrala-176 +abuiles__ember-watson-27 +abuiles__ember-watson-49 +abuiles__ember-watson-53 +abuiles__ember-watson-61 +academysoftwarefoundation__opentimelineio-1862 +academysoftwarefoundation__rez-1863 +acloudguru__serverless-plugin-aws-alerts-124 +acloudguru__serverless-plugin-aws-alerts-13 +acloudguru__serverless-plugin-aws-alerts-149 +acloudguru__serverless-plugin-aws-alerts-16 +acloudguru__serverless-plugin-aws-alerts-164 +acloudguru__serverless-plugin-aws-alerts-84 +acloudguru__serverless-plugin-aws-alerts-87 +act-rules__act-rules.github.io-1277 +act-rules__act-rules.github.io-1351 +act-rules__act-rules.github.io-1423 +act-rules__act-rules.github.io-1648 +act-rules__act-rules.github.io-1738 +act-rules__act-rules.github.io-1744 +act-rules__act-rules.github.io-2121 +actions__stale-220 +actions__stale-268 +actions__stale-269 +actions__stale-304 +actions__stale-334 +actions__stale-519 +actions__stale-816 +actions__toolkit-257 +actix__actix-web-2538 +actix__actix-web-2624 +actix__actix-web-3119 +adamchainz__flake8-comprehensions-143 +adamchainz__flake8-comprehensions-179 +adamchainz__flake8-comprehensions-195 +adamchainz__flake8-comprehensions-197 +adamchainz__flake8-comprehensions-200 +adamchainz__flake8-comprehensions-205 +adamchainz__flake8-comprehensions-553 +adamgibbons__ics-142 +adamgibbons__ics-143 +adamgibbons__ics-264 +adhocore__gronx-52 +adhocore__gronx-54 +adhocore__gronx-7 +adnanh__webhook-449 +adnanh__webhook-460 +adnanh__webhook-461 +adnanh__webhook-472 +adnanh__webhook-479 +adnanh__webhook-484 +adnanh__webhook-485 +adnanh__webhook-486 +adobe__elixir-styler-108 +adobe__elixir-styler-121 +adobe__elixir-styler-153 +adobe__elixir-styler-155 +adobe__elixir-styler-16 +adobe__elixir-styler-168 +adobe__elixir-styler-197 +adobe__elixir-styler-198 +adobe__elixir-styler-203 +adobe__elixir-styler-205 +adobe__elixir-styler-207 +adobe__elixir-styler-220 +adobe__elixir-styler-25 +adobe__elixir-styler-58 +adobe__elixir-styler-61 +adobe__elixir-styler-70 +adobe__elixir-styler-85 +adobe__elixir-styler-93 +adobe__elixir-styler-96 +adobe__elixir-styler-97 +aeon-toolkit__aeon-1609 +aeon-toolkit__aeon-1610 +aeon-toolkit__aeon-1624 +aeon-toolkit__aeon-1767 +aeon-toolkit__aeon-2029 +aeon-toolkit__aeon-2052 +aeon-toolkit__aeon-2164 +aeon-toolkit__aeon-2565 +aeon-toolkit__aeon-2647 +aeon-toolkit__aeon-2659 +aeon-toolkit__aeon-2668 +aeon-toolkit__aeon-2729 +aeon-toolkit__aeon-2822 +aeon-toolkit__aeon-2927 +aeon-toolkit__aeon-487 +aeon-toolkit__aeon-541 +aeon-toolkit__aeon-808 +aeye-lab__pymovements-1029 +aeye-lab__pymovements-1030 +aeye-lab__pymovements-1106 +aeye-lab__pymovements-1108 +aeye-lab__pymovements-1112 +aeye-lab__pymovements-1154 +aeye-lab__pymovements-225 +aeye-lab__pymovements-408 +aeye-lab__pymovements-486 +aeye-lab__pymovements-542 +aeye-lab__pymovements-614 +aeye-lab__pymovements-767 +aeye-lab__pymovements-786 +aeye-lab__pymovements-884 +aeye-lab__pymovements-959 +aeye-lab__pymovements-964 +aftership__clickhouse-sql-parser-114 +aftership__clickhouse-sql-parser-119 +aftership__clickhouse-sql-parser-123 +aftership__clickhouse-sql-parser-128 +aftership__clickhouse-sql-parser-130 +aftership__clickhouse-sql-parser-132 +aftership__clickhouse-sql-parser-136 +aftership__clickhouse-sql-parser-147 +aftership__clickhouse-sql-parser-148 +aftership__clickhouse-sql-parser-150 +aftership__clickhouse-sql-parser-158 +aftership__clickhouse-sql-parser-164 +aftership__clickhouse-sql-parser-175 +agnesoft__agdb-605 +agnostiqhq__covalent-1251 +agnostiqhq__covalent-1287 +agnostiqhq__covalent-1326 +agnostiqhq__covalent-1332 +agnostiqhq__covalent-1356 +agnostiqhq__covalent-1377 +agnostiqhq__covalent-1392 +agnostiqhq__covalent-1395 +agnostiqhq__covalent-1460 +agnostiqhq__covalent-1493 +agnostiqhq__covalent-1508 +agnostiqhq__covalent-1554 +agnostiqhq__covalent-1599 +agnostiqhq__covalent-1617 +agnostiqhq__covalent-1620 +agnostiqhq__covalent-1622 +agnostiqhq__covalent-1660 +agnostiqhq__covalent-1677 +agnostiqhq__covalent-1810 +agnostiqhq__covalent-1837 +agnostiqhq__covalent-1849 +agnostiqhq__covalent-1886 +agronholm__anyio-929 +agronholm__anyio-935 +aio-libs__aiohttp-10300 +aio-libs__aiohttp-10389 +aio-libs__aiohttp-10534 +aio-libs__aiohttp-10551 +aio-libs__aiohttp-10556 +aio-libs__aiohttp-10562 +aio-libs__aiohttp-10564 +aio-libs__aiohttp-10672 +aio-libs__aiohttp-10674 +aio-libs__aiohttp-10764 +aio-libs__aiohttp-10894 +aio-libs__aiohttp-10897 +aio-libs__aiohttp-10915 +aio-libs__aiohttp-10951 +aio-libs__aiohttp-10971 +aio-libs__aiohttp-11094 +aio-libs__aiohttp-11129 +aio-libs__aiohttp-11199 +aio-libs__aiohttp-11248 +aio-libs__aiohttp-11289 +aio-libs__aiohttp-11291 +aio-libs__aiohttp-11292 +aio-libs__aiohttp-11296 +aio-libs__aiohttp-5344 +aio-libs__aiohttp-6485 +aio-libs__aiohttp-6495 +aio-libs__aiohttp-6653 +aio-libs__aiohttp-6747 +aio-libs__aiohttp-7150 +aio-libs__aiohttp-7180 +aio-libs__aiohttp-7206 +aio-libs__aiohttp-7319 +aio-libs__aiohttp-7368 +aio-libs__aiohttp-7378 +aio-libs__aiohttp-7601 +aio-libs__aiohttp-7680 +aio-libs__aiohttp-7690 +aio-libs__aiohttp-7703 +aio-libs__aiohttp-7713 +aio-libs__aiohttp-7714 +aio-libs__aiohttp-7716 +aio-libs__aiohttp-7720 +aio-libs__aiohttp-7781 +aio-libs__aiohttp-7829 +aio-libs__aiohttp-7865 +aio-libs__aiohttp-7869 +aio-libs__aiohttp-7889 +aio-libs__aiohttp-7890 +aio-libs__aiohttp-7907 +aio-libs__aiohttp-7908 +aio-libs__aiohttp-7978 +aio-libs__aiohttp-8014 +aio-libs__aiohttp-8022 +aio-libs__aiohttp-8026 +aio-libs__aiohttp-8027 +aio-libs__aiohttp-8038 +aio-libs__aiohttp-8063 +aio-libs__aiohttp-8076 +aio-libs__aiohttp-8098 +aio-libs__aiohttp-8101 +aio-libs__aiohttp-8160 +aio-libs__aiohttp-8290 +aio-libs__aiohttp-8335 +aio-libs__aiohttp-8336 +aio-libs__aiohttp-8337 +aio-libs__aiohttp-8445 +aio-libs__aiohttp-8482 +aio-libs__aiohttp-8485 +aio-libs__aiohttp-8538 +aio-libs__aiohttp-8546 +aio-libs__aiohttp-8558 +aio-libs__aiohttp-8566 +aio-libs__aiohttp-8577 +aio-libs__aiohttp-8578 +aio-libs__aiohttp-8632 +aio-libs__aiohttp-8636 +aio-libs__aiohttp-8641 +aio-libs__aiohttp-8642 +aio-libs__aiohttp-8657 +aio-libs__aiohttp-8658 +aio-libs__aiohttp-8659 +aio-libs__aiohttp-8680 +aio-libs__aiohttp-8720 +aio-libs__aiohttp-8742 +aio-libs__aiohttp-8745 +aio-libs__aiohttp-8746 +aio-libs__aiohttp-8823 +aio-libs__aiohttp-8845 +aio-libs__aiohttp-8858 +aio-libs__aiohttp-8874 +aio-libs__aiohttp-8875 +aio-libs__aiohttp-8876 +aio-libs__aiohttp-8878 +aio-libs__aiohttp-8893 +aio-libs__aiohttp-8920 +aio-libs__aiohttp-8929 +aio-libs__aiohttp-8934 +aio-libs__aiohttp-8935 +aio-libs__aiohttp-8939 +aio-libs__aiohttp-8967 +aio-libs__aiohttp-8968 +aio-libs__aiohttp-8990 +aio-libs__aiohttp-8996 +aio-libs__aiohttp-8997 +aio-libs__aiohttp-8998 +aio-libs__aiohttp-9016 +aio-libs__aiohttp-9017 +aio-libs__aiohttp-9029 +aio-libs__aiohttp-9032 +aio-libs__aiohttp-9034 +aio-libs__aiohttp-9047 +aio-libs__aiohttp-9071 +aio-libs__aiohttp-9137 +aio-libs__aiohttp-9140 +aio-libs__aiohttp-9167 +aio-libs__aiohttp-9237 +aio-libs__aiohttp-9238 +aio-libs__aiohttp-9239 +aio-libs__aiohttp-9292 +aio-libs__aiohttp-9309 +aio-libs__aiohttp-9318 +aio-libs__aiohttp-9319 +aio-libs__aiohttp-9511 +aio-libs__aiohttp-9530 +aio-libs__aiohttp-9671 +aio-libs__aiosmtpd-213 +aio-libs__aiosmtpd-225 +aio-libs__aiosmtpd-242 +aio-libs__aiosmtpd-248 +aio-libs__aiosmtpd-355 +aio-libs__multidict-100 +aio-libs__multidict-1204 +aio-libs__multidict-89 +aio-libs__multidict-94 +aiogram__aiogram-1657 +aiogram__aiogram-1665 +aiogram__aiogram-1666 +aiogram__aiogram-1670 +aiogram__aiogram-1674 +aiogram__aiogram-1686 +aiogram__aiogram-906 +airtai__faststream-1926 +airtai__faststream-1936 +airtai__faststream-1965 +airtai__faststream-2073 +airtai__faststream-2092 +airtai__faststream-2137 +airtai__faststream-2153 +aiven__terraform-provider-aiven-2089 +akinsho__nvim-bufferline.lua-100 +akinsho__nvim-bufferline.lua-117 +akinsho__nvim-bufferline.lua-173 +aksiksi__compose2nix-21 +aksiksi__compose2nix-25 +aksiksi__compose2nix-28 +aksiksi__compose2nix-29 +aksiksi__compose2nix-44 +aksiksi__compose2nix-7 +aksiksi__compose2nix-76 +aksiksi__compose2nix-77 +aksiksi__compose2nix-9 +akuity__kargo-2724 +akvelon__flutter-code-editor-91 +akvelon__flutter-code-editor-95 +alan-turing-institute__sktime-3208 +alan-turing-institute__sktime-3231 +alangpierce__sucrase-673 +alangpierce__sucrase-709 +alangpierce__sucrase-711 +alangpierce__sucrase-713 +alangpierce__sucrase-732 +alangpierce__sucrase-746 +alangpierce__sucrase-769 +alangpierce__sucrase-788 +alangpierce__sucrase-789 +alangpierce__sucrase-798 +alangpierce__sucrase-800 +alangpierce__sucrase-806 +alangpierce__sucrase-809 +alangpierce__sucrase-810 +alangpierce__sucrase-811 +alchemyplatform__alchemy-sdk-js-124 +alchemyplatform__alchemy-sdk-js-178 +alchemyplatform__alchemy-sdk-js-185 +alchemyplatform__alchemy-sdk-js-230 +alchemyplatform__alchemy-sdk-js-273 +alchemyplatform__alchemy-sdk-js-279 +alecaivazis__survey-208 +alecaivazis__survey-219 +alecaivazis__survey-222 +alecthomas__chroma-521 +alecthomas__chroma-550 +alecthomas__gometalinter-289 +alecthomas__gometalinter-319 +alecthomas__gometalinter-333 +alecthomas__gometalinter-353 +alecthomas__gometalinter-377 +alecthomas__kong-130 +alecthomas__kong-135 +alecthomas__kong-169 +alecthomas__kong-245 +alecthomas__kong-247 +alecthomas__kong-262 +alecthomas__kong-317 +alecthomas__kong-331 +alecthomas__kong-368 +alecthomas__kong-409 +alecthomas__kong-484 +alecthomas__kong-529 +aleph-alpha__ts-rs-127 +aleph-alpha__ts-rs-184 +aleph-alpha__ts-rs-204 +aleph-alpha__ts-rs-206 +aleph-alpha__ts-rs-209 +aleph-alpha__ts-rs-212 +aleph-alpha__ts-rs-366 +aleph-alpha__ts-rs-371 +aleph-alpha__ts-rs-389 +aleph-alpha__ts-rs-393 +aleph-alpha__ts-rs-406 +aleph-alpha__ts-rs-422 +alexa-js__alexa-app-364 +alexa-js__alexa-app-374 +alexcasalboni__aws-lambda-power-tuning-103 +alexcasalboni__aws-lambda-power-tuning-149 +alexcasalboni__aws-lambda-power-tuning-180 +alexcasalboni__aws-lambda-power-tuning-213 +alexcasalboni__aws-lambda-power-tuning-98 +alexcasalboni__aws-lambda-power-tuning-99 +alexcrichton__futures-rs-151 +alexcrichton__futures-rs-451 +alexcrichton__futures-rs-555 +alexcrichton__futures-rs-557 +alexcrichton__futures-rs-560 +alexcrichton__futures-rs-578 +alexcrichton__futures-rs-712 +alexcrichton__proc-macro2-236 +alexcrichton__toml-rs-165 +alexcrichton__toml-rs-184 +alexcrichton__toml-rs-197 +algebraicjulia__catlab.jl-227 +algebraicjulia__catlab.jl-284 +algebraicjulia__catlab.jl-943 +algesten__ureq-916 +algolia__algoliasearch-client-go-690 +algolia__algoliasearch-helper-js-940 +algorand__indexer-1543 +algorand__indexer-1622 +algorand__indexer-440 +algorand__js-algorand-sdk-454 +algorand__js-algorand-sdk-700 +alibaba__fescar-382 +alibaba__fescar-396 +alibaba__fescar-406 +alibaba__fescar-408 +alibaba__fescar-412 +alibaba__fescar-426 +alibaba__fescar-467 +alibaba__fescar-485 +alibaba__fescar-501 +alibaba__fescar-571 +alibaba__fescar-619 +alibaba__fescar-629 +alibaba__fescar-634 +alibaba__fescar-644 +alibaba__hooks-920 +alibaba__sentinel-golang-332 +alibaba__sentinel-golang-352 +alibaba__sentinel-golang-354 +aliyun__fun-184 +aliyun__fun-243 +aliyun__fun-250 +aliyun__fun-255 +aliyun__fun-266 +allegro__bigcache-184 +allegro__bigcache-203 +allegro__bigcache-242 +allegro__marathon-consul-109 +allegro__marathon-consul-120 +allegro__marathon-consul-123 +allegro__marathon-consul-145 +allegro__marathon-consul-147 +allegro__marathon-consul-150 +allegro__marathon-consul-157 +allegro__marathon-consul-207 +allegro__marathon-consul-212 +almende__vis-3757 +altair-viz__altair-1539 +altair-viz__altair-3068 +altair-viz__altair-3118 +altair-viz__altair-3377 +altair-viz__altair-518 +alteryx__evalml-1167 +alteryx__evalml-1194 +alteryx__evalml-1218 +alteryx__evalml-1223 +alteryx__evalml-1230 +alteryx__evalml-1231 +alteryx__evalml-1249 +alteryx__evalml-1252 +alteryx__evalml-1254 +alteryx__evalml-1284 +alteryx__evalml-1302 +alteryx__evalml-1306 +alteryx__evalml-1318 +alteryx__evalml-1333 +alteryx__evalml-1348 +alteryx__evalml-1352 +alteryx__evalml-1365 +alteryx__evalml-1374 +alteryx__evalml-1377 +alteryx__evalml-1386 +alteryx__evalml-1403 +alteryx__evalml-1429 +alteryx__evalml-1441 +alteryx__evalml-1457 +alteryx__evalml-1476 +alteryx__evalml-3773 +alteryx__evalml-4179 +alteryx__evalml-4186 +alteryx__evalml-4194 +alteryx__evalml-4258 +alteryx__evalml-4283 +alteryx__evalml-4377 +alteryx__evalml-4385 +alteryx__featuretools-2627 +alteryx__woodwork-1001 +alteryx__woodwork-1015 +alteryx__woodwork-1026 +alteryx__woodwork-1043 +alteryx__woodwork-1184 +alteryx__woodwork-1199 +alteryx__woodwork-1206 +alteryx__woodwork-1269 +alteryx__woodwork-1299 +alteryx__woodwork-1300 +alteryx__woodwork-1315 +alteryx__woodwork-1356 +alteryx__woodwork-1363 +alteryx__woodwork-1366 +alteryx__woodwork-1533 +alteryx__woodwork-1557 +alteryx__woodwork-1574 +alteryx__woodwork-1594 +alteryx__woodwork-1862 +alteryx__woodwork-563 +alteryx__woodwork-588 +alteryx__woodwork-619 +alteryx__woodwork-632 +alteryx__woodwork-636 +alteryx__woodwork-646 +alteryx__woodwork-651 +alteryx__woodwork-657 +alteryx__woodwork-666 +alteryx__woodwork-682 +alteryx__woodwork-683 +alteryx__woodwork-685 +alteryx__woodwork-687 +alteryx__woodwork-692 +alteryx__woodwork-741 +alteryx__woodwork-862 +alteryx__woodwork-943 +alteryx__woodwork-988 +amacneil__dbmate-145 +amacneil__dbmate-167 +amacneil__dbmate-230 +amacneil__dbmate-266 +amacneil__dbmate-383 +amacneil__dbmate-387 +amacneil__dbmate-496 +amacneil__dbmate-76 +amaranth-lang__amaranth-1009 +amaranth-lang__amaranth-1039 +amaranth-lang__amaranth-1054 +amaranth-lang__amaranth-1059 +amaranth-lang__amaranth-1095 +amaranth-lang__amaranth-1098 +amaranth-lang__amaranth-1115 +amaranth-lang__amaranth-1135 +amaranth-lang__amaranth-1146 +amaranth-lang__amaranth-1147 +amaranth-lang__amaranth-1152 +amaranth-lang__amaranth-1163 +amaranth-lang__amaranth-1218 +amaranth-lang__amaranth-1234 +amaranth-lang__amaranth-1245 +amaranth-lang__amaranth-1265 +amaranth-lang__amaranth-1268 +amaranth-lang__amaranth-1317 +amaranth-lang__amaranth-1319 +amaranth-lang__amaranth-1328 +amaranth-lang__amaranth-1334 +amaranth-lang__amaranth-1353 +amaranth-lang__amaranth-1366 +amaranth-lang__amaranth-1376 +amaranth-lang__amaranth-1377 +amaranth-lang__amaranth-1378 +amaranth-lang__amaranth-1395 +amaranth-lang__amaranth-1406 +amaranth-lang__amaranth-1420 +amaranth-lang__amaranth-1429 +amaranth-lang__amaranth-1434 +amaranth-lang__amaranth-1436 +amaranth-lang__amaranth-1493 +amaranth-lang__amaranth-1510 +amaranth-lang__amaranth-1519 +amaranth-lang__amaranth-1520 +amaranth-lang__amaranth-1570 +amaranth-lang__amaranth-664 +amaranth-lang__amaranth-798 +amaranth-lang__amaranth-804 +amaranth-lang__amaranth-806 +amaranth-lang__amaranth-809 +amaranth-lang__amaranth-814 +amaranth-lang__amaranth-825 +amaranth-lang__amaranth-841 +amaranth-lang__amaranth-842 +amaranth-lang__amaranth-847 +amaranth-lang__amaranth-885 +amaranth-lang__amaranth-886 +amaranth-lang__amaranth-898 +amaranth-lang__amaranth-912 +amaranth-lang__amaranth-923 +amaranth-lang__amaranth-942 +amaranth-lang__amaranth-971 +amaranth-lang__amaranth-981 +amaranth-lang__amaranth-989 +amaranth-lang__amaranth-991 +ambv__black-165 +ambv__black-339 +ambv__black-595 +ambv__black-724 +ambv__black-763 +ambv__black-765 +amoffat__sh-497 +amoffat__sh-545 +amoffat__sh-598 +amoffat__sh-603 +amoffat__sh-744 +amoffat__sh-750 +amp-labs__connectors-156 +amp-labs__connectors-756 +amp-labs__connectors-901 +amperity__lein-monolith-61 +amperity__lein-monolith-72 +amperity__vault-clj-91 +amperity__vault-clj-95 +amplify-education__serverless-domain-manager-439 +amplify-education__serverless-domain-manager-469 +amplify-education__serverless-domain-manager-493 +amplify-education__serverless-domain-manager-505 +amplify-education__serverless-domain-manager-513 +amplify-education__serverless-domain-manager-537 +amplify-education__serverless-domain-manager-554 +amplify-education__serverless-domain-manager-557 +amplify-education__serverless-domain-manager-561 +amplify-education__serverless-domain-manager-592 +amplify-education__serverless-domain-manager-606 +amplify-education__serverless-domain-manager-609 +amplify-education__serverless-domain-manager-616 +ampproject__amp-toolbox-php-476 +ampproject__amp-toolbox-php-513 +ampproject__amp-toolbox-php-521 +ampproject__amp-toolbox-php-524 +ampproject__amp-toolbox-php-531 +ampproject__amp-toolbox-php-533 +ampproject__amp-toolbox-php-551 +amzn__ion-go-19 +amzn__ion-go-20 +amzn__ion-go-64 +amzn__ion-java-185 +amzn__ion-java-190 +amzn__ion-java-213 +amzn__ion-java-270 +amzn__ion-java-278 +amzn__ion-java-289 +amzn__ion-java-296 +amzn__ion-java-400 +amzn__ion-java-401 +anchore__grype-2741 +andig__evcc-171 +andig__evcc-172 +andig__evcc-268 +andig__evcc-464 +andrewdavidmackenzie__pigg-16 +andygrunwald__go-jira-584 +andygrunwald__go-jira-695 +andyogo__stylelint-declaration-strict-value-317 +ankitpokhrel__jira-cli-347 +anmonteiro__ocaml-h2-247 +ansible__ansible-runner-1307 +ansible__tower-cli-367 +ansible__tower-cli-371 +ansible__tower-cli-680 +ansys__pyansys-geometry-1208 +ansys__pyansys-geometry-941 +ant-design__ant-design-mobile-5458 +ant-design__ant-design-mobile-5627 +ant-design__ant-design-mobile-5751 +ant-design__ant-design-mobile-6113 +ant-design__ant-design-mobile-6239 +ant-design__ant-design-mobile-6256 +ant-design__ant-design-mobile-6309 +ant-design__ant-design-mobile-6316 +ant-design__ant-design-mobile-6342 +ant-design__ant-design-mobile-6481 +antrea-io__antrea-2535 +antrea-io__antrea-6531 +anuraghazra__github-readme-stats-2099 +anuraghazra__github-readme-stats-2228 +anz-bank__sysl-1020 +apache__camel-k-774 +apache__camel-k-779 +apache__camel-k-805 +apache__camel-k-808 +apache__camel-k-817 +apache__camel-k-825 +apache__camel-k-835 +apache__camel-k-842 +apache__camel-k-857 +apache__camel-k-866 +apache__datafusion-15232 +apache__datafusion-15563 +apache__datafusion-15576 +apache__datafusion-sqlparser-rs-1427 +apache__datafusion-sqlparser-rs-1453 +apache__datafusion-sqlparser-rs-1516 +apache__datafusion-sqlparser-rs-1793 +apache__datafusion-sqlparser-rs-1883 +apache__dubbo-go-hessian2-212 +apache__dubbo-go-hessian2-229 +apache__dubbo-go-hessian2-256 +apache__dubbo-go-hessian2-264 +apache__dubbo-go-hessian2-300 +apache__dubbo-go-hessian2-309 +apache__dubbo-go-hessian2-332 +apache__dubbo-go-hessian2-357 +apache__incubator-fluo-763 +apache__incubator-fluo-774 +apache__incubator-fluo-814 +apache__incubator-fluo-819 +apache__incubator-fluo-841 +apache__incubator-fluo-862 +apache__incubator-fluo-884 +apache__incubator-openwhisk-client-js-186 +apache__incubator-seata-go-739 +apache__incubator-shardingsphere-4517 +apache__incubator-shardingsphere-4525 +apache__incubator-shardingsphere-4908 +apache__pulsar-client-go-1197 +apache__pulsar-client-go-1225 +apache__pulsar-client-go-1264 +apache__pulsar-client-go-1385 +apache__pulsar-client-go-750 +apache__pulsar-client-go-799 +apache__pulsar-client-go-889 +apache__pulsar-client-go-893 +apache__pulsar-client-go-904 +apache__pulsar-client-go-916 +apache__pulsar-client-go-957 +apache__pulsar-client-go-987 +apache__rocketmq-client-go-1014 +apache__rocketmq-client-go-1019 +apache__rocketmq-client-go-1025 +apache__rocketmq-client-go-1107 +apache__trafficcontrol-7744 +apecloud__myduckserver-335 +api-platform__admin-252 +api-platform__admin-267 +api-platform__admin-269 +api-platform__admin-364 +api-platform__admin-515 +api-platform__core-6873 +api-platform__core-7021 +api-platform__core-7056 +api-platform__core-7134 +apiaryio__dredd-940 +apiflask__apiflask-322 +apiflask__apiflask-352 +apiflask__apiflask-353 +apiflask__apiflask-382 +apiflask__apiflask-392 +apiflask__apiflask-400 +apiflask__apiflask-407 +apiflask__apiflask-411 +apiflask__apiflask-412 +apiflask__apiflask-413 +apiflask__apiflask-448 +apiflask__apiflask-469 +apiflask__apiflask-485 +apiflask__apiflask-495 +apiflask__apiflask-508 +apiflask__apiflask-550 +apiflask__apiflask-589 +apiflask__apiflask-605 +apiflask__apiflask-615 +apiflask__apiflask-627 +apiflask__apiflask-630 +apiflask__apiflask-632 +apiflask__apiflask-642 +apiflask__apiflask-659 +apify__apify-cli-521 +apigee__registry-1021 +apigee__registry-1025 +apigee__registry-1044 +apigee__registry-1087 +apigee__registry-1103 +apigee__registry-1111 +apigee__registry-1124 +apigee__registry-1142 +apigee__registry-1145 +apigee__registry-524 +apigee__registry-582 +apigee__registry-627 +apigee__registry-665 +apigee__registry-683 +apigee__registry-687 +apigee__registry-695 +apigee__registry-698 +apigee__registry-754 +apigee__registry-796 +apigee__registry-816 +apigee__registry-818 +apigee__registry-828 +apigee__registry-849 +apigee__registry-859 +apigee__registry-928 +apigee__registry-961 +apigee__registry-963 +apigee__registry-969 +apigee__registry-980 +apigee__registry-994 +apluslms__a-plus-1199 +apluslms__a-plus-1403 +apollographql__apollo-codegen-311 +apollographql__apollo-codegen-312 +apollographql__apollo-codegen-345 +apollographql__apollo-codegen-368 +apollographql__apollo-rs-120 +apollographql__apollo-rs-135 +apollographql__apollo-rs-137 +apollographql__apollo-rs-245 +apollographql__apollo-rs-718 +apollographql__apollo-rs-745 +apollographql__apollo-rs-835 +apollographql__apollo-server-7916 +apollographql__apollo-tooling-2335 +apostrophecms__sanitize-html-495 +apostrophecms__sanitize-html-607 +apostrophecms__sanitize-html-634 +apostrophecms__sanitize-html-692 +appc__spec-647 +appium__appium-18479 +apple__swift-argument-parser-10 +apple__swift-argument-parser-28 +apple__swift-argument-parser-30 +apple__swift-argument-parser-48 +apple__swift-argument-parser-55 +apple__swift-argument-parser-592 +apple__swift-argument-parser-62 +apple__swift-argument-parser-63 +apple__swift-argument-parser-67 +apple__swift-argument-parser-71 +apple__swift-distributed-tracing-118 +apple__swift-distributed-tracing-68 +apple__swift-distributed-tracing-88 +apple__swift-distributed-tracing-90 +apple__swift-distributed-tracing-95 +apple__swift-markdown-133 +apple__swift-markdown-154 +apple__swift-markdown-50 +apple__swift-markdown-66 +apple__swift-markdown-79 +apple__swift-nio-extras-100 +apple__swift-nio-http2-102 +apple__swift-nio-http2-145 +apple__swift-nio-http2-174 +apple__swift-nio-http2-320 +apple__swift-nio-http2-97 +apple__swift-protobuf-1478 +appleboy__drone-telegram-104 +appleboy__drone-telegram-81 +appleboy__drone-telegram-83 +appleboy__drone-telegram-85 +appleboy__gin-jwt-342 +appsilon__rhino-102 +appsilon__rhino-238 +appsilon__rhino-453 +appsilon__rhino-491 +appsilon__rhino-535 +appsilon__rhino-537 +appvia__kev-617 +aquasecurity__kube-bench-1330 +aquasecurity__kube-bench-1367 +aquasecurity__starboard-1008 +aquasecurity__starboard-331 +aquasecurity__starboard-348 +aquasecurity__starboard-443 +aquasecurity__starboard-505 +aquasecurity__starboard-586 +aquasecurity__starboard-956 +aquasecurity__tfsec-1009 +aquasecurity__tfsec-1023 +aquasecurity__tfsec-1077 +aquasecurity__tfsec-1089 +aquasecurity__tfsec-1156 +aquasecurity__tfsec-1243 +aquasecurity__tfsec-1254 +aquasecurity__tfsec-1303 +aquasecurity__tfsec-1304 +aquasecurity__tfsec-1317 +aquasecurity__tfsec-1326 +aquasecurity__tfsec-1360 +aquasecurity__tfsec-1548 +aquasecurity__tfsec-870 +aquasecurity__tfsec-871 +aquasecurity__tfsec-909 +aquasecurity__tfsec-911 +aquasecurity__tfsec-969 +aquasecurity__tfsec-995 +aquasecurity__trivy-9207 +arabold__docs-mcp-server-11 +arabold__docs-mcp-server-141 +arabold__docs-mcp-server-27 +arabold__docs-mcp-server-35 +arabold__docs-mcp-server-42 +arabold__docs-mcp-server-44 +arabold__docs-mcp-server-56 +arabold__docs-mcp-server-81 +arb__celebrate-144 +arb__celebrate-148 +argoproj-labs__applicationset-111 +argoproj-labs__applicationset-132 +argoproj-labs__applicationset-136 +argoproj-labs__applicationset-138 +argoproj-labs__applicationset-139 +argoproj-labs__applicationset-141 +argoproj-labs__applicationset-146 +argoproj-labs__applicationset-147 +argoproj-labs__applicationset-155 +argoproj-labs__applicationset-156 +argoproj-labs__applicationset-193 +argoproj-labs__applicationset-197 +argoproj-labs__applicationset-215 +argoproj-labs__applicationset-24 +argoproj-labs__applicationset-242 +argoproj-labs__applicationset-282 +argoproj-labs__applicationset-370 +argoproj-labs__applicationset-372 +argoproj-labs__applicationset-429 +argoproj-labs__applicationset-69 +argoproj-labs__argo-rollouts-manager-46 +argoproj-labs__argocd-operator-472 +argoproj-labs__argocd-operator-476 +argoproj__argo-1892 +argoproj__argo-2166 +argoproj__argo-2304 +argoproj__argo-2365 +argoproj__argo-2373 +argoproj__argo-2377 +argoproj__argo-2431 +argoproj__argo-2445 +argoproj__argo-2453 +argoproj__argo-2510 +argoproj__argo-2514 +argoproj__argo-2523 +argoproj__argo-2562 +argoproj__argo-2572 +argoproj__argo-2604 +argoproj__argo-2645 +argoproj__argo-2721 +argoproj__argo-2774 +argoproj__argo-2819 +argoproj__argo-2827 +argoproj__argo-2830 +argoproj__argo-2964 +argoproj__argo-2966 +argoproj__argo-3019 +argoproj__argo-3024 +argoproj__argo-3146 +argoproj__argo-3149 +argoproj__argo-3345 +argoproj__argo-3385 +argoproj__argo-3437 +argoproj__argo-3469 +argoproj__argo-3490 +argoproj__argo-3509 +argoproj__argo-3514 +argoproj__argo-3581 +argoproj__argo-3624 +argoproj__argo-3661 +argoproj__argo-3716 +argoproj__argo-3717 +argoproj__argo-3758 +argoproj__argo-3801 +argoproj__argo-3813 +argoproj__argo-3814 +argoproj__argo-3945 +argoproj__argo-4105 +argoproj__argo-4195 +argoproj__argo-4310 +argoproj__argo-4316 +argoproj__argo-4350 +argoproj__argo-4369 +argoproj__argo-4401 +argoproj__argo-4409 +argoproj__argo-4412 +argoproj__argo-4492 +argoproj__argo-4594 +argoproj__argo-4643 +argoproj__argo-4664 +argoproj__argo-4695 +argoproj__argo-4735 +argoproj__argo-4757 +argoproj__argo-4808 +argoproj__argo-4872 +argoproj__argo-cd-4741 +argoproj__argo-cd-5661 +argoproj__argo-rollouts-1074 +ariakit__ariakit-2308 +ariakit__ariakit-2313 +ariga__atlas-1047 +ariga__atlas-1828 +ariga__atlas-1942 +ariga__atlas-2127 +ariga__atlas-2255 +ariga__atlas-3327 +ariga__atlas-3508 +ariga__atlas-549 +ariga__atlas-607 +aristanetworks__anta-1000 +aristanetworks__anta-1007 +aristanetworks__anta-1008 +aristanetworks__anta-1019 +aristanetworks__anta-1021 +aristanetworks__anta-1037 +aristanetworks__anta-1078 +aristanetworks__anta-1089 +aristanetworks__anta-1098 +aristanetworks__anta-1113 +aristanetworks__anta-1114 +aristanetworks__anta-1125 +aristanetworks__anta-1136 +aristanetworks__anta-1176 +aristanetworks__anta-1178 +aristanetworks__anta-1227 +aristanetworks__anta-1250 +aristanetworks__anta-1276 +aristanetworks__anta-739 +aristanetworks__anta-815 +aristanetworks__anta-828 +aristanetworks__anta-849 +aristanetworks__anta-859 +aristanetworks__anta-870 +aristanetworks__anta-877 +aristanetworks__anta-902 +aristanetworks__anta-919 +aristanetworks__anta-920 +aristanetworks__anta-956 +aristanetworks__anta-962 +aristanetworks__anta-969 +aristanetworks__anta-976 +aristanetworks__anta-978 +aristanetworks__anta-993 +arm-doe__act-651 +arm-doe__act-741 +arm-doe__act-743 +armadaproject__armada-3197 +armmbed__yotta-656 +armmbed__yotta-802 +artichoke__artichoke-2308 +artusjs__core-142 +artusjs__core-155 +artusjs__core-193 +artusjs__core-31 +arve0__markdown-it-attrs-155 +arve0__markdown-it-attrs-64 +arve0__markdown-it-attrs-69 +arve0__markdown-it-attrs-71 +arve0__markdown-it-attrs-76 +arve0__markdown-it-attrs-89 +arve0__markdown-it-attrs-95 +asdf-format__asdf-1907 +asdf-format__asdf-1935 +ash-project__ash-1371 +ash-project__ash-1624 +ash-project__ash-1853 +ash-project__ash-2027 +ash-project__ash-821 +ash-project__ash-863 +ash-project__ash_graphql-138 +ash-project__ash_graphql-166 +ash-project__ash_graphql-261 +ash-project__ash_graphql-307 +ashleygwilliams__cargo-generate-252 +ashleygwilliams__cargo-generate-269 +ashleygwilliams__wasm-pack-105 +ashleygwilliams__wasm-pack-138 +ashleygwilliams__wasm-pack-162 +ashleygwilliams__wasm-pack-32 +ashleygwilliams__wasm-pack-62 +ashleygwilliams__wasm-pack-95 +asottile__add-trailing-comma-178 +asottile__add-trailing-comma-182 +aspnetboilerplate__aspnetboilerplate-6811 +aspp__pelita-412 +aspp__pelita-601 +aspp__pelita-604 +aspp__pelita-635 +aspp__pelita-655 +aspp__pelita-798 +aspp__pelita-815 +aspp__pelita-863 +aspp__pelita-875 +ast-grep__ast-grep-1588 +ast-grep__ast-grep-1634 +ast-grep__ast-grep-1636 +ast-grep__ast-grep-1769 +ast-grep__ast-grep-1770 +ast-grep__ast-grep-1820 +ast-grep__ast-grep-2028 +astanin__python-tabulate-268 +astanin__python-tabulate-362 +astropenguin__xarray-dataclasses-2 +astropenguin__xarray-dataclasses-33 +astropenguin__xarray-dataclasses-4 +astropenguin__xarray-dataclasses-51 +astropenguin__xarray-dataclasses-6 +astropenguin__xarray-dataclasses-60 +astropenguin__xarray-dataclasses-8 +astropenguin__xarray-dataclasses-84 +astropenguin__xarray-dataclasses-87 +astropy__ccdproc-819 +astropy__ccdproc-867 +astropy__ccdproc-901 +astropy__pyvo-204 +astropy__specutils-1118 +astropy__specutils-1119 +astropy__specutils-1228 +asyncapi__generator-343 +asyncapi__generator-346 +asyncapi__generator-542 +asyncapi__modelina-239 +asyncapi__modelina-240 +asyncapi__modelina-249 +asyncapi__modelina-257 +asyncapi__modelina-263 +asyncapi__modelina-268 +asyncapi__modelina-269 +asyncapi__modelina-497 +asyncapi__modelina-511 +asyncapi__modelina-545 +asyncapi__modelina-554 +asyncapi__modelina-596 +asyncapi__modelina-613 +asyncapi__parser-js-778 +asyncapi__parser-js-786 +asynkron__protoactor-dotnet-1909 +athensresearch__athens-114 +athensresearch__athens-1521 +atk4__data-1227 +atk4__data-1238 +atlassian__changesets-187 +atlassian__changesets-204 +atlassian__changesets-278 +atlassian__changesets-281 +atlassian__changesets-311 +atlassian__changesets-313 +atlassian__changesets-324 +atlassian__changesets-352 +atlassian__changesets-418 +atlassian__changesets-441 +atlassian__changesets-495 +atlassian__changesets-504 +atlassian__changesets-507 +atlassian__changesets-634 +atlassian__gostatsd-274 +atlassian__gostatsd-310 +atoptima__coluna.jl-1004 +atoptima__coluna.jl-1122 +atsushisakai__pythonrobotics-1168 +attic-labs__noms-3869 +audreyr__cookiecutter-542 +audreyr__cookiecutter-563 +audreyr__cookiecutter-594 +audreyr__cookiecutter-642 +audreyr__cookiecutter-666 +audreyr__cookiecutter-729 +audreyr__cookiecutter-788 +audreyr__cookiecutter-792 +audreyr__cookiecutter-825 +audreyr__cookiecutter-834 +audreyr__cookiecutter-860 +audreyr__cookiecutter-862 +audreyr__cookiecutter-884 +audreyr__cookiecutter-964 +audreyr__cookiecutter-967 +auth0__auth0-php-665 +auth0__auth0-spa-js-1061 +auth0__auth0-spa-js-1068 +auth0__auth0-spa-js-1071 +auth0__auth0-spa-js-129 +auth0__auth0-spa-js-221 +auth0__auth0-spa-js-242 +auth0__auth0-spa-js-246 +auth0__auth0-spa-js-276 +auth0__auth0-spa-js-339 +auth0__auth0-spa-js-341 +auth0__auth0-spa-js-354 +auth0__auth0-spa-js-368 +auth0__auth0-spa-js-369 +auth0__auth0-spa-js-465 +auth0__auth0-spa-js-486 +auth0__auth0-spa-js-491 +auth0__auth0-spa-js-524 +auth0__auth0-spa-js-558 +auth0__auth0-spa-js-568 +auth0__auth0-spa-js-612 +auth0__auth0-spa-js-639 +auth0__auth0-spa-js-732 +auth0__auth0-spa-js-802 +auth0__auth0-spa-js-803 +auth0__auth0-spa-js-861 +auth0__auth0.js-1195 +auth0__auth0.js-285 +auth0__auth0.js-381 +auth0__auth0.js-619 +auth0__auth0.js-641 +auth0__auth0.js-817 +auth0__nextjs-auth0-1028 +auth0__nextjs-auth0-1341 +auth0__nextjs-auth0-1342 +auth0__nextjs-auth0-1346 +auth0__nextjs-auth0-257 +auth0__nextjs-auth0-267 +auth0__nextjs-auth0-276 +auth0__nextjs-auth0-298 +auth0__nextjs-auth0-317 +auth0__nextjs-auth0-365 +auth0__nextjs-auth0-557 +auth0__nextjs-auth0-570 +auth0__nextjs-auth0-571 +auth0__nextjs-auth0-843 +auth0__nextjs-auth0-875 +auth0__nextjs-auth0-877 +auth0__nextjs-auth0-900 +auth0__nextjs-auth0-909 +auth0__node-auth0-183 +auth0__node-auth0-189 +auth0__node-auth0-190 +auth0__node-auth0-217 +auth0__node-auth0-267 +auth0__node-auth0-278 +auth0__node-auth0-313 +auth0__node-auth0-340 +auth0__node-auth0-492 +auth0__node-auth0-744 +auth0__node-auth0-785 +authelia__authelia-1488 +authelia__authelia-1500 +authelia__authelia-2251 +authelia__authelia-2616 +authelia__authelia-2796 +authelia__authelia-2985 +authelia__authelia-2997 +authelia__authelia-3065 +authelia__authelia-3081 +authelia__authelia-3990 +authelia__authelia-5973 +authelia__authelia-7574 +authelia__authelia-8023 +authelia__authelia-8112 +authelia__authelia-8119 +authelia__authelia-813 +authelia__authelia-852 +authelia__authelia-8838 +authelia__authelia-8983 +authelia__authelia-944 +authelia__authelia-9479 +authelia__authelia-9714 +authts__oidc-client-ts-1104 +authts__oidc-client-ts-1148 +authts__oidc-client-ts-1158 +authts__oidc-client-ts-1212 +authts__oidc-client-ts-1233 +authts__oidc-client-ts-1291 +authts__oidc-client-ts-1342 +authts__oidc-client-ts-1430 +authts__oidc-client-ts-1702 +authts__oidc-client-ts-570 +authts__oidc-client-ts-573 +authts__oidc-client-ts-690 +authts__oidc-client-ts-701 +authts__oidc-client-ts-747 +authts__oidc-client-ts-768 +authts__oidc-client-ts-782 +authts__oidc-client-ts-812 +authts__oidc-client-ts-828 +auto-impl-rs__auto_impl-101 +auto-impl-rs__auto_impl-85 +automattic__juice-320 +automattic__juice-330 +automattic__juice-360 +automattic__juice-370 +automattic__juice-526 +automattic__node-canvas-2214 +automl__configspace-382 +automl__configspace-388 +automl__smac3-1069 +avajs__ava-2836 +avajs__ava-2837 +avajs__ava-3080 +avajs__ava-3283 +avajs__eslint-plugin-ava-246 +avajs__eslint-plugin-ava-265 +avajs__eslint-plugin-ava-306 +avenga__couper-177 +avenga__couper-181 +awdeorio__mailmerge-76 +aws-actions__configure-aws-credentials-20 +aws-actions__configure-aws-credentials-32 +aws-actions__configure-aws-credentials-42 +aws-actions__configure-aws-credentials-71 +aws-actions__configure-aws-credentials-82 +aws-actions__configure-aws-credentials-92 +aws-cloudformation__cfn-lint-2031 +aws-cloudformation__cfn-lint-2208 +aws-cloudformation__cfn-lint-2226 +aws-cloudformation__cfn-lint-2230 +aws-cloudformation__cfn-lint-2253 +aws-cloudformation__cfn-lint-2387 +aws-cloudformation__cfn-lint-2425 +aws-cloudformation__cfn-lint-2426 +aws-cloudformation__cfn-lint-2428 +aws-cloudformation__cfn-lint-2441 +aws-cloudformation__cfn-lint-2466 +aws-cloudformation__cfn-lint-2470 +aws-cloudformation__cfn-lint-2548 +aws-cloudformation__cfn-lint-2571 +aws-cloudformation__cfn-lint-2649 +aws-cloudformation__cfn-lint-2661 +aws-cloudformation__cfn-lint-2682 +aws-cloudformation__cfn-lint-2691 +aws-cloudformation__cfn-lint-2720 +aws-cloudformation__cfn-lint-2786 +aws-cloudformation__cfn-lint-2891 +aws-cloudformation__cfn-lint-2927 +aws-cloudformation__cfn-lint-2967 +aws-cloudformation__cfn-lint-3017 +aws-cloudformation__cfn-lint-3060 +aws-cloudformation__cfn-lint-3061 +aws-cloudformation__cfn-lint-3073 +aws-cloudformation__cfn-lint-3169 +aws-cloudformation__cfn-lint-3176 +aws-cloudformation__cfn-lint-3224 +aws-cloudformation__cfn-lint-3293 +aws-cloudformation__cfn-lint-3335 +aws-cloudformation__cfn-lint-3337 +aws-cloudformation__cfn-lint-3338 +aws-cloudformation__cfn-lint-3340 +aws-cloudformation__cfn-lint-3341 +aws-cloudformation__cfn-lint-3342 +aws-cloudformation__cfn-lint-3357 +aws-cloudformation__cfn-lint-3372 +aws-cloudformation__cfn-lint-3373 +aws-cloudformation__cfn-lint-3377 +aws-cloudformation__cfn-lint-3386 +aws-cloudformation__cfn-lint-3388 +aws-cloudformation__cfn-lint-3389 +aws-cloudformation__cfn-lint-3390 +aws-cloudformation__cfn-lint-3392 +aws-cloudformation__cfn-lint-3399 +aws-cloudformation__cfn-lint-3400 +aws-cloudformation__cfn-lint-3401 +aws-cloudformation__cfn-lint-3402 +aws-cloudformation__cfn-lint-3419 +aws-cloudformation__cfn-lint-3425 +aws-cloudformation__cfn-lint-3439 +aws-cloudformation__cfn-lint-3450 +aws-cloudformation__cfn-lint-3461 +aws-cloudformation__cfn-lint-3470 +aws-cloudformation__cfn-lint-3475 +aws-cloudformation__cfn-lint-3497 +aws-cloudformation__cfn-lint-3498 +aws-cloudformation__cfn-lint-3501 +aws-cloudformation__cfn-lint-3523 +aws-cloudformation__cfn-lint-3546 +aws-cloudformation__cfn-lint-3548 +aws-cloudformation__cfn-lint-3552 +aws-cloudformation__cfn-lint-3557 +aws-cloudformation__cfn-lint-3561 +aws-cloudformation__cfn-lint-3563 +aws-cloudformation__cfn-lint-3579 +aws-cloudformation__cfn-lint-3582 +aws-cloudformation__cfn-lint-3593 +aws-cloudformation__cfn-lint-3596 +aws-cloudformation__cfn-lint-3607 +aws-cloudformation__cfn-lint-3609 +aws-cloudformation__cfn-lint-3621 +aws-cloudformation__cfn-lint-3629 +aws-cloudformation__cfn-lint-3633 +aws-cloudformation__cfn-lint-3634 +aws-cloudformation__cfn-lint-3639 +aws-cloudformation__cfn-lint-3653 +aws-cloudformation__cfn-lint-3659 +aws-cloudformation__cfn-lint-3663 +aws-cloudformation__cfn-lint-3671 +aws-cloudformation__cfn-lint-3684 +aws-cloudformation__cfn-lint-3686 +aws-cloudformation__cfn-lint-3688 +aws-cloudformation__cfn-lint-3695 +aws-cloudformation__cfn-lint-3700 +aws-cloudformation__cfn-lint-3707 +aws-cloudformation__cfn-lint-3712 +aws-cloudformation__cfn-lint-3714 +aws-cloudformation__cfn-lint-3731 +aws-cloudformation__cfn-lint-3759 +aws-cloudformation__cfn-lint-3764 +aws-cloudformation__cfn-lint-3767 +aws-cloudformation__cfn-lint-3770 +aws-cloudformation__cfn-lint-3785 +aws-cloudformation__cfn-lint-3789 +aws-cloudformation__cfn-lint-3798 +aws-cloudformation__cfn-lint-3817 +aws-cloudformation__cfn-lint-3824 +aws-cloudformation__cfn-lint-3854 +aws-cloudformation__cfn-lint-3855 +aws-cloudformation__cfn-lint-3856 +aws-cloudformation__cfn-lint-3866 +aws-cloudformation__cfn-lint-3875 +aws-cloudformation__cfn-lint-3890 +aws-cloudformation__cfn-lint-3898 +aws-cloudformation__cfn-lint-3900 +aws-cloudformation__cfn-lint-3908 +aws-cloudformation__cfn-lint-3920 +aws-cloudformation__cfn-lint-3937 +aws-cloudformation__cfn-lint-3947 +aws-cloudformation__cfn-lint-3952 +aws-cloudformation__cfn-lint-3965 +aws-cloudformation__cfn-lint-3972 +aws-cloudformation__cfn-lint-3989 +aws-cloudformation__cfn-lint-3991 +aws-cloudformation__cfn-lint-3994 +aws-cloudformation__cfn-lint-4008 +aws-cloudformation__cfn-lint-4009 +aws-cloudformation__cfn-lint-4011 +aws-cloudformation__cfn-lint-4023 +aws-cloudformation__cfn-lint-4026 +aws-cloudformation__cfn-lint-4028 +aws-cloudformation__cfn-lint-4032 +aws-cloudformation__cfn-lint-4045 +aws-cloudformation__cfn-lint-4051 +aws-cloudformation__cfn-lint-4094 +aws-cloudformation__cfn-lint-4116 +aws-cloudformation__cfn-lint-4149 +aws-cloudformation__cfn-python-lint-1283 +aws-cloudformation__cfn-python-lint-1301 +aws-cloudformation__cfn-python-lint-1305 +aws-cloudformation__cfn-python-lint-1375 +aws-cloudformation__cfn-python-lint-1405 +aws-cloudformation__cfn-python-lint-1409 +aws-cloudformation__cfn-python-lint-1419 +aws-cloudformation__cfn-python-lint-1444 +aws-cloudformation__cfn-python-lint-1483 +aws-cloudformation__cfn-python-lint-1562 +aws-cloudformation__cfn-python-lint-1631 +aws-cloudformation__cfn-python-lint-1640 +aws-cloudformation__cfn-python-lint-1659 +aws-cloudformation__cfn-python-lint-1690 +aws-cloudformation__cfn-python-lint-1773 +aws-cloudformation__cfn-python-lint-1774 +aws-cloudformation__cfn-python-lint-1788 +aws-cloudformation__cfn-python-lint-1900 +aws-cloudformation__cfn-python-lint-1978 +aws-cloudformation__cfn-python-lint-1989 +aws-cloudformation__cfn-python-lint-2006 +aws-cloudformation__rain-103 +aws-cloudformation__rain-243 +aws-cloudformation__rain-265 +aws-cloudformation__rain-305 +aws-cloudformation__rain-404 +aws-cloudformation__rain-540 +aws-cloudformation__rain-541 +aws-cloudformation__rain-557 +aws-cloudformation__rain-565 +aws-cloudformation__rain-627 +aws-cloudformation__rain-644 +aws-cloudformation__rain-654 +aws-powertools__powertools-lambda-typescript-3030 +aws-powertools__powertools-lambda-typescript-3195 +aws-powertools__powertools-lambda-typescript-3325 +aws-powertools__powertools-lambda-typescript-3415 +aws-powertools__powertools-lambda-typescript-3482 +aws-powertools__powertools-lambda-typescript-3485 +aws-powertools__powertools-lambda-typescript-3506 +aws-powertools__powertools-lambda-typescript-3521 +aws-powertools__powertools-lambda-typescript-3523 +aws-powertools__powertools-lambda-typescript-3526 +aws-powertools__powertools-lambda-typescript-3560 +aws-powertools__powertools-lambda-typescript-3644 +aws-powertools__powertools-lambda-typescript-3676 +aws-powertools__powertools-lambda-typescript-3694 +aws-powertools__powertools-lambda-typescript-3709 +aws-powertools__powertools-lambda-typescript-3807 +aws-powertools__powertools-lambda-typescript-3907 +aws-powertools__powertools-lambda-typescript-3970 +aws-powertools__powertools-lambda-typescript-3972 +aws-quickstart__taskcat-505 +aws-quickstart__taskcat-534 +aws__amazon-ecs-cli-v2-363 +aws__amazon-ecs-cli-v2-466 +aws__amazon-ecs-cli-v2-479 +aws__amazon-ecs-cli-v2-486 +aws__aws-lambda-dotnet-1346 +aws__aws-sdk-go-3183 +aws__aws-sdk-go-3733 +aws__aws-sdk-go-5345 +aws__aws-sdk-js-2325 +aws__aws-sdk-js-2456 +aws__aws-sdk-js-4166 +awslabs__aws-ddk-264 +awslabs__aws-ddk-280 +awslabs__aws-ddk-284 +awslabs__aws-ddk-464 +awslabs__aws-embedded-metrics-node-16 +awslabs__aws-embedded-metrics-node-21 +awslabs__aws-embedded-metrics-node-23 +awslabs__aws-embedded-metrics-node-26 +awslabs__aws-embedded-metrics-node-55 +awslabs__aws-embedded-metrics-node-82 +awslabs__cdk8s-349 +awslabs__cdk8s-505 +awslabs__cfn-python-lint-426 +awslabs__cfn-python-lint-569 +awslabs__cfn-python-lint-595 +awslabs__cfn-python-lint-626 +awslabs__cfn-python-lint-644 +awslabs__cfn-python-lint-648 +awslabs__cfn-python-lint-659 +awslabs__cfn-python-lint-682 +awslabs__generative-ai-cdk-constructs-196 +awslabs__generative-ai-cdk-constructs-367 +awslabs__generative-ai-cdk-constructs-481 +awslabs__generative-ai-cdk-constructs-651 +awslabs__tough-404 +axelrod-python__axelrod-1070 +axelrod-python__axelrod-1084 +axelrod-python__axelrod-1086 +axelrod-python__axelrod-1113 +axelrod-python__axelrod-1118 +axelrod-python__axelrod-1152 +axelrod-python__axelrod-1157 +axelrod-python__axelrod-1161 +axelrod-python__axelrod-1182 +axelrod-python__axelrod-1190 +axelrod-python__axelrod-1204 +axelrod-python__axelrod-1244 +axelrod-python__axelrod-1458 +axelrod-python__axelrod-590 +axelrod-python__axelrod-638 +axelrod-python__axelrod-639 +axelrod-python__axelrod-653 +axelrod-python__axelrod-657 +axelrod-python__axelrod-671 +axelrod-python__axelrod-699 +axelrod-python__axelrod-733 +axelrod-python__axelrod-761 +axelrod-python__axelrod-767 +axelrod-python__axelrod-770 +axelrod-python__axelrod-778 +axelrod-python__axelrod-783 +axelrod-python__axelrod-792 +axelrod-python__axelrod-862 +axelrod-python__axelrod-959 +axelrod-python__axelrod-962 +axelrod-python__axelrod-975 +axios__axios-5018 +axios__axios-5247 +axios__axios-5250 +axios__axios-5497 +axios__axios-5542 +axios__axios-5661 +axios__axios-5831 +axios__axios-5919 +axios__axios-6175 +axios__axios-6380 +axios__axios-6873 +axios__axios-6961 +axodotdev__cargo-dist-1195 +axodotdev__cargo-dist-172 +axodotdev__cargo-dist-373 +axodotdev__cargo-dist-434 +azat-io__eslint-plugin-perfectionist-387 +azat-io__eslint-plugin-perfectionist-393 +azat-io__eslint-plugin-perfectionist-406 +azat-io__eslint-plugin-perfectionist-415 +azat-io__eslint-plugin-perfectionist-435 +azat-io__eslint-plugin-perfectionist-492 +azure-samples__azure-search-openai-demo-2260 +azure-samples__azure-search-openai-demo-852 +azure__aad-pod-identity-1100 +azure__azure-functions-durable-js-128 +azure__azure-functions-durable-js-145 +azure__azure-functions-durable-js-383 +azure__azure-functions-durable-js-429 +azure__azure-functions-durable-js-43 +azure__azure-functions-durable-js-462 +azure__azure-functions-durable-js-512 +azure__azure-functions-durable-js-71 +azure__azure-sdk-for-go-17742 +azure__azure-sdk-for-go-23871 +azure__azure-sdk-for-go-23911 +azure__azure-service-bus-go-169 +azure__azure-service-bus-go-234 +azure__azurite-2454 +azure__azurite-2545 +azure__draft-217 +azure__walinuxagent-1040 +azure__walinuxagent-1043 +azure__walinuxagent-1086 +azure__walinuxagent-1105 +azure__walinuxagent-1120 +azure__walinuxagent-1127 +azure__walinuxagent-1148 +azure__walinuxagent-1182 +azure__walinuxagent-1183 +azure__walinuxagent-1184 +azure__walinuxagent-1273 +azure__walinuxagent-1302 +azure__walinuxagent-1317 +azure__walinuxagent-1318 +azure__walinuxagent-1425 +azure__walinuxagent-1865 +azure__walinuxagent-2633 +azure__walinuxagent-2761 +azure__walinuxagent-3063 +azure__walinuxagent-317 +azure__walinuxagent-3324 +azure__walinuxagent-352 +azure__walinuxagent-403 +azure__walinuxagent-542 +azure__walinuxagent-547 +azure__walinuxagent-551 +azure__walinuxagent-552 +azure__walinuxagent-602 +azure__walinuxagent-603 +azure__walinuxagent-638 +azure__walinuxagent-642 +azure__walinuxagent-647 +azure__walinuxagent-951 +azure__walinuxagent-954 +azure__walinuxagent-970 +azure__walinuxagent-971 +azure__walinuxagent-987 +azure__walinuxagent-988 +azuread__microsoft-authentication-library-for-python-186 +azuread__microsoft-authentication-library-for-python-205 +azuread__microsoft-authentication-library-for-python-236 +azuread__microsoft-authentication-library-for-python-280 +azuread__microsoft-authentication-library-for-python-315 +azuread__microsoft-authentication-library-for-python-333 +azuread__microsoft-authentication-library-for-python-41 +azuread__microsoft-authentication-library-for-python-433 +azuread__microsoft-authentication-library-for-python-530 +azuread__microsoft-authentication-library-for-python-62 +azuread__microsoft-authentication-library-for-python-723 +azuread__microsoft-authentication-library-for-python-730 +azuread__microsoft-authentication-library-for-python-795 +babel__babili-543 +babel__babili-553 +babel__babili-587 +babel__babili-626 +babel__babili-638 +babel__minify-349 +babel__minify-531 +babel__minify-613 +babel__minify-705 +babel__minify-712 +babel__minify-733 +babel__minify-754 +babel__minify-755 +babel__minify-828 +babel__minify-830 +babel__minify-834 +babel__minify-841 +babel__minify-842 +babel__minify-882 +babel__minify-923 +backblaze__b2_command_line_tool-1070 +backblaze__b2_command_line_tool-259 +backblaze__b2_command_line_tool-295 +backblaze__b2_command_line_tool-302 +backblaze__b2_command_line_tool-304 +backblaze__b2_command_line_tool-332 +backblaze__b2_command_line_tool-360 +backblaze__b2_command_line_tool-389 +backblaze__b2_command_line_tool-420 +backblaze__b2_command_line_tool-488 +backblaze__b2_command_line_tool-499 +backblaze__b2_command_line_tool-643 +bacpop__ska.rust-30 +bacpop__ska.rust-31 +bacpop__ska.rust-37 +bacpop__ska.rust-40 +bacpop__ska.rust-61 +badgateway__oauth2-client-113 +badgateway__oauth2-client-126 +badgateway__oauth2-client-129 +badgateway__oauth2-client-134 +badgateway__oauth2-client-147 +badgateway__oauth2-client-148 +badgateway__oauth2-client-163 +badgateway__oauth2-client-84 +badgateway__oauth2-client-95 +badges__shields-10402 +badges__shields-10597 +badges__shields-2473 +badges__shields-2934 +badges__shields-2939 +badges__shields-3042 +badges__shields-3090 +badges__shields-3588 +badges__shields-3644 +badges__shields-3735 +badges__shields-3811 +badges__shields-3953 +badges__shields-4029 +badges__shields-4299 +badges__shields-4390 +badges__shields-4409 +badges__shields-4557 +badges__shields-4810 +badges__shields-5700 +badges__shields-5705 +badges__shields-5815 +badges__shields-6449 +badges__shields-6836 +baianat__vee-validate-1288 +baianat__vee-validate-1580 +baianat__vee-validate-1634 +baianat__vee-validate-1916 +baianat__vee-validate-1918 +baianat__vee-validate-1962 +baianat__vee-validate-2119 +baianat__vee-validate-2120 +baianat__vee-validate-868 +banesullivan__localtileserver-236 +banzaicloud__kafka-operator-630 +banzaicloud__logging-operator-527 +banzaicloud__logging-operator-531 +barryvdh__laravel-ide-helper-1116 +barryvdh__laravel-ide-helper-1196 +barryvdh__laravel-ide-helper-1262 +barryvdh__laravel-ide-helper-1292 +barryvdh__laravel-ide-helper-1352 +basho__riak-nodejs-client-152 +basho__riak-nodejs-client-162 +basho__riak-nodejs-client-166 +basho__riak-nodejs-client-71 +basho__riak-nodejs-client-76 +basho__riak-nodejs-client-83 +bashtage__arch-741 +bashtage__arch-750 +bashtage__linearmodels-634 +bazelbuild__bazelisk-190 +bazelbuild__bazelisk-256 +bazelbuild__bazelisk-427 +bazelbuild__buildtools-769 +bazelbuild__buildtools-772 +bazelbuild__buildtools-775 +bbc-news__psammead-180 +bbc__psammead-1066 +bbc__psammead-1067 +bbc__psammead-1215 +bbc__psammead-1243 +bbc__psammead-1352 +bbc__psammead-1362 +bbc__psammead-1408 +bbc__psammead-1430 +bbc__psammead-1477 +bbc__psammead-291 +bbc__psammead-406 +bbc__psammead-412 +bbc__psammead-446 +bbc__psammead-476 +bbc__psammead-491 +bbc__psammead-493 +bbc__psammead-504 +bbc__psammead-525 +bbc__psammead-550 +bbc__psammead-573 +bbc__psammead-585 +bbc__psammead-587 +bbc__psammead-609 +bbc__psammead-611 +bbc__psammead-617 +bbc__psammead-634 +bbc__psammead-643 +bbc__psammead-644 +bbc__psammead-647 +bbc__psammead-649 +bbc__psammead-666 +bbc__psammead-674 +bbc__psammead-747 +bbc__psammead-758 +bbc__psammead-764 +bbc__psammead-776 +bbc__psammead-787 +bbc__psammead-789 +bbc__psammead-935 +bbc__sqs-consumer-352 +bbc__sqs-consumer-379 +bbc__sqs-consumer-391 +bbc__sqs-consumer-394 +bbc__sqs-consumer-395 +bbc__sqs-consumer-401 +bbc__sqs-consumer-426 +bbc__sqs-consumer-470 +bbc__sqs-consumer-474 +bbc__sqs-consumer-489 +bbc__sqs-consumer-565 +bcoe__yargs-382 +beam-telemetry__telemetry_metrics_statsd-40 +beam-telemetry__telemetry_metrics_statsd-49 +beam-telemetry__telemetry_metrics_statsd-79 +beam-telemetry__telemetry_metrics_statsd-86 +bearer__bearer-1696 +beatlabs__harvester-109 +beatlabs__patron-604 +beatlabs__patron-624 +beatlabs__patron-771 +beeware__briefcase-2272 +behat__behat-1341 +behat__behat-1611 +behat__behat-1626 +behat__behat-1631 +behat__gherkin-294 +behat__gherkin-325 +behat__gherkin-340 +behat__gherkin-343 +behat__gherkin-357 +behat__gherkin-358 +behat__gherkin-359 +bem__bem-xjst-485 +bem__bh-115 +bem__bh-136 +bem__bh-139 +bem__bh-148 +bem__bh-161 +bem__bh-163 +benbjohnson__litestream-203 +benbjohnson__litestream-301 +benbjohnson__litestream-519 +benbjohnson__litestream-522 +benbjohnson__litestream-66 +benbjohnson__litestream-84 +benbjohnson__litestream-93 +benchopt__benchopt-361 +benchopt__benchopt-362 +benchopt__benchopt-381 +benchopt__benchopt-384 +benchopt__benchopt-414 +benchopt__benchopt-524 +benchopt__benchopt-697 +benchopt__benchopt-723 +benchopt__benchopt-725 +benhoyt__goawk-103 +benhoyt__goawk-123 +benhoyt__goawk-132 +benhoyt__goawk-133 +benhoyt__goawk-140 +benhoyt__goawk-147 +benhoyt__goawk-168 +benhoyt__goawk-169 +benhoyt__goawk-170 +benhoyt__goawk-173 +benhoyt__goawk-176 +benhoyt__goawk-184 +benhoyt__goawk-187 +benhoyt__goawk-192 +benhoyt__goawk-193 +benhoyt__goawk-199 +benhoyt__goawk-212 +benhoyt__goawk-214 +benhoyt__goawk-215 +benhoyt__goawk-216 +benhoyt__goawk-220 +benhoyt__goawk-230 +benhoyt__goawk-239 +benhoyt__goawk-240 +benhoyt__goawk-241 +benhoyt__goawk-63 +benhoyt__goawk-78 +benhoyt__goawk-83 +benhoyt__goawk-85 +bensampo__laravel-enum-180 +bensampo__laravel-enum-210 +bensampo__laravel-enum-264 +bensampo__laravel-enum-311 +benthosdev__benthos-2193 +bentoml__bentoml-3873 +bentoml__bentoml-5084 +benyap__resolve-tspaths-317 +benyap__resolve-tspaths-337 +benyap__resolve-tspaths-349 +berriai__litellm-10633 +berriai__litellm-10697 +berriai__litellm-10959 +berriai__litellm-11006 +berriai__litellm-11964 +berriai__litellm-1200 +berriai__litellm-12003 +berriai__litellm-12168 +berriai__litellm-12551 +berriai__litellm-3470 +berriai__litellm-4716 +berriai__litellm-4760 +berriai__litellm-5025 +berriai__litellm-5232 +berriai__litellm-6563 +berriai__litellm-8131 +berriai__litellm-8512 +berriai__litellm-9261 +berriai__litellm-9419 +berriai__litellm-9828 +bfgroup__b2-113 +bfgroup__b2-259 +bfgroup__b2-46 +biaslab__reactivemp.jl-435 +biaslab__reactivemp.jl-97 +bids-standard__pybids-1123 +bids-standard__pybids-574 +bids-standard__pybids-615 +bids-standard__pybids-810 +bikeshedder__deadpool-132 +bikeshedder__deadpool-179 +bikeshedder__deadpool-374 +bimmerconnected__bimmer_connected-183 +bimmerconnected__bimmer_connected-394 +bimmerconnected__bimmer_connected-449 +bimmerconnected__bimmer_connected-510 +bimmerconnected__bimmer_connected-584 +bimmerconnected__bimmer_connected-645 +bimmerconnected__bimmer_connected-646 +bimmerconnected__bimmer_connected-693 +bimmerconnected__bimmer_connected-695 +biocore__biom-format-918 +biocore__biom-format-919 +biocore__biom-format-921 +biocore__biom-format-922 +biocore__biom-format-923 +biocore__biom-format-929 +biocore__biom-format-930 +biotite-dev__biotite-619 +biotite-dev__biotite-651 +biotite-dev__biotite-653 +biotite-dev__biotite-659 +biotite-dev__biotite-795 +bitburner-official__bitburner-src-544 +bitburner-official__bitburner-src-720 +bitburner-official__bitburner-src-753 +bitburner-official__bitburner-src-754 +bitcoin-core__hwi-130 +bitcoin-core__secp256k1-513 +bitcoin-core__secp256k1-587 +bitcoin-core__secp256k1-701 +bitcoinjs__bitcoinjs-lib-660 +bitcoinjs__bitcoinjs-lib-834 +bitcrowd__chromic_pdf-95 +bitfield__script-215 +bitmaelum__bitmaelum-suite-202 +bitshifter__glam-rs-187 +bitshifter__glam-rs-33 +bitshifter__glam-rs-90 +biwascheme__biwascheme-349 +blacksmithgu__obsidian-dataview-1608 +blacksmithgu__obsidian-dataview-1882 +blacksmithgu__obsidian-dataview-2197 +blacksmithgu__obsidian-dataview-2261 +blacksmithgu__obsidian-dataview-2265 +blacksmithgu__obsidian-dataview-2271 +blaze__dask-756 +blaze__dask-776 +blaze__dask-972 +blevesearch__bleve-1179 +blevesearch__bleve-1416 +blevesearch__bleve-1465 +blevesearch__bleve-1636 +blitz-js__superjson-107 +blitz-js__superjson-111 +blitz-js__superjson-112 +blitz-js__superjson-115 +blitz-js__superjson-162 +blitz-js__superjson-244 +blitz-js__superjson-31 +blitz-js__superjson-37 +blitz-js__superjson-46 +blitz-js__superjson-59 +blitz-js__superjson-66 +blitz-js__superjson-78 +blitz-js__superjson-81 +bloomberg__memray-538 +bloomberg__memray-552 +bluekeyes__go-gitdiff-14 +bluekeyes__go-gitdiff-2 +bluekeyes__go-gitdiff-24 +bluekeyes__go-gitdiff-32 +bluekeyes__go-gitdiff-36 +bluekeyes__go-gitdiff-38 +bluekeyes__go-gitdiff-42 +bluekeyes__go-gitdiff-44 +bluekeyes__go-gitdiff-46 +bluenviron__gortsplib-316 +bluenviron__gortsplib-446 +bluesky__bluesky-1378 +bluesky__bluesky-1412 +bluesky__bluesky-1446 +bluesky__bluesky-1563 +bluesky__bluesky-1579 +bluesky__bluesky-1627 +bluesky__bluesky-1628 +bluesky__bluesky-1702 +bluesky__bluesky-1709 +bluesky__bluesky-1724 +bluesky__bluesky-1767 +bluesky__bluesky-1798 +bluesky__bluesky-1841 +bluesky__bluesky-1850 +bluss__arrayvec-159 +bluss__arrayvec-181 +bluss__arrayvec-183 +bluss__arrayvec-197 +bluss__rust-itertools-256 +bmish__eslint-doc-generator-481 +boa-dev__boa-4047 +boa-dev__boa-4307 +boardgameio__boardgame.io-691 +boardgameio__boardgame.io-752 +boardgameio__boardgame.io-791 +boardgameio__boardgame.io-819 +boardgameio__boardgame.io-821 +boardgameio__boardgame.io-823 +boardgameio__boardgame.io-825 +boardgameio__boardgame.io-832 +boardgameio__boardgame.io-838 +boardgameio__boardgame.io-839 +boardgameio__boardgame.io-857 +boardgameio__boardgame.io-879 +boardgameio__boardgame.io-885 +boardgameio__boardgame.io-894 +boardgameio__boardgame.io-918 +boardgameio__boardgame.io-957 +boardgameio__boardgame.io-963 +boardgameio__boardgame.io-972 +boardgameio__boardgame.io-985 +bojand__ghz-142 +bojand__ghz-143 +bojand__ghz-217 +bojand__ghz-272 +bojand__ghz-295 +bojand__ghz-376 +bombsimon__wsl-108 +bombsimon__wsl-123 +bombsimon__wsl-154 +bombsimon__wsl-173 +bombsimon__wsl-179 +bombsimon__wsl-23 +bombsimon__wsl-27 +bombsimon__wsl-30 +bombsimon__wsl-34 +bombsimon__wsl-37 +bombsimon__wsl-39 +bombsimon__wsl-45 +bombsimon__wsl-53 +bombsimon__wsl-55 +bombsimon__wsl-79 +borchero__switchboard-11 +borchero__switchboard-16 +borchero__switchboard-17 +borchero__switchboard-188 +borchero__switchboard-35 +borchero__switchboard-8 +boto__botocore-1144 +boto__botocore-1249 +boto__botocore-1269 +boto__botocore-472 +boto__botocore-572 +boto__botocore-573 +boto__botocore-590 +boto__botocore-626 +boto__botocore-648 +boto__botocore-746 +boto__botocore-830 +boto__botocore-852 +boto__botocore-866 +boto__botocore-871 +boto__botocore-886 +boto__botocore-887 +boto__botocore-985 +bower__bower-2361 +bower__bower-2368 +box-project__box-508 +box-project__box-561 +box__box-python-sdk-283 +box__box-python-sdk-37 +box__spout-807 +box__spout-810 +box__spout-814 +bpicode__fritzctl-117 +bpicode__fritzctl-67 +bpicode__fritzctl-72 +bpmn-io__bpmnlint-36 +bpmn-io__bpmnlint-73 +bpmn-io__bpmnlint-82 +bpmn-io__bpmnlint-85 +bradymholt__cronstrue-283 +bradymholt__cronstrue-297 +braintree__braintree-web-drop-in-649 +braintree__braintree-web-drop-in-675 +braintree__braintree-web-drop-in-683 +braintree__braintree-web-drop-in-703 +braintree__braintree-web-drop-in-734 +brandonbloom__fipp-69 +brandonbloom__fipp-78 +brazilian-utils__brutils-python-114 +brazilian-utils__brutils-python-116 +brazilian-utils__brutils-python-124 +brazilian-utils__brutils-python-125 +brazilian-utils__brutils-python-126 +brazilian-utils__brutils-python-201 +brazilian-utils__brutils-python-216 +brazilian-utils__brutils-python-218 +brazilian-utils__brutils-python-34 +brazilian-utils__brutils-python-36 +brazilian-utils__brutils-python-446 +brazilian-utils__brutils-python-52 +brazilian-utils__brutils-python-525 +brazilian-utils__brutils-python-54 +brazilian-utils__brutils-python-57 +brazilian-utils__brutils-python-58 +brazilian-utils__brutils-python-89 +brendanzab__codespan-134 +brendanzab__codespan-232 +brendanzab__codespan-241 +brendanzab__codespan-252 +brendanzab__codespan-253 +brendanzab__codespan-257 +brendanzab__codespan-260 +brendanzab__codespan-282 +brendanzab__codespan-312 +brendanzab__codespan-82 +brendanzab__codespan-96 +brenolf__polyjuice-58 +brenolf__polyjuice-59 +brenolf__polyjuice-64 +brenolf__polyjuice-65 +brenolf__polyjuice-66 +brenolf__polyjuice-67 +brenolf__polyjuice-71 +brettcannon__gidgethub-102 +brettcannon__gidgethub-122 +brettcannon__gidgethub-137 +brettcannon__gidgethub-174 +brettcannon__gidgethub-192 +brettcannon__gidgethub-194 +brettcannon__gidgethub-32 +brettcannon__gidgethub-35 +brettcannon__gidgethub-38 +brettcannon__gidgethub-46 +brian-team__brian2-1556 +brian-team__brian2-1609 +briannesbitt__carbon-2557 +briannesbitt__carbon-2665 +briannesbitt__carbon-2667 +briannesbitt__carbon-2669 +briannesbitt__carbon-2688 +briannesbitt__carbon-2693 +briannesbitt__carbon-2707 +briannesbitt__carbon-2709 +briannesbitt__carbon-2712 +briannesbitt__carbon-2719 +briannesbitt__carbon-2745 +briannesbitt__carbon-2750 +briannesbitt__carbon-2752 +briannesbitt__carbon-2762 +briannesbitt__carbon-2799 +briannesbitt__carbon-2801 +briannesbitt__carbon-2802 +briannesbitt__carbon-2804 +briannesbitt__carbon-2825 +briannesbitt__carbon-2839 +briannesbitt__carbon-2983 +briannesbitt__carbon-2987 +briannesbitt__carbon-2994 +briannesbitt__carbon-2997 +briannesbitt__carbon-3005 +briannesbitt__carbon-3033 +briannesbitt__carbon-3042 +briannesbitt__carbon-3144 +briannesbitt__carbon-3170 +brigand__babel-plugin-flow-react-proptypes-184 +brightcove__hot-shots-58 +brightcove__hot-shots-78 +brikev__express-jsdoc-swagger-146 +brikev__express-jsdoc-swagger-161 +brikev__express-jsdoc-swagger-172 +brikev__express-jsdoc-swagger-173 +brikev__express-jsdoc-swagger-177 +brikev__express-jsdoc-swagger-185 +brikev__express-jsdoc-swagger-37 +brikev__express-jsdoc-swagger-40 +brikev__express-jsdoc-swagger-43 +brikev__express-jsdoc-swagger-67 +brikev__express-jsdoc-swagger-80 +brikev__express-jsdoc-swagger-90 +brikev__express-jsdoc-swagger-93 +brimsec__zq-2077 +brimsec__zq-2098 +brimsec__zq-2173 +brimsec__zq-2189 +brimsec__zq-2194 +brimsec__zq-2309 +broadwaylamb__opencombine-107 +broadwaylamb__opencombine-112 +broadwaylamb__opencombine-187 +broadwaylamb__opencombine-39 +btcpayserver__btcpayserver-5538 +btcpayserver__btcpayserver-5643 +btcpayserver__btcpayserver-5986 +btcpayserver__btcpayserver-6050 +btcpayserver__btcpayserver-6191 +btcpayserver__btcpayserver-6228 +btcpayserver__btcpayserver-6251 +btcpayserver__btcpayserver-6254 +btcpayserver__btcpayserver-6386 +btcpayserver__btcpayserver-6427 +btcpayserver__btcpayserver-6723 +buchgr__bazel-remote-112 +buchgr__bazel-remote-122 +buchgr__bazel-remote-390 +buchgr__bazel-remote-398 +buchgr__bazel-remote-583 +buchgr__bazel-remote-595 +buchgr__bazel-remote-85 +bufbuild__buf-3111 +bufbuild__buf-3665 +bufbuild__buf-3696 +bufbuild__buf-3698 +buger__goreplay-836 +buger__goreplay-855 +buger__goreplay-881 +buger__goreplay-882 +buildo__react-components-293 +buildo__react-components-310 +buildo__react-components-474 +buildpack__pack-382 +buildpack__pack-406 +buildpacks__lifecycle-1309 +buildpacks__lifecycle-1347 +buildpacks__lifecycle-1348 +buildpacks__lifecycle-1374 +buildsafedev__bsf-132 +buildsafedev__bsf-133 +burntsushi__ripgrep-1237 +burntsushi__ripgrep-2885 +burntsushi__ripgrep-454 +burntsushi__ripgrep-723 +burntsushi__toml-332 +burntsushi__toml-339 +burntsushi__toml-414 +burntsushi__toml-418 +burrowers__garble-953 +bustlelabs__shep-113 +bustlelabs__shep-157 +bustlelabs__shep-203 +bustlelabs__shep-69 +busyorg__busy-1096 +busyorg__busy-1986 +busyorg__busy-2043 +busyorg__busy-2176 +busyorg__busy-922 +busyorg__busy-989 +buttercup__buttercup-core-339 +buxlabs__boxwood-594 +buxlabs__boxwood-610 +buxlabs__boxwood-615 +buxlabs__boxwood-619 +buxlabs__boxwood-621 +buxlabs__boxwood-630 +buxlabs__boxwood-637 +buxlabs__boxwood-639 +buxlabs__boxwood-644 +bvanelli__actualpy-56 +bvanelli__actualpy-74 +bvaughn__react-resizable-panels-463 +bvaughn__react-resizable-panels-465 +bxcodec__faker-137 +bxcodec__faker-40 +bytecodealliance__wasm-tools-1302 +bytecodealliance__wasm-tools-1590 +bytecodealliance__wasm-tools-1686 +bytecodealliance__wasm-tools-1688 +bytecodealliance__wasm-tools-1697 +bytecodealliance__wasm-tools-1714 +bytecodealliance__wasm-tools-1817 +bytecodealliance__wasm-tools-1851 +bytecodealliance__wasm-tools-1946 +bytecodealliance__wasm-tools-2107 +bytecodealliance__wasm-tools-2167 +bytecodealliance__wasm-tools-2189 +bytecodealliance__wasm-tools-2251 +bytecodealliance__wasm-tools-685 +bytecodealliance__wasmtime-2803 +bytecodealliance__wasmtime-2851 +bytedance__sonic-668 +bytedance__sonic-695 +bytedance__sonic-756 +bytedance__sonic-776 +bytedance__sonic-803 +c-cube__qcheck-244 +c-cube__qcheck-247 +c-cube__qcheck-253 +c-cube__qcheck-255 +c-cube__qcheck-298 +c-cube__qcheck-299 +c-cube__qcheck-344 +c2fo__vfs-101 +c2fo__vfs-190 +c2fo__vfs-246 +caarlos0__env-223 +caarlos0__env-227 +caarlos0__env-297 +caarlos0__env-321 +caarlos0__env-329 +caarlos0__env-340 +cachix__devenv-2018 +cadquery__cadquery-1622 +cadquery__cadquery-1623 +cadquery__cadquery-1690 +caicloud__nirvana-375 +caikit__caikit-233 +caikit__caikit-238 +caikit__caikit-253 +caikit__caikit-358 +caikit__caikit-366 +caikit__caikit-388 +caikit__caikit-405 +caikit__caikit-416 +caikit__caikit-430 +caikit__caikit-438 +caikit__caikit-447 +caikit__caikit-482 +caikit__caikit-508 +caikit__caikit-516 +caikit__caikit-583 +caikit__caikit-657 +caikit__caikit-662 +caikit__caikit-681 +caikit__caikit-708 +cakephp__chronos-323 +cakephp__chronos-435 +cakephp__chronos-459 +callowayproject__bump-my-version-111 +callowayproject__bump-my-version-125 +callowayproject__bump-my-version-147 +callowayproject__bump-my-version-156 +callowayproject__bump-my-version-166 +callowayproject__bump-my-version-180 +callowayproject__bump-my-version-183 +callowayproject__bump-my-version-213 +callowayproject__bump-my-version-239 +callowayproject__bump-my-version-325 +callowayproject__bump-my-version-326 +callowayproject__bump-my-version-347 +callowayproject__bump-my-version-36 +callowayproject__bump-my-version-63 +callstack__react-native-paper-1057 +callstack__react-native-paper-2808 +callstack__react-native-paper-394 +callstack__react-native-paper-494 +callstack__react-native-paper-972 +callstack__react-native-paper-992 +callstack__react-native-paper-997 +calmm-js__partial.lenses-48 +calmm-js__partial.lenses-69 +camunda__camunda-platform-helm-1840 +canjs__can-zone-103 +canjs__can-zone-119 +canjs__can-zone-138 +canjs__can-zone-194 +canonical__operator-1074 +canonical__operator-1599 +canonical__operator-1631 +canonical__operator-601 +caolan__async-1542 +caolan__async-1569 +caolan__async-1621 +caolan__async-1628 +caolan__async-1633 +caolan__async-1640 +caolan__async-1641 +capitalone__datacompy-404 +capricorn86__happy-dom-516 +capricorn86__happy-dom-528 +capricorn86__happy-dom-539 +capricorn86__happy-dom-601 +capricorn86__happy-dom-615 +capricorn86__happy-dom-619 +capricorn86__happy-dom-623 +capricorn86__happy-dom-626 +capricorn86__happy-dom-629 +capricorn86__happy-dom-630 +capricorn86__happy-dom-696 +capricorn86__happy-dom-710 +capricorn86__happy-dom-713 +capricorn86__happy-dom-723 +capricorn86__happy-dom-727 +capricorn86__happy-dom-752 +capricorn86__happy-dom-758 +capricorn86__happy-dom-772 +capricorn86__happy-dom-782 +capricorn86__happy-dom-786 +capricorn86__happy-dom-806 +capricorn86__happy-dom-824 +capricorn86__happy-dom-852 +capricorn86__happy-dom-861 +capricorn86__happy-dom-893 +capricorn86__happy-dom-897 +cargo-generate__cargo-generate-639 +cargo-generate__cargo-generate-671 +cargo-generate__cargo-generate-677 +cargo-generate__cargo-generate-691 +cargo-generate__cargo-generate-692 +carstenbauer__threadpinning.jl-49 +cartodb__cartoframes-1105 +casbin__casbin-1229 +casbin__casbin-1307 +casbin__casbin-1406 +casbin__casbin-1491 +casbin__casbin-325 +casbin__casbin-331 +casbin__casbin-392 +casbin__casbin-490 +casbin__casbin-974 +casey__just-1116 +casey__just-1174 +casey__just-1339 +casey__just-1354 +casey__just-1393 +casey__just-1713 +casey__just-1745 +casey__just-1809 +casey__just-1833 +casey__just-1845 +casey__just-1911 +casey__just-2065 +casey__just-2069 +casey__just-2085 +casey__just-2111 +casey__just-2112 +casey__just-2158 +casey__just-2180 +casey__just-2256 +casey__just-2259 +casey__just-2329 +casey__just-2437 +casey__just-2440 +casey__just-2460 +casey__just-2462 +casey__just-2592 +casey__just-2660 +casey__just-2785 +casey__just-2816 +cayleygraph__cayley-776 +cayleygraph__cayley-848 +cayleygraph__cayley-849 +cberner__redb-1023 +cdent__gabbi-342 +cdimascio__express-openapi-validator-809 +cdimascio__express-openapi-validator-863 +cdimascio__express-openapi-validator-866 +cdimascio__express-openapi-validator-955 +cdk8s-team__cdk8s-plus-2170 +cdk8s-team__cdk8s-plus-2302 +cdk8s-team__cdk8s-plus-2964 +cdk8s-team__cdk8s-plus-3508 +cdk8s-team__cdk8s-plus-4483 +cdk8s-team__cdk8s-plus-958 +cdk8s-team__cdk8s-plus-962 +cdklabs__cdk-pipelines-github-1105 +cedar-policy__cedar-1405 +cedar-policy__cedar-1473 +cedar-policy__cedar-1510 +cedar-policy__cedar-1551 +cedar-policy__cedar-1562 +cedar-policy__cedar-1634 +cedar-policy__cedar-1652 +cekit__cekit-818 +cekit__cekit-836 +cekit__cekit-932 +cekit__cekit-937 +cekit__cekit-940 +celery__celery-7470 +celery__celery-7544 +celery__celery-7608 +celery__celery-7609 +celery__celery-7858 +celery__celery-7945 +celery__celery-7951 +celery__celery-8143 +celery__celery-8301 +celery__celery-8312 +celery__celery-8374 +celery__celery-8383 +celery__celery-8385 +celery__celery-8462 +celery__celery-8806 +celery__celery-8982 +celery__celery-8984 +celery__celery-9247 +celery__celery-9331 +celery__celery-9348 +celery__celery-9392 +celery__celery-9393 +celery__celery-9465 +celery__celery-9614 +celery__celery-9669 +celestiaorg__celestia-core-2199 +celestiaorg__celestia-core-2223 +celestiaorg__nmt-102 +celestiaorg__nmt-113 +celestiaorg__nmt-172 +celestiaorg__nmt-179 +celestiaorg__nmt-182 +celestiaorg__nmt-187 +celestiaorg__nmt-188 +celestiaorg__nmt-192 +celestiaorg__nmt-291 +celestiaorg__nmt-47 +celestiaorg__nmt-90 +census-ecosystem__opencensus-go-exporter-stackdriver-152 +census-ecosystem__opencensus-go-exporter-stackdriver-231 +census-ecosystem__opencensus-go-exporter-stackdriver-238 +census-instrumentation__opencensus-go-1156 +census-instrumentation__opencensus-go-1183 +census-instrumentation__opencensus-go-1196 +census-instrumentation__opencensus-go-1218 +census-instrumentation__opencensus-go-251 +census-instrumentation__opencensus-python-108 +census-instrumentation__opencensus-python-144 +census-instrumentation__opencensus-python-150 +census-instrumentation__opencensus-python-156 +census-instrumentation__opencensus-python-165 +census-instrumentation__opencensus-python-246 +census-instrumentation__opencensus-python-410 +census-instrumentation__opencensus-service-119 +census-instrumentation__opencensus-service-120 +ceph__ceph-csi-3290 +ceph__go-ceph-208 +ceph__go-ceph-221 +ceph__go-ceph-235 +ceph__go-ceph-364 +ceph__go-ceph-407 +ceph__go-ceph-447 +ceph__go-ceph-480 +ceph__go-ceph-490 +ceph__go-ceph-502 +ceph__go-ceph-506 +ceph__go-ceph-795 +ceph__go-ceph-799 +ceph__go-ceph-889 +ceph__go-ceph-929 +cerbos__cerbos-1550 +cerbos__cerbos-1645 +cerbos__cerbos-1655 +cerbos__cerbos-1717 +cerbos__cerbos-2403 +cerbos__cerbos-2513 +cfug__dio-1671 +cfug__dio-1975 +cfug__dio-2029 +cfug__dio-2094 +cfug__dio-2205 +cfug__dio-2239 +cfug__dio-2247 +cfug__dio-2257 +cfug__dio-2297 +cgrand__xforms-45 +chaijs__chai-1008 +chaijs__chai-1012 +chaijs__chai-1101 +chaijs__chai-661 +chaijs__chai-668 +chaijs__chai-701 +chaijs__chai-724 +chaijs__chai-728 +chaijs__chai-739 +chaijs__chai-758 +chaijs__chai-761 +chaijs__chai-774 +chaijs__chai-782 +chaijs__chai-799 +chaijs__chai-924 +chaijs__chai-990 +chainguard-dev__apko-1672 +chainguard-dev__apko-465 +chanind__hanzi-writer-102 +chanind__hanzi-writer-131 +chanind__hanzi-writer-146 +chanind__hanzi-writer-156 +chanind__hanzi-writer-217 +chanind__hanzi-writer-294 +chanind__hanzi-writer-295 +chanind__hanzi-writer-63 +chanind__hanzi-writer-68 +chanind__hanzi-writer-74 +chanind__hanzi-writer-86 +chanind__hanzi-writer-92 +chanind__hanzi-writer-93 +chanind__hanzi-writer-95 +chanzuckerberg__fogg-412 +chanzuckerberg__fogg-465 +chanzuckerberg__fogg-731 +chanzuckerberg__terraform-provider-snowflake-624 +chanzuckerberg__terraform-provider-snowflake-768 +chanzuckerberg__terraform-provider-snowflake-990 +char0n__ramda-adjunct-1080 +char0n__ramda-adjunct-1112 +char0n__ramda-adjunct-1116 +char0n__ramda-adjunct-1125 +char0n__ramda-adjunct-1130 +char0n__ramda-adjunct-1131 +char0n__ramda-adjunct-1132 +char0n__ramda-adjunct-1134 +char0n__ramda-adjunct-1139 +char0n__ramda-adjunct-1421 +char0n__ramda-adjunct-1612 +char0n__ramda-adjunct-1616 +char0n__ramda-adjunct-1708 +char0n__ramda-adjunct-1713 +char0n__ramda-adjunct-1714 +char0n__ramda-adjunct-826 +char0n__ramda-adjunct-831 +charmbracelet__bubbletea-1372 +charmbracelet__bubbletea-215 +charmbracelet__bubbletea-415 +charmbracelet__bubbletea-455 +charmbracelet__bubbletea-467 +charmbracelet__bubbletea-533 +charmbracelet__bubbletea-537 +charmbracelet__bubbletea-570 +chartjs__chartjs-plugin-zoom-488 +chartjs__chartjs-plugin-zoom-544 +chartjs__chartjs-plugin-zoom-889 +chartjs__chartjs-plugin-zoom-896 +cheeriojs__cheerio-827 +chef__automate-3633 +chef__automate-4110 +chezou__tabula-py-112 +chezou__tabula-py-135 +chezou__tabula-py-151 +chezou__tabula-py-39 +chicio__id3tageditor-54 +chicio__id3tageditor-64 +chicio__id3tageditor-99 +chimurai__http-proxy-middleware-509 +chimurai__http-proxy-middleware-512 +chimurai__http-proxy-middleware-563 +chimurai__http-proxy-middleware-823 +chimurai__http-proxy-middleware-989 +christianmurphy__postcss-combine-duplicated-selectors-94 +christophebougere__asl-validator-102 +christophebougere__asl-validator-105 +christophebougere__asl-validator-107 +christophebougere__asl-validator-109 +christophebougere__asl-validator-139 +christophebougere__asl-validator-145 +christophebougere__asl-validator-66 +christophebougere__asl-validator-82 +christophebougere__asl-validator-83 +christophebougere__asl-validator-85 +christophebougere__asl-validator-91 +christophebougere__asl-validator-95 +christophebougere__asl-validator-98 +chrovis__cljam-268 +cilium__cilium-12521 +cinar__indicatorts-103 +cinar__indicatorts-29 +cinar__indicatorts-30 +cinar__indicatorts-32 +cinar__indicatorts-35 +cinar__indicatorts-40 +cinar__indicatorts-427 +cinar__indicatorts-428 +cinar__indicatorts-459 +cinar__indicatorts-92 +cinar__indicatorts-94 +circuitscape__circuitscape.jl-422 +clap-rs__clap-3170 +clap-rs__clap-3175 +clap-rs__clap-3179 +clap-rs__clap-3188 +clap-rs__clap-3196 +clap-rs__clap-3212 +clap-rs__clap-3225 +clap-rs__clap-3311 +clap-rs__clap-3334 +clap-rs__clap-3391 +clap-rs__clap-3394 +clap-rs__clap-3670 +clap-rs__clap-3689 +clap-rs__clap-3692 +clap-rs__clap-3775 +clap-rs__clap-3960 +clap-rs__clap-3968 +clap-rs__clap-3974 +clap-rs__clap-3989 +clap-rs__clap-3990 +clap-rs__clap-4005 +clap-rs__clap-4080 +clap-rs__clap-4081 +clap-rs__clap-4159 +clap-rs__clap-4412 +clap-rs__clap-5873 +clastix__kamaji-611 +cli__cli-10180 +cli__cli-10324 +cli__cli-10327 +cli__cli-10329 +cli__cli-10354 +cli__cli-10362 +cli__cli-10363 +cli__cli-10364 +cli__cli-10374 +cli__cli-10384 +cli__cli-10388 +cli__cli-10398 +cli__cli-10413 +cli__cli-10429 +cli__cli-10456 +cli__cli-10458 +cli__cli-10539 +cli__cli-10609 +cli__cli-10625 +cli__cli-10660 +cli__cli-10680 +cli__cli-10901 +cli__cli-10937 +cli__cli-10941 +cli__cli-11038 +cli__cli-9868 +clj-commons__aleph-651 +clj-commons__aleph-666 +clj-commons__aleph-714 +clj-commons__hickory-89 +clj-commons__manifold-195 +clj-commons__marginalia-183 +clj-pdf__clj-pdf-188 +clojure-lsp__clojure-lsp-101 +clojure-lsp__clojure-lsp-21 +clojure-lsp__clojure-lsp-95 +cloudant__couchbackup-381 +cloudant__couchbackup-384 +cloudant__nodejs-cloudant-311 +cloudant__nodejs-cloudant-341 +cloudant__nodejs-cloudant-386 +cloudant__nodejs-cloudant-427 +cloudant__nodejs-cloudant-455 +cloudant__python-cloudant-504 +cloudevents__sdk-go-261 +cloudflare__cfssl-1249 +cloudflare__circl-517 +cloudflare__cloudflare-go-1016 +cloudflare__cloudflare-go-1035 +cloudflare__cloudflare-go-1046 +cloudflare__cloudflare-go-1066 +cloudflare__cloudflare-go-1088 +cloudflare__cloudflare-go-1243 +cloudflare__cloudflare-go-1278 +cloudflare__cloudflare-go-1322 +cloudflare__cloudflare-go-1338 +cloudflare__cloudflare-go-1365 +cloudflare__cloudflare-go-1384 +cloudflare__cloudflare-go-1393 +cloudflare__cloudflare-go-1433 +cloudflare__cloudflare-go-1480 +cloudflare__cloudflare-go-2838 +cloudflare__cloudflare-go-355 +cloudflare__cloudflare-go-461 +cloudflare__cloudflare-go-547 +cloudflare__cloudflare-go-570 +cloudflare__cloudflare-go-573 +cloudflare__cloudflare-go-609 +cloudflare__cloudflare-go-636 +cloudflare__cloudflare-go-729 +cloudflare__cloudflare-go-757 +cloudflare__cloudflare-go-760 +cloudflare__cloudflare-go-850 +cloudflare__cloudflare-go-866 +cloudflare__cloudflare-go-912 +cloudflare__cloudflare-go-950 +cloudflare__cloudflare-go-959 +cloudflare__cloudflare-go-967 +cloudflare__cloudflare-go-971 +cloudflare__daphne-771 +cloudflare__wrangler-1543 +cloudflare__wrangler-1988 +clouditor__clouditor-1107 +clouditor__clouditor-426 +clouditor__clouditor-482 +cloudnativelabs__kube-router-1666 +cloudpipe__cloudpickle-104 +cloudpipe__cloudpickle-140 +cloudpipe__cloudpickle-153 +cloudpipe__cloudpickle-154 +cloudpipe__cloudpickle-188 +cloudpipe__cloudpickle-189 +cloudpipe__cloudpickle-208 +cloudpipe__cloudpickle-210 +cloudpipe__cloudpickle-254 +cloudpipe__cloudpickle-264 +cloudpipe__cloudpickle-314 +cloudpipe__cloudpickle-325 +cloudpipe__cloudpickle-329 +cloudpipe__cloudpickle-384 +cloudpipe__cloudpickle-392 +cloudpipe__cloudpickle-495 +cloudpipe__cloudpickle-57 +cloudpipe__cloudpickle-72 +cloudreach__sceptre-206 +cloudreach__sceptre-220 +cloudreach__sceptre-258 +cloudreach__sceptre-270 +cloudreach__sceptre-371 +cloudreach__sceptre-381 +cloudreach__sceptre-408 +cloudreach__sceptre-413 +cloudreach__sceptre-415 +cloudreach__sceptre-434 +cloudreach__sceptre-442 +cloudreach__sceptre-460 +cloudreach__sceptre-473 +cloudspannerecosystem__harbourbridge-104 +cloudspannerecosystem__harbourbridge-138 +cloudspannerecosystem__harbourbridge-203 +cloudspannerecosystem__harbourbridge-204 +cloudspannerecosystem__harbourbridge-214 +cloudspannerecosystem__harbourbridge-262 +cloudspannerecosystem__harbourbridge-312 +cloudspannerecosystem__memefish-118 +cloudspannerecosystem__memefish-145 +cloudspannerecosystem__memefish-154 +cloudspannerecosystem__memefish-155 +cloudspannerecosystem__memefish-161 +cloudspannerecosystem__memefish-163 +cloudspannerecosystem__memefish-166 +cloudspannerecosystem__memefish-182 +cloudspannerecosystem__memefish-191 +cloudspannerecosystem__memefish-194 +cloudspannerecosystem__memefish-197 +cloudspannerecosystem__memefish-207 +cloudspannerecosystem__memefish-215 +cloudspannerecosystem__memefish-219 +cloudspannerecosystem__memefish-220 +cloudtools__troposphere-1968 +cloudtools__troposphere-2055 +cloudtools__troposphere-2064 +cloudtools__troposphere-2087 +cloudtools__troposphere-2182 +cloudtools__troposphere-2191 +cloudwego__hertz-1181 +cloudwego__hertz-1264 +cloudwego__hertz-258 +cloudwego__hertz-269 +cloudwego__hertz-321 +cloudwego__hertz-367 +cloudwego__hertz-375 +cloudwego__hertz-401 +cloudwego__hertz-456 +cloudwego__hertz-876 +cloudykit__jet-154 +cloudykit__jet-156 +cloudykit__jet-159 +cloudykit__jet-169 +cloudykit__jet-182 +clusterlabs__ha_cluster_exporter-118 +clusterlabs__ha_cluster_exporter-216 +clusterlabs__ha_cluster_exporter-221 +clusternet__clusternet-885 +cobalt-org__cobalt.rs-1054 +cobalt-org__cobalt.rs-1090 +cobalt-org__cobalt.rs-1230 +cobalt-org__cobalt.rs-1241 +cobalt-org__liquid-rust-402 +cobalt-org__liquid-rust-403 +cobalt-org__liquid-rust-404 +cobalt-org__liquid-rust-423 +cobalt-org__liquid-rust-424 +cobalt-org__liquid-rust-506 +cobalt-org__liquid-rust-556 +cobalt-org__liquid-rust-77 +cockroachdb__pebble-1875 +cockroachdb__pebble-2715 +cockroachdb__pebble-2718 +cockroachdb__pebble-2878 +cockroachdb__pebble-2898 +cockroachdb__pebble-2900 +cockroachdb__pebble-2936 +cockroachdb__pebble-2949 +cockroachdb__pebble-813 +code-ready__crc-3333 +codeception__codeception-6409 +codeception__codeception-6477 +codeception__codeception-6610 +codeception__codeception-6626 +codecov__uploader-286 +codecov__uploader-328 +codecov__uploader-331 +codecov__uploader-363 +codecov__uploader-467 +codecov__uploader-793 +codecov__uploader-831 +codecov__uploader-944 +codeforphilly__chime-175 +codeforphilly__chime-190 +codeforphilly__chime-216 +codeforphilly__chime-218 +codeforphilly__chime-276 +codeforphilly__chime-418 +codeforphilly__chime-559 +codekie__openapi-examples-validator-145 +codekie__openapi-examples-validator-179 +codekie__openapi-examples-validator-198 +codekie__openapi-examples-validator-43 +codekie__openapi-examples-validator-46 +codekie__openapi-examples-validator-74 +codekie__openapi-examples-validator-81 +codemanki__cloudscraper-127 +codemanki__cloudscraper-137 +codemanki__cloudscraper-159 +codemanki__cloudscraper-205 +codemanki__cloudscraper-260 +codenotary__immudb-1839 +codenotary__immudb-756 +coder__envbuilder-213 +coder__envbuilder-290 +coder__envbuilder-381 +coder__envbuilder-389 +coder__envbuilder-398 +coder__envbuilder-406 +codezonediitj__pydatastructs-118 +codezonediitj__pydatastructs-125 +codezonediitj__pydatastructs-126 +codezonediitj__pydatastructs-127 +codezonediitj__pydatastructs-130 +codezonediitj__pydatastructs-143 +codezonediitj__pydatastructs-152 +codezonediitj__pydatastructs-163 +codezonediitj__pydatastructs-165 +codezonediitj__pydatastructs-177 +codezonediitj__pydatastructs-211 +codezonediitj__pydatastructs-219 +codezonediitj__pydatastructs-221 +codezonediitj__pydatastructs-222 +codezonediitj__pydatastructs-238 +codezonediitj__pydatastructs-253 +codezonediitj__pydatastructs-299 +codezonediitj__pydatastructs-312 +codezonediitj__pydatastructs-314 +codezonediitj__pydatastructs-315 +codezonediitj__pydatastructs-321 +codezonediitj__pydatastructs-328 +codezonediitj__pydatastructs-519 +codezonediitj__pydatastructs-538 +codezonediitj__pydatastructs-542 +codezonediitj__pydatastructs-643 +codezonediitj__pydatastructs-661 +codezonediitj__pydatastructs-85 +codezonediitj__pydatastructs-99 +codypearce__material-bread-136 +codypearce__material-bread-173 +codypearce__material-bread-175 +codypearce__material-bread-177 +codypearce__material-bread-192 +codypearce__material-bread-209 +cofacts__rumors-api-344 +cogent3__cogent3-1001 +cogent3__cogent3-1279 +cogent3__cogent3-1449 +cogent3__cogent3-1514 +cogent3__cogent3-1622 +cogent3__cogent3-1650 +cogent3__cogent3-1668 +cogent3__cogent3-1692 +cogent3__cogent3-1709 +cogent3__cogent3-1757 +cogent3__cogent3-1780 +cogent3__cogent3-1937 +cogent3__cogent3-1951 +cogent3__cogent3-2013 +cogent3__cogent3-2025 +cogent3__cogent3-2050 +cogent3__cogent3-2131 +cogent3__cogent3-2138 +cogent3__cogent3-2269 +coinbase__rosetta-sdk-go-414 +colinhacks__zod-4377 +colinhacks__zod-4385 +colinhacks__zod-4386 +colinhacks__zod-4861 +collective__icalendar-829 +collective__icalendar-834 +collective__icalendar-835 +collective__icalendar-878 +collective__icalendar-879 +collective__icalendar-880 +collective__icalendar-882 +cometbft__cometbft-3045 +commanded__commanded-105 +commanded__commanded-121 +commanded__commanded-333 +commanded__commanded-342 +commanded__commanded-363 +commanded__commanded-372 +commanded__commanded-380 +commanded__commanded-393 +commanded__commanded-406 +comonicon__comonicon.jl-146 +comonicon__comonicon.jl-162 +comonicon__comonicon.jl-169 +comonicon__comonicon.jl-200 +comonicon__comonicon.jl-202 +comonicon__comonicon.jl-205 +comonicon__comonicon.jl-217 +comonicon__comonicon.jl-219 +comonicon__comonicon.jl-221 +comonicon__comonicon.jl-227 +comonicon__comonicon.jl-229 +compiler-explorer__compiler-explorer-6350 +compiler-explorer__compiler-explorer-6701 +compose-spec__compose-go-122 +compose-spec__compose-go-784 +compose-spec__compose-go-792 +composer-unused__composer-unused-673 +compuives__codesandbox-client-321 +conan-io__conan-13041 +conan-io__conan-17920 +conan-io__conan-18327 +conan-io__conan-18385 +conan-io__conan-18429 +conan-io__conan-18444 +conan-io__conan-18572 +conan-io__conan-package-tools-608 +conda-incubator__grayskull-238 +conda-incubator__grayskull-399 +conda-incubator__grayskull-409 +conda__conda-1807 +conda__conda-1808 +conda__conda-6128 +conda__conda-6131 +conda__conda-7162 +conda__conda-7598 +conda__conda-7722 +conda__conda-7826 +conda__conda-8015 +conda__conda-8184 +conda__conda-lock-374 +conda__conda-lock-772 +conda__conda-lock-802 +consensys__mythril-classic-596 +containerd__containerd-10980 +containernetworking__cni-1062 +containers__image-2767 +containers__podman-18713 +containous__maesh-679 +containous__maesh-686 +containous__traefik-5372 +containrrr__watchtower-1010 +containrrr__watchtower-1027 +containrrr__watchtower-1116 +containrrr__watchtower-1123 +containrrr__watchtower-1142 +containrrr__watchtower-1337 +containrrr__watchtower-1373 +containrrr__watchtower-1481 +containrrr__watchtower-1526 +containrrr__watchtower-1542 +containrrr__watchtower-1574 +containrrr__watchtower-1626 +containrrr__watchtower-1784 +containrrr__watchtower-1801 +containrrr__watchtower-515 +containrrr__watchtower-731 +containrrr__watchtower-793 +containrrr__watchtower-869 +containrrr__watchtower-877 +containrrr__watchtower-907 +containrrr__watchtower-990 +conventional-changelog__standard-version-630 +coopcycle__coopcycle-web-4972 +copier-org__copier-1561 +copier-org__copier-1589 +copier-org__copier-1597 +copier-org__copier-1716 +copier-org__copier-1785 +copier-org__copier-1820 +copier-org__copier-1886 +copier-org__copier-1948 +copier-org__copier-1998 +copier-org__copier-2007 +copier-org__copier-2032 +copier-org__copier-2067 +copier-org__copier-2145 +copier-org__copier-2189 +corazawaf__coraza-1379 +corazawaf__coraza-559 +corazawaf__coraza-659 +corazawaf__coraza-720 +corazawaf__coraza-725 +core-gatech-group__serpent-tools-154 +core-gatech-group__serpent-tools-21 +core-gatech-group__serpent-tools-220 +core-gatech-group__serpent-tools-227 +core-gatech-group__serpent-tools-24 +core-gatech-group__serpent-tools-255 +core-gatech-group__serpent-tools-268 +core-gatech-group__serpent-tools-272 +core-gatech-group__serpent-tools-273 +core-gatech-group__serpent-tools-288 +core-gatech-group__serpent-tools-289 +core-gatech-group__serpent-tools-306 +core-gatech-group__serpent-tools-315 +core-gatech-group__serpent-tools-34 +core-gatech-group__serpent-tools-346 +core-gatech-group__serpent-tools-35 +core-gatech-group__serpent-tools-4 +core-gatech-group__serpent-tools-447 +core-gatech-group__serpent-tools-456 +core-gatech-group__serpent-tools-481 +core-gatech-group__serpent-tools-517 +core-gatech-group__serpent-tools-72 +core-gatech-group__serpent-tools-85 +coreoffice__corexlsx-109 +coreoffice__corexlsx-122 +coreoffice__corexlsx-135 +coreoffice__corexlsx-139 +coreoffice__corexlsx-143 +coreos__dex-1003 +coreos__dex-1056 +coreos__dex-540 +coreos__dex-658 +coreos__dex-772 +coreos__dex-792 +coreos__dex-809 +coreruleset__go-ftw-283 +corneliusweig__ketall-49 +corneliusweig__ketall-8 +corneliusweig__ketall-98 +cornellius-gp__gpytorch-216 +cornellius-gp__gpytorch-223 +cornellius-gp__gpytorch-296 +cornellius-gp__gpytorch-407 +cornellius-gp__gpytorch-484 +cornellius-gp__gpytorch-656 +cornellius-gp__gpytorch-782 +cornellius-gp__gpytorch-973 +cornellius-gp__gpytorch-977 +corteva__rioxarray-516 +corteva__rioxarray-559 +corteva__rioxarray-735 +corteva__rioxarray-817 +corteva__rioxarray-841 +coryodaniel__bonny-147 +coryodaniel__bonny-156 +cosmos__interchain-security-102 +cosmos__interchain-security-1146 +cosmos__interchain-security-118 +cosmos__interchain-security-177 +cosmos__interchain-security-504 +cosmos__interchain-security-542 +cosmos__interchain-security-565 +cosmos__relayer-1412 +cosmwasm__cosmwasm-1520 +cosmwasm__cosmwasm-1905 +cosmwasm__cosmwasm-1944 +cosmwasm__cosmwasm-2008 +cosmwasm__cosmwasm-2114 +cosmwasm__cosmwasm-2310 +cosmwasm__cosmwasm-2383 +cosmwasm__cosmwasm-2420 +cosmwasm__cosmwasm-2471 +cosmwasm__cw-multi-test-117 +cosmwasm__cw-multi-test-83 +cosmwasm__cw-multi-test-97 +cosmwasm__sylvia-179 +cosmwasm__sylvia-200 +cosmwasm__sylvia-213 +cosmwasm__sylvia-23 +cosmwasm__sylvia-247 +cosmwasm__sylvia-85 +couds__react-bulma-components-162 +couds__react-bulma-components-173 +couds__react-bulma-components-181 +couds__react-bulma-components-240 +couds__react-bulma-components-288 +couds__react-bulma-components-293 +couds__react-bulma-components-337 +couds__react-bulma-components-375 +couds__react-bulma-components-376 +cpisciotta__xcbeautify-12 +cpisciotta__xcbeautify-284 +cpisciotta__xcbeautify-294 +cpisciotta__xcbeautify-305 +cpisciotta__xcbeautify-307 +cpisciotta__xcbeautify-311 +cpisciotta__xcbeautify-321 +cpisciotta__xcbeautify-322 +cpisciotta__xcbeautify-323 +cpisciotta__xcbeautify-324 +cpisciotta__xcbeautify-405 +cpisciotta__xcbeautify-75 +cpisciotta__xcbeautify-99 +cqfn__diktat-1008 +cqfn__diktat-1011 +cqfn__diktat-1014 +cqfn__diktat-1017 +cqfn__diktat-1022 +cqfn__diktat-1024 +cqfn__diktat-1035 +cqfn__diktat-1036 +cqfn__diktat-1050 +cqfn__diktat-1052 +cqfn__diktat-1072 +cqfn__diktat-1073 +cqfn__diktat-1096 +cqfn__diktat-1098 +cqfn__diktat-1102 +cqfn__diktat-1104 +cqfn__diktat-1108 +cqfn__diktat-1110 +cqfn__diktat-1111 +cqfn__diktat-1116 +cqfn__diktat-1119 +cqfn__diktat-1121 +cqfn__diktat-1123 +cqfn__diktat-1133 +cqfn__diktat-1171 +cqfn__diktat-1183 +cqfn__diktat-1190 +cqfn__diktat-1191 +cqfn__diktat-1192 +cqfn__diktat-1200 +cqfn__diktat-1201 +cqfn__diktat-1206 +cqfn__diktat-1230 +cqfn__diktat-1258 +cqfn__diktat-1276 +cqfn__diktat-1334 +cqfn__diktat-1354 +cqfn__diktat-1369 +cqfn__diktat-1387 +cqfn__diktat-1389 +cqfn__diktat-1410 +cqfn__diktat-1411 +cqfn__diktat-1416 +cqfn__diktat-1442 +cqfn__diktat-1445 +cqfn__diktat-1471 +cqfn__diktat-1486 +cqfn__diktat-1537 +cqfn__diktat-780 +cqfn__diktat-847 +cqfn__diktat-848 +cqfn__diktat-849 +cqfn__diktat-857 +cqfn__diktat-858 +cqfn__diktat-874 +cqfn__diktat-877 +cqfn__diktat-878 +cqfn__diktat-879 +cqfn__diktat-885 +cqfn__diktat-886 +cqfn__diktat-905 +cqfn__diktat-932 +cqfn__diktat-933 +cqfn__diktat-943 +cqfn__diktat-946 +cqfn__diktat-947 +cqfn__diktat-952 +cqfn__diktat-962 +cqfn__diktat-967 +cqfn__diktat-973 +cqfn__diktat-974 +cqfn__diktat-983 +cqfn__diktat-985 +cqfn__diktat-989 +cqfn__diktat-990 +crate-ci__typos-279 +crate-ci__typos-833 +crazy-max__diun-895 +crazy-max__ghaction-docker-meta-23 +crazy-max__ghaction-docker-meta-31 +crazy-max__ghaction-docker-meta-53 +crazy-max__ghaction-docker-meta-59 +crazy-max__ghaction-docker-meta-62 +crazy-max__ghaction-docker-meta-63 +crazy-max__ghaction-docker-meta-71 +crc-org__crc-4827 +creachadair__jrpc2-111 +creachadair__jrpc2-24 +creachadair__jrpc2-37 +creachadair__jrpc2-39 +creachadair__jrpc2-42 +creachadair__jrpc2-81 +createapi__createapi-104 +createapi__createapi-109 +createapi__createapi-118 +createapi__createapi-131 +createapi__createapi-133 +createapi__createapi-142 +crewaiinc__crewai-1818 +crewaiinc__crewai-2408 +crewaiinc__crewai-2495 +crewaiinc__crewai-2552 +crewaiinc__crewai-2570 +crewaiinc__crewai-2588 +crewaiinc__crewai-3150 +crossbeam-rs__crossbeam-999 +crossgl__crosstl-201 +crossgl__crosstl-202 +crossgl__crosstl-207 +crossgl__crosstl-249 +crossgl__crosstl-251 +crossgl__crosstl-260 +crossgl__crosstl-41 +crossgl__crosstl-95 +crossplane-contrib__provider-aws-1898 +crossplane-contrib__provider-aws-1909 +crossplane-contrib__provider-aws-1932 +crossplane-contrib__provider-aws-1966 +crossplane-contrib__provider-aws-1969 +crossplane-contrib__provider-aws-2000 +crossplane-contrib__provider-aws-2088 +crossplane-contrib__provider-aws-2117 +crossplane-contrib__provider-aws-2206 +crossplane-contrib__provider-aws-2221 +crossplane-contrib__provider-gitlab-154 +crossplane-contrib__provider-gitlab-156 +crossplane-contrib__provider-sql-148 +crossplane-contrib__provider-sql-168 +crossplane-contrib__provider-sql-171 +crossplane-contrib__provider-sql-192 +crossplane-contrib__provider-terraform-111 +crossplane-contrib__provider-terraform-123 +crossplane-contrib__provider-terraform-141 +crossplane-contrib__provider-terraform-28 +crossplane-contrib__provider-terraform-38 +crossplane-contrib__provider-terraform-48 +crossplane-contrib__provider-terraform-56 +crossplane-contrib__provider-terraform-67 +crossplane-contrib__provider-terraform-68 +crossplane-contrib__provider-terraform-72 +crossplane__crossplane-6303 +crossplane__crossplane-6535 +crossplane__crossplane-6588 +crossplane__crossplane-runtime-367 +crossplane__provider-aws-1068 +crossplane__provider-aws-1119 +crossplane__provider-aws-1129 +crossplane__provider-aws-1161 +crossplane__provider-aws-1207 +crossplane__provider-aws-1240 +crossplane__provider-aws-1283 +crossplane__provider-aws-617 +crossplane__provider-aws-701 +crossplane__provider-aws-781 +crossplane__provider-aws-793 +crossplane__provider-aws-807 +crossplane__provider-aws-824 +crossplane__provider-aws-860 +crossplane__provider-aws-988 +crsmithdev__arrow-792 +crustio__crust-393 +crustio__crust-629 +crypto-org-chain__chain-main-449 +crypto-org-chain__chain-main-464 +crypto-org-chain__chain-main-477 +cs-si__eodag-1262 +cs-si__eodag-1338 +cs-si__eodag-1536 +cs-si__eodag-1717 +cs-si__eodag-201 +cs-si__eodag-204 +cs-si__eodag-249 +cs-si__eodag-257 +cs-si__eodag-304 +cs-si__eodag-357 +cs-si__eodag-367 +cs-si__eodag-380 +cs-si__eodag-381 +cs-si__eodag-405 +cs-si__eodag-458 +cs-si__eodag-480 +cs-si__eodag-490 +cs-si__eodag-508 +cs-si__eodag-524 +cs-si__eodag-545 +cs-si__eodag-554 +cs-si__eodag-566 +cs-si__eodag-576 +cs-si__eodag-586 +cs-si__eodag-588 +cs-si__eodag-592 +cs-si__eodag-616 +cs-si__eodag-634 +cs-si__eodag-645 +cs-si__eodag-751 +cs-si__eodag-790 +cs-si__eodag-795 +cs-si__eodag-802 +cs-si__eodag-836 +cs-si__eodag-885 +cs-si__eodag-918 +cs-si__eodag-927 +cs-si__eodag-961 +cs-si__eodag-969 +cs-si__eodag-987 +cscfi__rems-1003 +cscfi__rems-1145 +cscfi__rems-1161 +cscfi__rems-1187 +cscfi__rems-1225 +cscfi__rems-1227 +cscfi__rems-1244 +cscfi__rems-1268 +cscfi__rems-1378 +cscfi__rems-1410 +cscfi__rems-1425 +cscfi__rems-1538 +cscfi__rems-1642 +cscfi__rems-3195 +cscfi__rems-3368 +csml-by-clevy__csml-engine-264 +csml-by-clevy__csml-engine-267 +csml-by-clevy__csml-engine-278 +csml-by-clevy__csml-engine-285 +csml-by-clevy__csml-engine-300 +csml-by-clevy__csml-engine-301 +csml-by-clevy__csml-engine-315 +csml-by-clevy__csml-engine-328 +cstenglein__raspiblitz-web-598 +cta-observatory__ctapipe-1872 +cta-observatory__ctapipe-1883 +cta-observatory__ctapipe-1893 +cta-observatory__ctapipe-1925 +cta-observatory__ctapipe-2042 +cta-observatory__ctapipe-2102 +cta-observatory__ctapipe-2288 +cta-observatory__ctapipe-2317 +cta-observatory__ctapipe-2320 +cta-observatory__ctapipe-2343 +cta-observatory__ctapipe-2375 +cta-observatory__ctapipe-2397 +cta-observatory__ctapipe-2403 +cta-observatory__ctapipe-2429 +cta-observatory__ctapipe-2430 +cta-observatory__ctapipe-2483 +cta-observatory__ctapipe-2485 +cta-observatory__ctapipe-2505 +cta-observatory__ctapipe-2602 +cta-observatory__ctapipe-2627 +cta-observatory__ctapipe-2655 +cta-observatory__ctapipe-2707 +cta-observatory__ctapipe-2732 +cta-observatory__ctapipe-2738 +ctfd__ctfd-2333 +ctfd__ctfd-2451 +ctfd__ctfd-263 +ctfd__ctfd-2767 +ctfd__ctfd-317 +ctfd__ctfd-336 +ctfd__ctfd-410 +ctfd__ctfd-432 +ctfd__ctfd-457 +ctfd__ctfd-470 +ctfd__ctfd-474 +ctfd__ctfd-760 +ctfd__ctfd-792 +ctfd__ctfd-798 +ctfd__ctfd-805 +ctfd__ctfd-899 +ctfd__ctfd-903 +ctreminiom__go-atlassian-259 +ctreminiom__go-atlassian-288 +ctripcorp__apollo-3507 +ctrlplusb__easy-peasy-190 +ctrlplusb__easy-peasy-27 +ctrlplusb__easy-peasy-874 +cubed-dev__cubed-410 +cubed-dev__cubed-462 +cubed-dev__cubed-465 +cubed-dev__cubed-516 +cubed-dev__cubed-528 +cubed-dev__cubed-540 +cubed-dev__cubed-572 +cubed-dev__cubed-596 +cubed-dev__cubed-691 +cubed-dev__cubed-700 +cucumber__godog-665 +cuthbertlab__music21-1040 +cuthbertlab__music21-1062 +cuthbertlab__music21-1063 +cuthbertlab__music21-1066 +cuthbertlab__music21-1138 +cuthbertlab__music21-1299 +cuthbertlab__music21-1337 +cuthbertlab__music21-1381 +cuthbertlab__music21-1475 +cuthbertlab__music21-1479 +cuthbertlab__music21-1725 +cuthbertlab__music21-1736 +cuthbertlab__music21-314 +cuthbertlab__music21-578 +cuthbertlab__music21-791 +cuthbertlab__music21-855 +cuthbertlab__music21-866 +cuthbertlab__music21-953 +cuthbertlab__music21-958 +cuthbertlab__music21-960 +cuthbertlab__music21-970 +cuttle-cards__cuttle-1038 +cuttle-cards__cuttle-1046 +cuttle-cards__cuttle-1052 +cuttle-cards__cuttle-976 +cuttle-cards__cuttle-981 +cuttle-cards__cuttle-984 +cuyz__valinor-490 +cuyz__valinor-493 +cuyz__valinor-497 +cuyz__valinor-498 +cuyz__valinor-504 +cuyz__valinor-506 +cuyz__valinor-507 +cuyz__valinor-510 +cuyz__valinor-512 +cuyz__valinor-514 +cuyz__valinor-515 +cuyz__valinor-521 +cuyz__valinor-534 +cuyz__valinor-596 +cuyz__valinor-597 +cuyz__valinor-604 +cuyz__valinor-610 +cuyz__valinor-613 +cuyz__valinor-620 +cuyz__valinor-643 +cveproject__cve-services-1005 +cveproject__cve-services-1029 +cveproject__cve-services-1078 +cveproject__cve-services-1098 +cveproject__cve-services-1104 +cveproject__cve-services-1107 +cveproject__cve-services-1117 +cveproject__cve-services-1122 +cveproject__cve-services-1222 +cveproject__cve-services-598 +cveproject__cve-services-599 +cveproject__cve-services-991 +cybertec-postgresql__pg_timetable-235 +cybertec-postgresql__pg_timetable-238 +cybertec-postgresql__pg_timetable-249 +cybertec-postgresql__pg_timetable-273 +cybertec-postgresql__pg_timetable-281 +cycloidio__terracost-23 +cycloidio__terracost-26 +cycloidio__terracost-30 +cycloidio__terracost-34 +cycloidio__terracost-35 +cycloidio__terracost-36 +cycloidio__terracost-40 +cycloidio__terracost-98 +cyclonedx__cdxgen-319 +cypress-io__eslint-plugin-cypress-13 +cypress-io__eslint-plugin-cypress-141 +cypress-io__eslint-plugin-cypress-189 +cypress-io__eslint-plugin-cypress-212 +cypress-io__eslint-plugin-cypress-59 +cypress-io__eslint-plugin-cypress-60 +d0c-s4vage__lookatme-153 +d0c-s4vage__pfp-109 +d0c-s4vage__pfp-112 +d0c-s4vage__pfp-114 +d0c-s4vage__pfp-116 +d0c-s4vage__pfp-121 +d0c-s4vage__pfp-123 +d0c-s4vage__pfp-126 +d0c-s4vage__pfp-128 +d0c-s4vage__pfp-99 +d3__d3-array-159 +d3__d3-array-196 +d3__d3-array-204 +d3__d3-array-205 +d3__d3-array-276 +d5__tengo-221 +d5__tengo-244 +d5__tengo-254 +d5__tengo-272 +d5__tengo-285 +d5__tengo-290 +d5__tengo-292 +d5__tengo-316 +d5__tengo-318 +d5__tengo-364 +d5__tengo-378 +d5__tengo-387 +d5__tengo-399 +d5__tengo-460 +da0-da0__dao-contracts-155 +da0-da0__dao-contracts-210 +da0-da0__dao-contracts-212 +da0-da0__dao-contracts-217 +da0-da0__dao-contracts-274 +da0-da0__dao-contracts-378 +da0-da0__dao-contracts-428 +da0-da0__dao-contracts-433 +dadi__api-102 +dadi__api-393 +dadi__api-402 +dadrus__heimdall-1047 +dadrus__heimdall-2537 +dadrus__heimdall-749 +dai-lab__copulas-104 +dai-lab__copulas-106 +dai-lab__copulas-54 +dai-lab__copulas-78 +dai-lab__copulas-81 +dai-lab__copulas-87 +dai-lab__copulas-92 +dai-lab__copulas-93 +dai-lab__copulas-94 +dai-shi__waku-1164 +dai-shi__waku-1203 +dai-shi__waku-789 +dai-shi__waku-925 +daisy__ace-130 +daixiang0__gci-142 +daixiang0__gci-147 +daixiang0__gci-148 +daixiang0__gci-81 +daixiang0__gci-94 +daixiang0__gci-99 +dalance__veryl-459 +dalibo__pev2-702 +dalibo__pev2-713 +dalibo__pev2-728 +damienharper__auditor-107 +damienharper__auditor-117 +damienharper__auditor-118 +damienharper__auditor-120 +damienharper__auditor-133 +damienharper__auditor-139 +damienharper__auditor-175 +damienharper__auditor-19 +damienharper__auditor-195 +damienharper__auditor-48 +damienharper__auditor-77 +damienharper__auditor-96 +dandavison__delta-220 +dandavison__delta-225 +danielb2__purdy.js-27 +danielgtaylor__huma-854 +danielgtaylor__restish-253 +danvergara__dblab-126 +danvergara__dblab-149 +danvergara__dblab-174 +danvergara__dblab-40 +danvergara__dblab-48 +danvergara__dblab-53 +danvergara__dblab-75 +danvergara__dblab-87 +danvk__literate-ts-102 +danvk__literate-ts-104 +danvk__literate-ts-145 +danvk__literate-ts-147 +danvk__literate-ts-150 +danvk__literate-ts-252 +danvk__literate-ts-261 +danvk__literate-ts-262 +danvk__literate-ts-54 +danvk__literate-ts-61 +danvk__literate-ts-63 +dapr__cli-1490 +dapr__components-contrib-1807 +dapr__components-contrib-1925 +dapr__components-contrib-3478 +dapr__dotnet-sdk-1173 +dapr__dotnet-sdk-1310 +darkreader__darkreader-2371 +darkreader__darkreader-2508 +darkreader__darkreader-2934 +darkreader__darkreader-3048 +darkreader__darkreader-3426 +darkreader__darkreader-3439 +darkreader__darkreader-3533 +darkreader__darkreader-3549 +darkskyapp__forecast-io-translations-121 +darkskyapp__forecast-io-translations-126 +darkskyapp__forecast-io-translations-128 +darkskyapp__forecast-io-translations-129 +darkskyapp__forecast-io-translations-130 +darkskyapp__forecast-io-translations-133 +darkskyapp__forecast-io-translations-137 +darkskyapp__forecast-io-translations-139 +darkskyapp__forecast-io-translations-141 +darkskyapp__forecast-io-translations-142 +darkskyapp__forecast-io-translations-148 +dart-lang__dartdoc-3193 +dart-lang__dartdoc-3216 +dart-lang__dartdoc-3372 +dart-lang__dartdoc-3393 +dart-lang__dartdoc-3401 +dart-lang__dartdoc-3446 +dart-lang__dartdoc-3658 +dart-lang__dartdoc-3682 +dart-lang__ffigen-187 +dart-lang__ffigen-192 +dart-lang__ffigen-499 +dasdae__dascore-407 +dasdae__dascore-421 +dasdae__dascore-426 +dasdae__dascore-464 +dasdae__dascore-476 +dashbitco__broadway_cloud_pub_sub-99 +dashbitco__nimble_options-128 +dashbitco__nimble_options-17 +dashbitco__nimble_options-18 +dashbitco__nimble_options-19 +dashbitco__nimble_options-24 +dashbitco__nimble_options-38 +dashbitco__nimble_options-43 +dashbitco__nimble_options-87 +dashbitco__nimble_options-96 +dask-contrib__dask-expr-866 +dask-contrib__dask-expr-872 +dask-contrib__dask-expr-901 +dask__dask-10113 +dask__dask-10485 +dask__dask-10734 +dask__dask-10970 +dask__dask-11311 +dask__dask-11747 +dask__dask-11760 +dask__dask-5861 +dask__dask-6331 +dask__dask-7142 +dask__dask-9627 +dask__dask-jobqueue-563 +dask__dask-jobqueue-584 +dask__dask-jobqueue-677 +databacker__mysql-backup-266 +databacker__mysql-backup-299 +databacker__mysql-backup-325 +databacker__mysql-backup-451 +databricks__dbt-databricks-1008 +databricks__dbt-databricks-1084 +databricks__dbt-databricks-861 +databricks__dbt-databricks-935 +databricks__dbt-databricks-995 +databrickslabs__terraform-provider-databricks-1370 +datadog__datadogpy-545 +datadog__datadogpy-555 +datadog__datadogpy-609 +datadog__datadogpy-625 +datadog__dd-trace-js-1884 +datadog__dd-trace-js-1934 +datadog__dd-trace-js-2132 +datadog__dd-trace-js-2146 +datadog__dd-trace-js-2249 +datadog__dd-trace-js-2363 +datadog__dd-trace-js-2687 +datadog__dd-trace-js-2880 +datadog__dd-trace-js-3420 +datadog__dd-trace-js-4471 +datadog__guarddog-108 +datadog__guarddog-156 +datadog__guarddog-162 +datadog__guarddog-163 +datadog__guarddog-176 +datadog__guarddog-342 +datadog__guarddog-419 +datadog__guarddog-83 +datalad__datalad-4963 +datalad__datalad-5603 +dataversioncontrol__dvc-562 +dataversioncontrol__dvc-680 +dataversioncontrol__dvc-692 +datreeio__datree-401 +datreeio__datree-450 +datreeio__datree-827 +davidhalter__jedi-1579 +davidhalter__jedi-1704 +davidhalter__jedi-1772 +davidhalter__jedi-2018 +davidlattimore__wild-452 +davidlattimore__wild-474 +davidlattimore__wild-591 +davidlattimore__wild-643 +davidlattimore__wild-879 +davidlattimore__wild-935 +davidlattimore__wild-967 +davisvaughan__slider-183 +dbader__node-datadog-metrics-137 +dbader__node-datadog-metrics-141 +dbader__node-datadog-metrics-69 +dbader__node-datadog-metrics-71 +dbader__node-datadog-metrics-73 +dbader__node-datadog-metrics-80 +dbader__node-datadog-metrics-99 +dbrgn__tealdeer-230 +dbrgn__tealdeer-236 +dbrgn__tealdeer-238 +dbrgn__tealdeer-254 +dbrgn__tealdeer-322 +dbt-athena__dbt-athena-324 +dbt-athena__dbt-athena-440 +dbt-athena__dbt-athena-512 +dbt-athena__dbt-athena-684 +dbt-athena__dbt-athena-79 +dbt-labs__dbt-bigquery-1251 +dbt-labs__dbt-bigquery-460 +dbt-labs__dbt-bigquery-888 +dbt-labs__dbt-bigquery-892 +dbt-labs__dbt-bigquery-902 +dbt-labs__dbt-redshift-258 +dbt-labs__dbt-redshift-420 +dbt-labs__dbt-redshift-473 +dbt-labs__dbt-redshift-836 +dbt-labs__dbt-redshift-841 +dbt-labs__dbt-redshift-895 +dbt-labs__dbt-redshift-950 +dbt-labs__dbt-redshift-970 +dbt-labs__dbt-snowflake-1067 +dbt-labs__dbt-snowflake-1107 +dbt-labs__dbt-snowflake-1110 +dbt-labs__dbt-snowflake-1169 +dbt-labs__dbt-snowflake-1289 +dbt-labs__dbt-snowflake-49 +dbt-labs__dbt-snowflake-65 +dbt-labs__dbt-snowflake-716 +dbus2__zbus-1256 +dbus2__zbus-1376 +dcastil__tailwind-merge-478 +dcastil__tailwind-merge-538 +dcastil__tailwind-merge-559 +dcastil__tailwind-merge-565 +dcastil__tailwind-merge-591 +dcs4cop__xcube-109 +dcs4cop__xcube-110 +dcs4cop__xcube-150 +dcs4cop__xcube-168 +dcs4cop__xcube-2 +dcs4cop__xcube-220 +dcs4cop__xcube-239 +dcs4cop__xcube-60 +dcs4cop__xcube-81 +dcs4cop__xcube-93 +ddev__ddev-6939 +ddev__ddev-6956 +ddev__ddev-6960 +ddev__ddev-7199 +decaffeinate__decaffeinate-2481 +decentralized-identity__did-jwt-288 +decred__dcrdex-240 +decred__dcrdex-327 +decred__dcrdex-386 +decred__dcrdex-440 +decred__dcrdex-458 +decred__dcrdex-477 +decred__dcrdex-719 +dedis__kyber-401 +deepmind__optax-467 +def-studio__telegraph-104 +def-studio__telegraph-153 +def-studio__telegraph-161 +def-studio__telegraph-65 +def-studio__telegraph-76 +def-studio__telegraph-80 +definitelytyped__dt-mergebot-448 +defstudio__telegraph-205 +defstudio__telegraph-206 +defstudio__telegraph-211 +defstudio__telegraph-216 +defstudio__telegraph-253 +defstudio__telegraph-256 +defstudio__telegraph-261 +defstudio__telegraph-263 +defstudio__telegraph-277 +defstudio__telegraph-306 +defstudio__telegraph-334 +defstudio__telegraph-335 +defstudio__telegraph-424 +defstudio__telegraph-502 +deislabs__ratify-1105 +deislabs__ratify-1134 +deislabs__ratify-116 +deislabs__ratify-1280 +deislabs__ratify-1343 +deislabs__ratify-166 +deislabs__ratify-452 +deislabs__ratify-493 +deislabs__ratify-498 +deislabs__ratify-604 +deislabs__ratify-636 +deislabs__ratify-667 +deislabs__ratify-768 +deislabs__ratify-769 +deislabs__ratify-815 +deislabs__ratify-883 +deislabs__ratify-957 +delgan__loguru-1236 +delgan__loguru-1238 +delgan__loguru-1297 +delgan__loguru-1299 +delgan__loguru-1303 +delgan__loguru-1304 +delgan__loguru-1306 +delgan__loguru-528 +delgan__loguru-852 +delgan__loguru-955 +delgan__loguru-960 +delgan__loguru-985 +deltares__wflow.jl-154 +deltares__wflow.jl-330 +deltares__wflow.jl-332 +deltares__wflow.jl-368 +deltares__wflow.jl-370 +deltares__wflow.jl-373 +deltares__wflow.jl-95 +delvedor__find-my-way-207 +delvedor__find-my-way-211 +delvedor__find-my-way-251 +delvedor__find-my-way-256 +delvedor__find-my-way-278 +delvedor__find-my-way-279 +delvedor__find-my-way-282 +delvedor__find-my-way-306 +delvedor__find-my-way-380 +denisenkom__go-mssqldb-546 +denoland__deno_lint-1047 +denoland__deno_lint-1212 +denoland__deno_lint-1255 +denoland__deno_lint-1275 +denvercoder1__github-readme-streak-stats-110 +denvercoder1__github-readme-streak-stats-140 +denvercoder1__github-readme-streak-stats-362 +denvercoder1__github-readme-streak-stats-490 +denvercoder1__github-readme-streak-stats-495 +denvercoder1__github-readme-streak-stats-498 +denvercoder1__github-readme-streak-stats-526 +denvercoder1__github-readme-streak-stats-673 +denvercoder1__readme-typing-svg-213 +denvercoder1__readme-typing-svg-254 +denvercoder1__readme-typing-svg-302 +depcheck__depcheck-808 +depcheck__depcheck-855 +depcheck__depcheck-858 +derekkraan__curl_req-11 +derekkraan__curl_req-26 +derekkraan__curl_req-27 +derekkraan__curl_req-29 +derekkraan__curl_req-31 +derekkraan__curl_req-32 +derekkraan__curl_req-48 +derekkraan__curl_req-53 +dermotduffy__frigate-hass-card-1399 +dermotduffy__frigate-hass-card-1433 +dermotduffy__frigate-hass-card-1443 +dermotduffy__frigate-hass-card-1504 +dermotduffy__frigate-hass-card-1505 +dermotduffy__frigate-hass-card-1869 +deshaw__pyflyby-230 +deshaw__pyflyby-239 +deshaw__pyflyby-244 +deshaw__pyflyby-270 +deshaw__pyflyby-289 +deshaw__pyflyby-294 +deshaw__pyflyby-303 +deshaw__pyflyby-330 +deshaw__pyflyby-340 +deshaw__pyflyby-363 +deshaw__pyflyby-391 +designliquido__delegua-436 +designliquido__delegua-525 +designliquido__delegua-542 +designliquido__delegua-548 +designliquido__delegua-554 +designliquido__delegua-621 +designliquido__delegua-647 +designliquido__delegua-732 +designliquido__delegua-736 +designliquido__delegua-742 +designliquido__delegua-743 +desmos-labs__desmos-533 +desmos-labs__desmos-716 +destinyitemmanager__dim-6987 +destinyitemmanager__dim-7847 +destinyitemmanager__dim-7868 +destinyitemmanager__dim-8205 +detachhead__basedpyright-34 +detachhead__basedpyright-52 +developer-dao__web3-ui-116 +developer-dao__web3-ui-41 +developmentseed__titiler-1115 +developmentseed__titiler-1138 +devexpress__devextreme-react-100 +devexpress__devextreme-react-116 +devexpress__devextreme-react-171 +devexpress__devextreme-react-179 +devexpress__devextreme-react-181 +devexpress__devextreme-react-217 +devexpress__devextreme-react-222 +devexpress__devextreme-react-265 +devexpress__devextreme-react-287 +devexpress__devextreme-react-290 +devexpress__devextreme-react-313 +devexpress__devextreme-react-59 +devexpress__devextreme-react-71 +devexpress__devextreme-vue-111 +devexpress__devextreme-vue-136 +devexpress__devextreme-vue-152 +devexpress__devextreme-vue-180 +devexpress__devextreme-vue-201 +devexpress__devextreme-vue-206 +devexpress__devextreme-vue-210 +devexpress__devextreme-vue-49 +devexpress__devextreme-vue-56 +devexpress__devextreme-vue-80 +devexpress__devextreme-vue-92 +devexpress__testcafe-7268 +devexpress__testcafe-7289 +deviceinsight__kafkactl-186 +devlooped__moq-1259 +devlooped__moq-1260 +devlooped__moq-1262 +devlooped__moq-1281 +devlooped__moq-1313 +devlooped__moq-1319 +devpi__devpi-1074 +dgasmith__opt_einsum-11 +dgasmith__opt_einsum-43 +dgasmith__opt_einsum-48 +dgasmith__opt_einsum-53 +dharmab__skyeye-158 +dherault__serverless-offline-660 +diaoul__subliminal-1180 +diaoul__subliminal-1201 +diaoul__subliminal-1207 +diaoul__subliminal-1217 +diaoul__subliminal-1218 +diaoul__subliminal-1225 +diaoul__subliminal-1242 +diegoholiveira__jsonlogic-111 +diegoholiveira__jsonlogic-30 +diegoholiveira__jsonlogic-31 +diegoholiveira__jsonlogic-38 +diegoholiveira__jsonlogic-59 +diegoholiveira__jsonlogic-66 +diegoholiveira__jsonlogic-72 +diegoholiveira__jsonlogic-73 +diegoholiveira__jsonlogic-76 +diegoholiveira__jsonlogic-78 +diegoholiveira__jsonlogic-80 +diegoholiveira__jsonlogic-85 +diegoholiveira__jsonlogic-97 +digdir__designsystemet-3793 +diggerhq__digger-67 +digitalocean__doctl-1266 +digitalocean__doctl-1273 +digitalocean__doctl-1499 +digitalocean__doctl-1593 +digitalocean__pynetbox-128 +digitalocean__pynetbox-138 +digitalocean__pynetbox-193 +digitalocean__pynetbox-194 +digitalocean__pynetbox-53 +digitalocean__pynetbox-66 +digitalslidearchive__histomicstk-1007 +dikhan__terraform-provider-openapi-319 +dikhan__terraform-provider-openapi-322 +directorytree__imapengine-15 +directorytree__imapengine-47 +directorytree__imapengine-53 +directorytree__imapengine-57 +directorytree__imapengine-58 +directorytree__imapengine-67 +directorytree__imapengine-70 +directorytree__imapengine-73 +directorytree__imapengine-84 +dirty-cat__dirty_cat-420 +dirty-cat__dirty_cat-421 +dirty-cat__dirty_cat-532 +dirty-cat__dirty_cat-534 +dirty-cat__dirty_cat-539 +dirty-cat__dirty_cat-543 +discordjs__voice-120 +discordjs__voice-130 +discordjs__voice-140 +discordjs__voice-147 +discordjs__voice-171 +discordjs__voice-75 +discordjs__voice-79 +discordjs__voice-85 +discordjs__voice-87 +distribution__distribution-2903 +distribution__distribution-4285 +distribution__distribution-4293 +distribution__distribution-4338 +divvypayhq__absinthe_federation-109 +divvypayhq__absinthe_federation-22 +divvypayhq__absinthe_federation-24 +divvypayhq__absinthe_federation-42 +divvypayhq__absinthe_federation-68 +divvypayhq__absinthe_federation-91 +divvypayhq__absinthe_federation-96 +django-extensions__django-extensions-1654 +django-extensions__django-extensions-1664 +django-extensions__django-extensions-1669 +django-money__django-money-786 +django__asgiref-523 +django__channels-1468 +django__channels-1581 +django__channels-1614 +django__channels-1651 +django__channels-1951 +djc__askama-1057 +djc__askama-1097 +djc__askama-215 +djc__askama-393 +djc__askama-394 +djc__askama-399 +djc__askama-411 +djc__askama-423 +djc__askama-458 +djc__askama-499 +djc__askama-500 +djc__askama-530 +djc__askama-560 +djc__askama-673 +djc__askama-837 +djc__askama-910 +djc__askama-911 +djc__askama-922 +djc__askama-943 +djc__askama-951 +djrobstep__sqlakeyset-100 +djrobstep__sqlakeyset-106 +djrobstep__sqlakeyset-96 +djrobstep__sqlakeyset-98 +dmitrysoshnikov__regexp-tree-125 +dmitrysoshnikov__regexp-tree-133 +dmitrysoshnikov__regexp-tree-139 +dmitrysoshnikov__regexp-tree-153 +dmitrysoshnikov__regexp-tree-157 +dmitrysoshnikov__regexp-tree-263 +dmitrysoshnikov__regexp-tree-31 +dmitrysoshnikov__regexp-tree-33 +dmitrysoshnikov__regexp-tree-61 +dmitrysoshnikov__regexp-tree-97 +docker-java__docker-java-212 +docker-java__docker-java-454 +docker__compose-10192 +docker__compose-10202 +docker__compose-10554 +docker__compose-10840 +docker__compose-12141 +docker__compose-12628 +docker__compose-12954 +docker__compose-8620 +docker__compose-8650 +docker__compose-8658 +docker__compose-9073 +docker__compose-9130 +docker__compose-9148 +docker__compose-9179 +docker__compose-9192 +docker__compose-9214 +docker__compose-9539 +docker__compose-9698 +docker__compose-9729 +docker__compose-9829 +docker__compose-cli-1005 +docker__compose-cli-1053 +docker__notary-1043 +docker__notary-740 +docker__notary-970 +dockyard__elixir-mail-106 +dockyard__elixir-mail-123 +dockyard__elixir-mail-131 +dockyard__elixir-mail-161 +doctrine__dbal-4287 +doctrine__dbal-4293 +doctrine__dbal-4320 +doctrine__dbal-4341 +doctrine__dbal-4414 +doctrine__dbal-4422 +doctrine__dbal-4429 +doctrine__migrations-1210 +doctrine__migrations-1226 +doctrine__migrations-1229 +doctrine__orm-10058 +doctrine__orm-10074 +doctrine__orm-10735 +doctrine__orm-10763 +doctrine__orm-10913 +doctrine__orm-10915 +doctrine__orm-11082 +doctrine__orm-11260 +doctrine__orm-11287 +doctrine__orm-11308 +doctrine__orm-11387 +doctrine__orm-11445 +doctrine__orm-11528 +doctrine__orm-11646 +doctrine__orm-11826 +doctrine__orm-9381 +doctrine__orm-9616 +documentationjs__documentation-864 +documentationjs__documentation-895 +doitintl__kube-no-trouble-109 +doitintl__kube-no-trouble-163 +doitintl__kube-no-trouble-182 +doitintl__kube-no-trouble-268 +doitintl__kube-no-trouble-355 +doitintl__kube-no-trouble-373 +doitintl__kube-no-trouble-407 +doitintl__kube-no-trouble-85 +dokato__todor-46 +dokato__todor-48 +dominikbraun__graph-127 +domluna__juliaformatter.jl-169 +domluna__juliaformatter.jl-250 +domluna__juliaformatter.jl-261 +domluna__juliaformatter.jl-347 +domluna__juliaformatter.jl-357 +domluna__juliaformatter.jl-424 +domluna__juliaformatter.jl-488 +domluna__juliaformatter.jl-511 +domluna__juliaformatter.jl-529 +domluna__juliaformatter.jl-540 +domluna__juliaformatter.jl-661 +domluna__juliaformatter.jl-692 +domluna__juliaformatter.jl-695 +domluna__juliaformatter.jl-716 +domluna__juliaformatter.jl-732 +domluna__juliaformatter.jl-913 +domluna__juliaformatter.jl-918 +domluna__juliaformatter.jl-931 +donejs__donejs-1085 +dotemacs__pdfboxing-67 +dotenv-linter__dotenv-linter-257 +dotenv-linter__dotenv-linter-279 +dotenv-linter__dotenv-linter-327 +dotenv-linter__dotenv-linter-341 +dotenv-linter__dotenv-linter-342 +dotenv-linter__dotenv-linter-367 +dotenv-linter__dotenv-linter-394 +dotenv-linter__dotenv-linter-450 +dotenv-linter__dotenv-linter-453 +dotenv-linter__dotenv-linter-462 +dotenv-linter__dotenv-linter-463 +dotnet-script__dotnet-script-762 +dpkp__kafka-python-2080 +dpkp__kafka-python-2081 +dpkp__kafka-python-2119 +dpkp__kafka-python-2544 +dpkp__kafka-python-2608 +dpkp__kafka-python-2612 +dpkp__kafka-python-2616 +dprint__dprint-plugin-typescript-366 +dprint__dprint-plugin-typescript-374 +dprint__dprint-plugin-typescript-375 +dprint__dprint-plugin-typescript-376 +dprint__dprint-plugin-typescript-396 +dprint__dprint-plugin-typescript-40 +dprint__dprint-plugin-typescript-404 +dprint__dprint-plugin-typescript-405 +dprint__dprint-plugin-typescript-407 +dprint__dprint-plugin-typescript-408 +dprint__dprint-plugin-typescript-412 +dprint__dprint-plugin-typescript-414 +dprint__dprint-plugin-typescript-418 +dprint__dprint-plugin-typescript-419 +dprint__dprint-plugin-typescript-422 +dprint__dprint-plugin-typescript-427 +dprint__dprint-plugin-typescript-428 +dprint__dprint-plugin-typescript-434 +dprint__dprint-plugin-typescript-443 +dprint__dprint-plugin-typescript-447 +dprint__dprint-plugin-typescript-449 +dprint__dprint-plugin-typescript-469 +dprint__dprint-plugin-typescript-513 +dprint__dprint-plugin-typescript-514 +dprint__dprint-plugin-typescript-522 +dprint__dprint-plugin-typescript-536 +dprint__dprint-plugin-typescript-544 +dprint__dprint-plugin-typescript-566 +dprint__dprint-plugin-typescript-588 +dr-leo__pandasdmx-101 +dr-leo__pandasdmx-95 +dr-leo__pandasdmx-96 +dr-leo__pandasdmx-98 +dr-leo__pandasdmx-99 +draft-js-plugins__draft-js-plugins-2039 +draft-js-plugins__draft-js-plugins-2052 +drand__drand-1017 +drand__drand-1030 +drand__drand-1407 +drand__drand-295 +drand__drand-313 +drand__drand-724 +drivendataorg__cloudpathlib-102 +drivendataorg__cloudpathlib-104 +drivendataorg__cloudpathlib-185 +drivendataorg__cloudpathlib-209 +drivendataorg__cloudpathlib-224 +drivendataorg__cloudpathlib-249 +drivendataorg__cloudpathlib-404 +drivendataorg__cloudpathlib-432 +drivendataorg__cloudpathlib-433 +drivendataorg__cloudpathlib-437 +drivendataorg__cloudpathlib-460 +drivendataorg__cloudpathlib-474 +dtolnay__anyhow-19 +dtolnay__anyhow-24 +dtolnay__anyhow-28 +dtolnay__anyhow-45 +dtolnay__anyhow-47 +dtolnay__async-trait-100 +dtolnay__async-trait-150 +dtolnay__async-trait-160 +dtolnay__async-trait-162 +dtolnay__async-trait-205 +dtolnay__async-trait-223 +dtolnay__async-trait-227 +dtolnay__async-trait-233 +dtolnay__async-trait-235 +dtolnay__async-trait-239 +dtolnay__async-trait-260 +dtolnay__async-trait-282 +dtolnay__async-trait-284 +dtolnay__async-trait-289 +dtolnay__cxx-1104 +dtolnay__cxx-1150 +dtolnay__cxx-1281 +dtolnay__cxx-131 +dtolnay__cxx-159 +dtolnay__cxx-167 +dtolnay__cxx-182 +dtolnay__cxx-187 +dtolnay__cxx-190 +dtolnay__cxx-196 +dtolnay__cxx-263 +dtolnay__cxx-267 +dtolnay__cxx-311 +dtolnay__cxx-322 +dtolnay__cxx-361 +dtolnay__cxx-392 +dtolnay__cxx-408 +dtolnay__cxx-411 +dtolnay__cxx-443 +dtolnay__cxx-502 +dtolnay__cxx-515 +dtolnay__cxx-531 +dtolnay__cxx-541 +dtolnay__cxx-554 +dtolnay__cxx-585 +dtolnay__cxx-603 +dtolnay__cxx-609 +dtolnay__cxx-62 +dtolnay__cxx-642 +dtolnay__cxx-652 +dtolnay__cxx-660 +dtolnay__cxx-661 +dtolnay__cxx-689 +dtolnay__cxx-694 +dtolnay__cxx-743 +dtolnay__cxx-800 +dtolnay__cxx-814 +dtolnay__cxx-828 +dtolnay__cxx-839 +dtolnay__cxx-840 +dtolnay__cxx-859 +dtolnay__paste-17 +dtolnay__paste-23 +dtolnay__paste-32 +dtolnay__paste-4 +dtolnay__paste-48 +dtolnay__thiserror-16 +duartegroup__autode-213 +duartegroup__autode-242 +duartegroup__autode-243 +duartegroup__autode-275 +duartegroup__autode-292 +duartegroup__autode-303 +duartegroup__autode-349 +dubzzz__fast-check-1020 +dubzzz__fast-check-1586 +ducaale__xh-164 +ducaale__xh-167 +ducaale__xh-168 +ducaale__xh-202 +ducaale__xh-209 +ducaale__xh-257 +ducaale__xh-308 +ducaale__xh-379 +ducaale__xh-411 +ducaale__xh-416 +dundee__gdu-391 +dusk-network__dusk-blockchain-1296 +dusk-network__dusk-blockchain-1337 +dusk-network__dusk-blockchain-1533 +dvajs__dva-158 +dvanoni__notero-604 +dvanoni__notero-608 +dwavesystems__dwave-cloud-client-582 +dwavesystems__dwave-cloud-client-680 +dwavesystems__dwave-system-554 +dwavesystems__dwave-system-556 +dwavesystems__dwave-system-582 +dymensionxyz__dymension-1177 +dymensionxyz__dymension-1186 +dymensionxyz__dymension-1352 +dymensionxyz__dymension-1666 +dymensionxyz__dymension-1668 +dymensionxyz__dymension-647 +dymensionxyz__dymension-673 +dymensionxyz__dymension-808 +dymensionxyz__dymension-913 +dymensionxyz__dymint-1065 +dymensionxyz__dymint-811 +dynaconf__dynaconf-1040 +dynaconf__dynaconf-1107 +dynaconf__dynaconf-1115 +dynaconf__dynaconf-1168 +dynaconf__dynaconf-1184 +dynaconf__dynaconf-1185 +dynaconf__dynaconf-1237 +dynaconf__dynaconf-1238 +dynaconf__dynaconf-1254 +dynaconf__dynaconf-1293 +dynaconf__dynaconf-1295 +dynaconf__dynaconf-795 +dynaconf__dynaconf-802 +dynaconf__dynaconf-811 +dynaconf__dynaconf-915 +dynaconf__dynaconf-960 +dynaconf__dynaconf-966 +dynamoosejs__dynamoose-798 +dynamoosejs__dynamoose-817 +dynamoosejs__dynamoose-821 +dynamoosejs__dynamoose-823 +dynamoosejs__dynamoose-824 +e2niee__pandapower-2017 +e2niee__pandapower-2147 +e2niee__pandapower-258 +ec-cube__ec-cube2-1021 +ec-cube__ec-cube2-1037 +ec-cube__ec-cube2-1108 +ec-cube__ec-cube2-1112 +ec-cube__ec-cube2-1113 +ec-cube__ec-cube2-1134 +ec-cube__ec-cube2-1148 +ecadlabs__taquito-2781 +ecadlabs__taquito-2919 +ecadlabs__taquito-2975 +echobind__bisonapp-181 +eclipse__leshan-1174 +eclipse__leshan-774 +eclipse__leshan-785 +eclipse__leshan-985 +eclipse__microprofile-lra-186 +eclipse__microprofile-lra-205 +eclipse__microprofile-lra-258 +eclipse__microprofile-lra-271 +eclipse__microprofile-lra-273 +eclipse__microprofile-lra-293 +eclipse__microprofile-lra-295 +eclipse__microprofile-lra-310 +eclipse__microprofile-lra-311 +eclipse__microprofile-lra-313 +eclipse__microprofile-lra-321 +eclipse__microprofile-lra-322 +eclipse__thingweb.node-wot-779 +eclipse__thingweb.node-wot-791 +eclipse__thingweb.node-wot-901 +eclipse__thingweb.node-wot-943 +ecmwf__earthkit-data-111 +ecmwf__earthkit-data-119 +ecmwf__earthkit-data-126 +ecmwf__earthkit-data-163 +ecmwf__earthkit-data-170 +ecmwf__earthkit-data-216 +ecmwf__earthkit-data-249 +ecmwf__earthkit-data-251 +ecmwf__earthkit-data-265 +ecmwf__earthkit-data-272 +ecmwf__earthkit-data-283 +ecmwf__earthkit-data-285 +ecmwf__earthkit-data-304 +ecmwf__earthkit-data-327 +ecmwf__earthkit-data-339 +ecmwf__earthkit-data-380 +ecmwf__earthkit-data-403 +ecmwf__earthkit-data-407 +ecmwf__earthkit-data-523 +ecmwf__earthkit-data-565 +ecmwf__earthkit-data-592 +ecmwf__earthkit-data-599 +ecmwf__earthkit-data-650 +ecmwf__earthkit-data-671 +edgexfoundry__device-modbus-go-443 +edgexfoundry__device-modbus-go-617 +edgexfoundry__device-sdk-go-1297 +edgexfoundry__device-sdk-go-1301 +edgexfoundry__device-sdk-go-1356 +edgexfoundry__device-sdk-go-1444 +edgexfoundry__device-sdk-go-1515 +edgexfoundry__device-sdk-go-265 +edgexfoundry__edgex-go-5189 +edgi-govdata-archiving__wayback-139 +edgi-govdata-archiving__wayback-140 +edgurgel__mimic-18 +edgurgel__mimic-47 +edgurgel__mimic-56 +edgurgel__mimic-74 +editorconfig-checker__editorconfig-checker-112 +editorconfig-checker__editorconfig-checker-126 +editorconfig-checker__editorconfig-checker-128 +editorconfig-checker__editorconfig-checker-284 +editorconfig-checker__editorconfig-checker-331 +editorconfig-checker__editorconfig-checker-339 +editorconfig-checker__editorconfig-checker-350 +editorconfig-checker__editorconfig-checker-360 +editorconfig-checker__editorconfig-checker-363 +editorconfig-checker__editorconfig-checker-375 +editorconfig-checker__editorconfig-checker-448 +editorconfig-checker__editorconfig-checker-67 +editorconfig-checker__editorconfig-checker-71 +editorconfig-checker__editorconfig-checker-98 +educationaltestingservice__rsmtool-669 +educationaltestingservice__rsmtool-670 +edvardchen__eslint-plugin-i18next-108 +edvardchen__eslint-plugin-i18next-112 +edvardchen__eslint-plugin-i18next-127 +edvardchen__eslint-plugin-i18next-128 +edvardchen__eslint-plugin-i18next-24 +edvardchen__eslint-plugin-i18next-5 +edvardchen__eslint-plugin-i18next-98 +edvardchen__eslint-plugin-i18next-99 +eemeli__yaml-259 +eemeli__yaml-271 +eemeli__yaml-278 +eemeli__yaml-304 +eemeli__yaml-309 +eemeli__yaml-335 +eemeli__yaml-370 +eemeli__yaml-371 +eemeli__yaml-372 +eemeli__yaml-451 +eemeli__yaml-580 +effector__effector-469 +effector__effector-741 +effector__effector-744 +effector__effector-776 +effector__effector-862 +effector__eslint-plugin-159 +eksctl-io__eksctl-8447 +elastic__apm-agent-php-1174 +elastic__apm-agent-php-1213 +elastic__apm-agent-php-431 +elastic__apm-agent-php-458 +elastic__apm-agent-php-625 +elastic__apm-agent-php-691 +elastic__apm-agent-php-692 +elastic__cloud-on-k8s-1809 +elastic__cloud-on-k8s-1837 +elastic__cloud-on-k8s-5308 +elastic__curator-1019 +elastic__curator-1081 +elastic__curator-1085 +elastic__curator-1158 +elastic__curator-1175 +elastic__curator-1176 +elastic__curator-1221 +elastic__curator-1296 +elastic__curator-1355 +elastic__curator-1436 +elastic__curator-1437 +elastic__curator-469 +elastic__curator-535 +elastic__curator-559 +elastic__curator-560 +elastic__curator-603 +elastic__curator-616 +elastic__curator-642 +elastic__curator-664 +elastic__curator-743 +elastic__curator-748 +elastic__curator-750 +elastic__curator-793 +elastic__curator-913 +elastic__ecctl-82 +elastic__elasticsearch-js-1732 +elastic__go-libaudit-145 +elastic__go-libaudit-65 +elastic__go-libaudit-67 +elastic__go-libaudit-68 +elastic__go-sysinfo-115 +elastic__go-sysinfo-116 +elastic__go-sysinfo-140 +electrode-io__electrode-native-1824 +electrode-io__electrode-native-1844 +electron-userland__electron-forge-123 +electron-userland__electron-forge-253 +electron-userland__electron-forge-352 +electron-userland__electron-forge-427 +electron-userland__electron-forge-430 +electron__fiddle-512 +electron__fiddle-523 +electron__fiddle-531 +electron__fiddle-553 +electron__fiddle-587 +electron__fiddle-625 +electron__fiddle-633 +electron__fiddle-637 +elementai__baal-18 +elixir-ecto__ecto-2056 +elixir-ecto__ecto-2065 +elixir-ecto__ecto-2195 +elixir-ecto__ecto-2258 +elixir-ecto__ecto-2338 +elixir-ecto__ecto-2339 +elixir-ecto__ecto-2345 +elixir-ecto__ecto-2348 +elixir-ecto__ecto-2371 +elixir-ecto__ecto-4426 +elixir-ecto__ecto_sql-600 +elixir-error-tracker__error-tracker-133 +elixir-error-tracker__error-tracker-69 +elixir-error-tracker__error-tracker-86 +elixir-gettext__gettext-226 +elixir-gettext__gettext-239 +elixir-gettext__gettext-254 +elixir-gettext__gettext-322 +elixir-gettext__gettext-385 +elixir-gettext__gettext-412 +elixir-grpc__grpc-227 +elixir-grpc__grpc-236 +elixir-grpc__grpc-250 +elixir-grpc__grpc-258 +elixir-grpc__grpc-314 +elixir-plug__plug-1021 +elixir-plug__plug-1098 +elixir-plug__plug-1116 +elixir-plug__plug-1154 +elixir-plug__plug-1218 +elixir-plug__plug-1240 +elixir-plug__plug-1245 +elixir-plug__plug-862 +elixir-protobuf__protobuf-140 +elixir-protobuf__protobuf-164 +elixir-protobuf__protobuf-387 +elixirmoney__money-240 +elliotchance__gedcom-293 +elliotchance__gedcom-303 +elliotchance__gedcom-305 +elliotchance__pie-151 +elliotchance__pie-182 +elliotchance__pie-50 +elm-tooling__elm-language-server-278 +elm-tooling__elm-language-server-370 +elm-tooling__elm-language-server-411 +elm-tooling__elm-language-server-427 +elm-tooling__elm-language-server-464 +elm-tooling__elm-language-server-487 +elm-tooling__elm-language-server-507 +elm-tooling__elm-language-server-517 +elm-tooling__elm-language-server-522 +elm-tooling__elm-language-server-532 +elm-tooling__elm-language-server-534 +elm-tooling__elm-language-server-586 +elm-tooling__elm-language-server-588 +elm-tooling__elm-language-server-609 +elm-tooling__elm-language-server-613 +elm-tooling__elm-language-server-627 +elm-tooling__elm-language-server-628 +elm-tooling__elm-language-server-721 +elm-tooling__elm-language-server-941 +elm-tooling__elm-language-server-946 +elm-tooling__elm-language-server-962 +elves__elvish-1860 +embassy-rs__embassy-2380 +ember-cli__ember-cli-10022 +ember-cli__ember-cli-10249 +ember-cli__ember-cli-10521 +ember-cli__ember-cli-10562 +ember-cli__ember-cli-10577 +ember-cli__ember-cli-6319 +ember-cli__ember-cli-6436 +ember-cli__ember-cli-7528 +ember-cli__ember-cli-8028 +ember-cli__ember-cli-8175 +ember-cli__ember-cli-8701 +ember-cli__ember-cli-9392 +ember-cli__ember-cli-9848 +ember-cli__eslint-plugin-ember-1000 +ember-cli__eslint-plugin-ember-1055 +ember-cli__eslint-plugin-ember-107 +ember-cli__eslint-plugin-ember-1079 +ember-cli__eslint-plugin-ember-1102 +ember-cli__eslint-plugin-ember-1115 +ember-cli__eslint-plugin-ember-1135 +ember-cli__eslint-plugin-ember-1150 +ember-cli__eslint-plugin-ember-1188 +ember-cli__eslint-plugin-ember-132 +ember-cli__eslint-plugin-ember-1536 +ember-cli__eslint-plugin-ember-1538 +ember-cli__eslint-plugin-ember-1546 +ember-cli__eslint-plugin-ember-1555 +ember-cli__eslint-plugin-ember-1635 +ember-cli__eslint-plugin-ember-1702 +ember-cli__eslint-plugin-ember-1715 +ember-cli__eslint-plugin-ember-1823 +ember-cli__eslint-plugin-ember-1865 +ember-cli__eslint-plugin-ember-1939 +ember-cli__eslint-plugin-ember-1994 +ember-cli__eslint-plugin-ember-260 +ember-cli__eslint-plugin-ember-262 +ember-cli__eslint-plugin-ember-331 +ember-cli__eslint-plugin-ember-457 +ember-cli__eslint-plugin-ember-458 +ember-cli__eslint-plugin-ember-476 +ember-cli__eslint-plugin-ember-546 +ember-cli__eslint-plugin-ember-548 +ember-cli__eslint-plugin-ember-551 +ember-cli__eslint-plugin-ember-552 +ember-cli__eslint-plugin-ember-573 +ember-cli__eslint-plugin-ember-595 +ember-cli__eslint-plugin-ember-607 +ember-cli__eslint-plugin-ember-615 +ember-cli__eslint-plugin-ember-664 +ember-cli__eslint-plugin-ember-670 +ember-cli__eslint-plugin-ember-695 +ember-cli__eslint-plugin-ember-697 +ember-cli__eslint-plugin-ember-715 +ember-cli__eslint-plugin-ember-718 +ember-cli__eslint-plugin-ember-719 +ember-cli__eslint-plugin-ember-870 +ember-cli__eslint-plugin-ember-871 +ember-cli__eslint-plugin-ember-894 +ember-cli__eslint-plugin-ember-920 +ember-cli__eslint-plugin-ember-923 +ember-cli__eslint-plugin-ember-934 +ember-cli__eslint-plugin-ember-957 +ember-cli__eslint-plugin-ember-973 +ember-cli__eslint-plugin-ember-985 +ember-cli__eslint-plugin-ember-993 +ember-cli__eslint-plugin-ember-998 +ember-codemods__ember-angle-brackets-codemod-152 +ember-codemods__ember-angle-brackets-codemod-158 +ember-codemods__ember-angle-brackets-codemod-165 +ember-codemods__ember-angle-brackets-codemod-181 +ember-codemods__ember-angle-brackets-codemod-192 +ember-codemods__ember-angle-brackets-codemod-214 +ember-codemods__ember-angle-brackets-codemod-486 +ember-intl__ember-intl-1285 +ember-intl__ember-intl-1310 +ember-intl__ember-intl-588 +ember-intl__ember-intl-593 +ember-intl__ember-intl-596 +ember-template-lint__ember-template-lint-404 +ember-template-lint__ember-template-lint-419 +ember-template-lint__ember-template-lint-444 +ember-template-lint__ember-template-lint-750 +ember-template-lint__ember-template-lint-783 +ember-template-lint__ember-template-lint-850 +ember-template-lint__ember-template-lint-900 +ember-template-lint__ember-template-lint-902 +ember-template-lint__ember-template-lint-923 +emdgroup-liquid__liquid-224 +emdgroup-liquid__liquid-498 +emdgroup-liquid__liquid-579 +emdgroup-liquid__liquid-632 +emdgroup-liquid__liquid-636 +emdgroup-liquid__liquid-676 +emersion__go-imap-137 +emersion__go-imap-431 +emersion__go-smtp-111 +emersion__go-smtp-148 +emersion__go-smtp-213 +emit-rs__emit-110 +emit-rs__emit-190 +encode__django-rest-framework-8979 +encode__django-rest-framework-9333 +encode__django-rest-framework-9360 +encode__django-rest-framework-9455 +encode__django-rest-framework-9467 +encode__httpx-1044 +encode__httpx-1736 +encode__httpx-1800 +encode__httpx-3187 +encode__httpx-718 +endojs__endo-2377 +endojs__endo-2597 +endojs__endo-2624 +endojs__endo-2645 +enselic__cargo-public-api-174 +enselic__cargo-public-api-177 +enselic__cargo-public-api-196 +enselic__cargo-public-api-246 +enselic__cargo-public-api-270 +enselic__cargo-public-api-289 +enselic__cargo-public-api-353 +enselic__cargo-public-api-428 +enselic__cargo-public-api-431 +enselic__cargo-public-api-439 +enselic__cargo-public-api-477 +enselic__cargo-public-api-72 +enter-tainer__typstyle-220 +enter-tainer__typstyle-224 +enthought__envisage-275 +enthought__envisage-353 +enthought__envisage-354 +enthought__envisage-443 +enthought__envisage-508 +enthought__envisage-529 +enthought__envisage-535 +enthought__envisage-546 +enthought__traits-1006 +enthought__traits-1026 +enthought__traits-1040 +enthought__traits-1058 +enthought__traits-1088 +enthought__traits-1100 +enthought__traits-1107 +enthought__traits-1110 +enthought__traits-1115 +enthought__traits-1119 +enthought__traits-1134 +enthought__traits-1144 +enthought__traits-1172 +enthought__traits-1173 +enthought__traits-1189 +enthought__traits-1278 +enthought__traits-1308 +enthought__traits-1311 +enthought__traits-1331 +enthought__traits-1335 +enthought__traits-1346 +enthought__traits-1348 +enthought__traits-1349 +enthought__traits-1351 +enthought__traits-1365 +enthought__traits-1367 +enthought__traits-1384 +enthought__traits-1392 +enthought__traits-1393 +enthought__traits-1395 +enthought__traits-1397 +enthought__traits-1440 +enthought__traits-1475 +enthought__traits-1498 +enthought__traits-1501 +enthought__traits-1515 +enthought__traits-1525 +enthought__traits-1534 +enthought__traits-1550 +enthought__traits-1560 +enthought__traits-1564 +enthought__traits-1624 +enthought__traits-1670 +enthought__traits-1699 +enthought__traits-1740 +enthought__traits-1805 +enthought__traits-1846 +enthought__traits-509 +enthought__traits-510 +enthought__traits-541 +enthought__traits-548 +enthought__traits-645 +enthought__traits-740 +enthought__traits-783 +enthought__traits-887 +enthought__traits-889 +enthought__traits-926 +enthought__traits-927 +enthought__traits-929 +enthought__traits-970 +enthought__traits-999 +enthought__traitsui-1433 +enthought__traitsui-1554 +enthought__traitsui-1557 +enthought__traitsui-1817 +enthought__traitsui-2000 +envoyproxy__ai-gateway-252 +envoyproxy__gateway-5933 +envoyproxy__gateway-6326 +envoyproxy__gateway-6421 +enzonotario__vitepress-openapi-101 +enzonotario__vitepress-openapi-126 +enzonotario__vitepress-openapi-132 +enzonotario__vitepress-openapi-133 +enzonotario__vitepress-openapi-136 +enzonotario__vitepress-openapi-137 +enzonotario__vitepress-openapi-193 +enzonotario__vitepress-openapi-201 +enzonotario__vitepress-openapi-209 +enzonotario__vitepress-openapi-224 +enzonotario__vitepress-openapi-79 +enzonotario__vitepress-openapi-82 +enzonotario__vitepress-openapi-86 +epam-cross-platform-lab__swagger-dart-code-generator-391 +epam-cross-platform-lab__swagger-dart-code-generator-547 +epam-cross-platform-lab__swagger-dart-code-generator-701 +epam__edp-keycloak-operator-177 +epam__edp-keycloak-operator-184 +epi052__feroxbuster-672 +epi052__feroxbuster-706 +epiforecasts__scoringutils-1028 +epiforecasts__scoringutils-229 +epiforecasts__scoringutils-293 +epiforecasts__scoringutils-586 +epiforecasts__scoringutils-592 +epiforecasts__scoringutils-596 +epiforecasts__scoringutils-613 +epiforecasts__scoringutils-679 +epiforecasts__scoringutils-717 +epiforecasts__scoringutils-727 +epiforecasts__scoringutils-841 +epiforecasts__scoringutils-859 +epiforecasts__scoringutils-882 +epiforecasts__scoringutils-924 +epiforecasts__scoringutils-943 +equinor__design-system-3575 +equinor__design-system-3577 +equinor__design-system-3695 +equinor__design-system-3700 +equinor__design-system-3725 +equinor__design-system-3728 +equinor__design-system-3803 +equinor__design-system-3807 +ergebnis__php-cs-fixer-config-1012 +ergochat__ergo-1809 +ergochat__ergo-1927 +ergochat__ergo-1954 +ergochat__ergo-1984 +ergochat__ergo-2132 +ergochat__ergo-2159 +ericmjl__pyjanitor-624 +ericmjl__pyjanitor-648 +ericmjl__pyjanitor-673 +ericmjl__pyjanitor-694 +ericmjl__pyjanitor-704 +ericmjl__pyjanitor-709 +ericmjl__pyjanitor-714 +ericmjl__pyjanitor-727 +ericmjl__pyjanitor-728 +ericmjl__pyjanitor-735 +ericmjl__pyjanitor-762 +ericmjl__pyjanitor-770 +ericmjl__pyjanitor-811 +erikras__redux-form-425 +erikras__redux-form-641 +eslint-community__eslint-plugin-es-x-146 +eslint-community__eslint-plugin-es-x-43 +eslint-community__eslint-plugin-es-x-98 +eslint-community__eslint-plugin-promise-361 +eslint-community__eslint-plugin-promise-362 +eslint-community__eslint-plugin-promise-363 +eslint-community__eslint-plugin-promise-365 +eslint-community__eslint-plugin-promise-368 +eslint-community__eslint-plugin-promise-369 +eslint-community__eslint-plugin-promise-370 +eslint-community__eslint-plugin-promise-479 +eslint-community__eslint-plugin-promise-493 +eslint-community__eslint-plugin-promise-494 +eslint-community__eslint-plugin-promise-496 +eslint-community__eslint-plugin-promise-513 +eslint-community__eslint-plugin-promise-515 +eslint-community__eslint-plugin-promise-574 +eslint-functional__eslint-plugin-functional-803 +eslint-functional__eslint-plugin-functional-839 +eslint-functional__eslint-plugin-functional-863 +eslint-functional__eslint-plugin-functional-890 +eslint-functional__eslint-plugin-functional-935 +eslint-stylistic__eslint-stylistic-905 +eslint__css-100 +eslint__css-124 +eslint__css-128 +eslint__css-178 +eslint__css-27 +eslint__css-38 +eslint__css-49 +eslint__css-61 +eslint__css-74 +eslint__css-92 +eslint__css-93 +eslint__doctrine-125 +eslint__doctrine-126 +eslint__doctrine-130 +eslint__doctrine-132 +eslint__doctrine-134 +eslint__doctrine-137 +eslint__doctrine-139 +eslint__doctrine-142 +eslint__doctrine-144 +eslint__doctrine-152 +eslint__doctrine-158 +eslint__doctrine-160 +eslint__doctrine-164 +eslint__doctrine-172 +eslint__doctrine-182 +eslint__doctrine-193 +eslint__eslint-11489 +eslint__eslint-12028 +eslint__eslint-12053 +eslint__eslint-12197 +eslint__eslint-12258 +eslint__eslint-12264 +eslint__eslint-12339 +eslint__eslint-12414 +eslint__eslint-12436 +eslint__eslint-12441 +eslint__eslint-12475 +eslint__eslint-14227 +eslint__eslint-14282 +eslint__eslint-14641 +eslint__eslint-14901 +eslint__eslint-15666 +eslint__eslint-15727 +eslint__eslint-github-bot-219 +eslint__typescript-eslint-parser-43 +ethereum-optimism__optimism-6914 +ethereum__web3.py-2023 +ethereum__web3.py-2288 +ethereum__web3.py-2655 +ethereum__web3.py-2691 +ethereum__web3.py-3618 +ethereum__web3.py-3620 +ethereum__web3.py-3622 +ethereum__web3.py-3662 +ethereum__web3.py-3663 +ethereum__web3.py-3685 +ethereum__web3.py-3690 +ethereum__web3.py-3702 +evan-liu__karabiner.ts-23 +evan-liu__karabiner.ts-42 +evan-liu__karabiner.ts-77 +evcc-io__evcc-11542 +evcc-io__evcc-13799 +evcc-io__evcc-13909 +evcc-io__evcc-18114 +evcc-io__evcc-20724 +evcc-io__evcc-6204 +evcc-io__evcc-6309 +evcc-io__evcc-9015 +evcc-io__evcc-9932 +evcc-io__evcc-9996 +eventlet__eventlet-1015 +eventlet__eventlet-1047 +eventlet__eventlet-854 +eventlet__eventlet-866 +eventlet__eventlet-877 +evertras__bubble-table-154 +evertras__bubble-table-166 +exadel-inc__esl-1053 +exadel-inc__esl-1094 +exadel-inc__esl-1437 +executablebooks__myst-parser-497 +executablebooks__myst-parser-734 +executablebooks__myst-parser-742 +executablebooks__myst-parser-924 +executablebooks__myst-parser-925 +exercism__cli-1044 +exercism__cli-429 +exercism__clojure-373 +exercism__python-3165 +exercism__xgo-687 +extendr__extendr-173 +extendr__extendr-242 +extendr__extendr-243 +extendr__extendr-254 +extendr__extendr-318 +extendr__extendr-375 +extendr__extendr-466 +extendr__extendr-573 +external-secrets__external-secrets-2735 +external-secrets__external-secrets-3003 +external-secrets__external-secrets-3288 +external-secrets__external-secrets-3292 +external-secrets__external-secrets-3308 +external-secrets__external-secrets-3438 +external-secrets__external-secrets-3576 +external-secrets__external-secrets-3952 +external-secrets__external-secrets-4229 +external-secrets__external-secrets-4304 +external-secrets__external-secrets-4305 +eyblockchain__nightfall_3-879 +eyevinn__mp4ff-399 +eyevinn__mp4ff-401 +ezrec__uv3dp-96 +fabien0102__ts-to-zod-106 +fabien0102__ts-to-zod-120 +fabien0102__ts-to-zod-194 +fabien0102__ts-to-zod-198 +fabien0102__ts-to-zod-229 +fabien0102__ts-to-zod-240 +fabien0102__ts-to-zod-243 +fabien0102__ts-to-zod-254 +fabien0102__ts-to-zod-287 +fabien0102__ts-to-zod-289 +fabien0102__ts-to-zod-72 +fabiolb__fabio-924 +fabricjs__fabric.js-10078 +fabricjs__fabric.js-9469 +fabricjs__fabric.js-9712 +facebook__facebook-instant-articles-sdk-php-326 +facebook__facebook-instant-articles-sdk-php-349 +facebook__zstd-1459 +facebook__zstd-1726 +facebook__zstd-1733 +facebook__zstd-1950 +facebookexperimental__usort-129 +facebookexperimental__usort-141 +facebookexperimental__usort-146 +facebookexperimental__usort-204 +facebookresearch__hydra-245 +facebookresearch__hydra-269 +facebookresearch__hydra-273 +facebookresearch__hydra-305 +facelessuser__pymdown-extensions-1568 +facelessuser__pymdown-extensions-1719 +facelessuser__pymdown-extensions-2003 +facelessuser__pymdown-extensions-2472 +facelessuser__pymdown-extensions-2649 +facelessuser__soupsieve-4 +facelessuser__wcmatch-46 +facile-it__paraunit-186 +facile-it__paraunit-194 +factoryboy__factory_boy-1006 +factoryboy__factory_boy-1045 +factoryboy__factory_boy-1067 +factoryboy__factory_boy-752 +factoryboy__factory_boy-841 +fairwindsops__pluto-29 +fairwindsops__pluto-30 +fairwindsops__pluto-545 +fairwindsops__pluto-65 +fairwindsops__pluto-68 +fairwindsops__pluto-72 +fairwindsops__polaris-1062 +fairwindsops__polaris-678 +fairwindsops__polaris-879 +fakerphp__faker-661 +falconry__falcon-1414 +falconry__falcon-1419 +falcosecurity__driverkit-66 +farama-foundation__pettingzoo-802 +farcaster-project__farcaster-node-255 +farmbot__farmbot-web-app-2365 +farmbot__farmbot-web-app-2372 +farmbot__farmbot-web-app-2374 +farmbot__farmbot-web-app-2383 +farmbot__farmbot-web-app-2385 +farmbot__farmbot-web-app-2387 +fastify__fast-json-stringify-116 +fastify__fast-json-stringify-120 +fastify__fast-json-stringify-134 +fastify__fast-json-stringify-137 +fastify__fast-json-stringify-140 +fastify__fast-json-stringify-153 +fastify__fast-json-stringify-156 +fastify__fast-json-stringify-163 +fastify__fast-json-stringify-219 +fastify__fast-json-stringify-224 +fastify__fast-json-stringify-234 +fastify__fast-json-stringify-254 +fastify__fast-json-stringify-257 +fastify__fast-json-stringify-276 +fastify__fast-json-stringify-278 +fastify__fast-json-stringify-334 +fastify__fast-json-stringify-382 +fastify__fast-json-stringify-433 +fastify__fast-json-stringify-460 +fastify__fast-json-stringify-482 +fastify__fast-json-stringify-507 +fastify__fast-json-stringify-513 +fastify__fastify-cli-182 +fastify__fastify-cli-242 +fastify__fastify-cli-321 +fastify__fastify-cli-359 +fastify__fastify-cli-434 +fastify__fastify-cli-532 +fastify__fastify-cors-152 +fastify__fastify-cors-244 +fastify__fastify-cors-252 +fastify__fastify-cors-285 +fastify__fastify-cors-288 +fastify__fastify-cors-292 +fastify__fastify-cors-6 +fastify__fastify-jwt-131 +fastify__fastify-jwt-91 +fastify__fastify-swagger-233 +fastify__fastify-swagger-305 +fastify__fastify-swagger-385 +fastify__fastify-swagger-44 +fastify__fastify-swagger-67 +fastify__fastify-swagger-748 +fastify__fastify-swagger-86 +fastify__github-action-merge-dependabot-176 +fastify__github-action-merge-dependabot-186 +fastify__github-action-merge-dependabot-411 +fastify__github-action-merge-dependabot-462 +fastify__light-my-request-208 +fastify__light-my-request-213 +fastify__light-my-request-218 +fastify__light-my-request-229 +fatiando__harmonica-205 +fatiando__harmonica-315 +fatiando__harmonica-316 +fatiando__harmonica-373 +fatiando__harmonica-398 +fatiando__harmonica-419 +fatiando__harmonica-430 +fatiando__harmonica-453 +fatiando__harmonica-478 +fatiando__harmonica-479 +fatiando__harmonica-487 +fatiando__harmonica-491 +fatiando__harmonica-510 +fatiando__harmonica-515 +fatiando__pooch-165 +fatiando__verde-101 +fatiando__verde-163 +fatiando__verde-169 +fatiando__verde-181 +fatiando__verde-28 +fatiando__verde-29 +fatiando__verde-3 +fatiando__verde-44 +fatiando__verde-69 +fatih__gomodifytags-37 +fatih__gomodifytags-41 +favonia__cloudflare-ddns-270 +favonia__cloudflare-ddns-280 +favonia__cloudflare-ddns-366 +favonia__cloudflare-ddns-411 +favonia__cloudflare-ddns-412 +favonia__cloudflare-ddns-502 +favonia__cloudflare-ddns-560 +favonia__cloudflare-ddns-564 +favonia__cloudflare-ddns-600 +favonia__cloudflare-ddns-624 +favonia__cloudflare-ddns-761 +favonia__cloudflare-ddns-774 +favonia__cloudflare-ddns-783 +favonia__cloudflare-ddns-784 +favonia__cloudflare-ddns-788 +favonia__cloudflare-ddns-851 +favonia__cloudflare-ddns-914 +favonia__cloudflare-ddns-936 +favonia__cloudflare-ddns-948 +feathersjs__feathers-authentication-349 +feathersjs__feathers-authentication-403 +feathersjs__feathers-authentication-456 +feathersjs__feathers-hooks-18 +feature-engine__feature_engine-304 +feature-engine__feature_engine-350 +feature-engine__feature_engine-458 +feature-engine__feature_engine-500 +feature-engine__feature_engine-531 +feature-engine__feature_engine-614 +feature-engine__feature_engine-663 +feature-engine__feature_engine-665 +feature-engine__feature_engine-793 +feature-engine__feature_engine-794 +feature-engine__feature_engine-857 +feed-rs__feed-rs-158 +feed-rs__feed-rs-168 +feed-rs__feed-rs-202 +feed-rs__feed-rs-207 +feed-rs__feed-rs-212 +feed-rs__feed-rs-238 +felangel__bloc-3704 +felangel__bloc-4310 +felangel__bloc-4311 +felangel__bloc-4486 +felangel__bloc-4521 +felangel__bloc-4562 +felangel__bloc-4569 +felangel__bloc-4572 +felangel__bloc-4633 +felangel__bloc-4648 +fermyon__spin-1169 +fermyon__spin-1235 +fermyon__spin-967 +ferranbt__fastssz-149 +ferrite-fem__ferrite.jl-1235 +ferrite-fem__ferrite.jl-392 +ferrite-fem__ferrite.jl-455 +ferrite-fem__ferrite.jl-505 +ferrite-fem__ferrite.jl-509 +ferrite-fem__ferrite.jl-535 +ferrite-fem__ferrite.jl-594 +ferrite-fem__ferrite.jl-606 +ferrite-fem__ferrite.jl-670 +ferrite-fem__ferrite.jl-721 +ferrite-fem__ferrite.jl-771 +ferrite-fem__ferrite.jl-967 +ferrite-fem__ferrite.jl-979 +ferrite-fem__ferrite.jl-981 +ferrite-fem__ferrite.jl-998 +fgnass__node-dev-227 +fgnass__node-dev-230 +fgnass__node-dev-232 +fgnass__node-dev-237 +fgnass__node-dev-239 +fgnass__node-dev-262 +fhir__sushi-1000 +fhir__sushi-1006 +fhir__sushi-1014 +fhir__sushi-1016 +fhir__sushi-1034 +fhir__sushi-1036 +fhir__sushi-1046 +fhir__sushi-1047 +fhir__sushi-1050 +fhir__sushi-1056 +fhir__sushi-1057 +fhir__sushi-1066 +fhir__sushi-1074 +fhir__sushi-1076 +fhir__sushi-1085 +fhir__sushi-1100 +fhir__sushi-1102 +fhir__sushi-1104 +fhir__sushi-1115 +fhir__sushi-1116 +fhir__sushi-1153 +fhir__sushi-1158 +fhir__sushi-1175 +fhir__sushi-1182 +fhir__sushi-1186 +fhir__sushi-1189 +fhir__sushi-1193 +fhir__sushi-1196 +fhir__sushi-1198 +fhir__sushi-1237 +fhir__sushi-1257 +fhir__sushi-1291 +fhir__sushi-1294 +fhir__sushi-1295 +fhir__sushi-1316 +fhir__sushi-1317 +fhir__sushi-1318 +fhir__sushi-1329 +fhir__sushi-1331 +fhir__sushi-1339 +fhir__sushi-134 +fhir__sushi-1348 +fhir__sushi-1353 +fhir__sushi-1363 +fhir__sushi-137 +fhir__sushi-1378 +fhir__sushi-1400 +fhir__sushi-1405 +fhir__sushi-1418 +fhir__sushi-142 +fhir__sushi-1420 +fhir__sushi-1427 +fhir__sushi-1433 +fhir__sushi-1434 +fhir__sushi-1436 +fhir__sushi-1452 +fhir__sushi-1456 +fhir__sushi-1462 +fhir__sushi-1464 +fhir__sushi-1466 +fhir__sushi-1503 +fhir__sushi-1520 +fhir__sushi-1524 +fhir__sushi-1528 +fhir__sushi-1534 +fhir__sushi-1537 +fhir__sushi-1539 +fhir__sushi-154 +fhir__sushi-1540 +fhir__sushi-1541 +fhir__sushi-156 +fhir__sushi-1568 +fhir__sushi-158 +fhir__sushi-161 +fhir__sushi-164 +fhir__sushi-165 +fhir__sushi-167 +fhir__sushi-172 +fhir__sushi-173 +fhir__sushi-197 +fhir__sushi-202 +fhir__sushi-203 +fhir__sushi-215 +fhir__sushi-216 +fhir__sushi-219 +fhir__sushi-235 +fhir__sushi-253 +fhir__sushi-262 +fhir__sushi-270 +fhir__sushi-271 +fhir__sushi-304 +fhir__sushi-310 +fhir__sushi-317 +fhir__sushi-329 +fhir__sushi-334 +fhir__sushi-337 +fhir__sushi-340 +fhir__sushi-341 +fhir__sushi-348 +fhir__sushi-353 +fhir__sushi-359 +fhir__sushi-378 +fhir__sushi-400 +fhir__sushi-403 +fhir__sushi-404 +fhir__sushi-410 +fhir__sushi-439 +fhir__sushi-446 +fhir__sushi-457 +fhir__sushi-460 +fhir__sushi-461 +fhir__sushi-464 +fhir__sushi-465 +fhir__sushi-467 +fhir__sushi-469 +fhir__sushi-475 +fhir__sushi-509 +fhir__sushi-513 +fhir__sushi-518 +fhir__sushi-525 +fhir__sushi-539 +fhir__sushi-540 +fhir__sushi-541 +fhir__sushi-548 +fhir__sushi-552 +fhir__sushi-561 +fhir__sushi-565 +fhir__sushi-573 +fhir__sushi-579 +fhir__sushi-597 +fhir__sushi-628 +fhir__sushi-631 +fhir__sushi-633 +fhir__sushi-634 +fhir__sushi-636 +fhir__sushi-637 +fhir__sushi-639 +fhir__sushi-643 +fhir__sushi-644 +fhir__sushi-645 +fhir__sushi-651 +fhir__sushi-661 +fhir__sushi-665 +fhir__sushi-704 +fhir__sushi-710 +fhir__sushi-727 +fhir__sushi-735 +fhir__sushi-739 +fhir__sushi-745 +fhir__sushi-746 +fhir__sushi-757 +fhir__sushi-762 +fhir__sushi-763 +fhir__sushi-766 +fhir__sushi-770 +fhir__sushi-771 +fhir__sushi-776 +fhir__sushi-796 +fhir__sushi-799 +fhir__sushi-803 +fhir__sushi-839 +fhir__sushi-841 +fhir__sushi-843 +fhir__sushi-860 +fhir__sushi-861 +fhir__sushi-869 +fhir__sushi-878 +fhir__sushi-881 +fhir__sushi-888 +fhir__sushi-893 +fhir__sushi-898 +fhir__sushi-907 +fhir__sushi-908 +fhir__sushi-913 +fhir__sushi-916 +fhir__sushi-922 +fhir__sushi-945 +fhir__sushi-946 +fhir__sushi-957 +fhir__sushi-960 +fhir__sushi-964 +fhir__sushi-965 +fhir__sushi-966 +fhir__sushi-979 +fhir__sushi-985 +fhir__sushi-995 +fhir__sushi-996 +fika-lang__fika-14 +fika-lang__fika-18 +fika-lang__fika-20 +fika-lang__fika-34 +fika-lang__fika-37 +fika-lang__fika-43 +fika-lang__fika-48 +fika-lang__fika-56 +fika-lang__fika-74 +fika-lang__fika-77 +filamentphp__filament-3933 +filamentphp__filament-4429 +filamentphp__filament-4431 +filecoin-project__bacalhau-2024 +filecoin-project__builtin-actors-1422 +filecoin-project__builtin-actors-1424 +filecoin-project__builtin-actors-1438 +filecoin-project__builtin-actors-581 +filecoin-project__builtin-actors-611 +filecoin-project__builtin-actors-669 +filecoin-project__builtin-actors-715 +filecoin-project__builtin-actors-722 +filecoin-project__builtin-actors-725 +filecoin-project__builtin-actors-746 +filecoin-project__specs-actors-1389 +filecoin-project__specs-actors-1390 +filecoin-project__specs-actors-1416 +filecoin-project__specs-actors-1489 +filecoin-project__specs-actors-1564 +filecoin-project__specs-actors-378 +filecoin-project__specs-actors-427 +filecoin-project__specs-actors-434 +filecoin-project__specs-actors-435 +filecoin-project__specs-actors-443 +filecoin-project__specs-actors-472 +filecoin-project__specs-actors-482 +filecoin-project__specs-actors-496 +filecoin-project__specs-actors-501 +filecoin-project__specs-actors-516 +filecoin-project__specs-actors-518 +filecoin-project__specs-actors-525 +filecoin-project__specs-actors-533 +filecoin-project__specs-actors-562 +filecoin-project__specs-actors-567 +filecoin-project__specs-actors-572 +filecoin-project__specs-actors-581 +filecoin-project__specs-actors-584 +filecoin-project__specs-actors-592 +filecoin-project__specs-actors-611 +filecoin-project__specs-actors-638 +filecoin-project__specs-actors-644 +filecoin-project__specs-actors-646 +filecoin-project__specs-actors-659 +filecoin-project__specs-actors-703 +filerjs__filer-648 +filerjs__filer-739 +filerjs__filer-745 +filerjs__filer-756 +filerjs__filer-778 +final-form__final-form-265 +final-form__final-form-33 +final-form__final-form-385 +final-form__final-form-386 +final-form__final-form-453 +final-form__final-form-46 +final-form__final-form-57 +final-form__final-form-64 +final-form__react-final-form-111 +final-form__react-final-form-153 +final-form__react-final-form-42 +final-form__react-final-form-44 +final-form__react-final-form-608 +final-form__react-final-form-678 +financialforcedev__debug-log-analyzer-215 +financialforcedev__debug-log-analyzer-217 +finos__fdc3-1246 +finos__fdc3-1247 +finos__fdc3-315 +finos__fdc3-516 +finos__legend-studio-695 +finos__legend-studio-776 +firebase__firebase-admin-go-299 +firebase__firebase-admin-go-459 +firebase__firebase-admin-go-530 +firebase__firebase-admin-java-156 +firebase__firebase-admin-java-158 +firebase__firebase-admin-java-167 +firebase__firebase-admin-java-338 +firebase__firebase-admin-java-389 +firebase__firebase-admin-java-439 +firebase__firebase-admin-java-475 +firebase__firebase-tools-2214 +firebase__firebase-tools-2321 +firebase__firebase-tools-2467 +firebase__firebase-tools-2696 +firebase__firebase-tools-2733 +firebase__firebase-tools-2885 +firebase__firebase-tools-3025 +firebase__firebase-tools-3033 +firebase__firebase-tools-3096 +firebase__firebase-tools-3099 +firebase__firebase-tools-3105 +firebase__firebase-tools-3246 +firebase__firebase-tools-3253 +firebase__firebase-tools-3351 +firebase__firebase-tools-3505 +firebase__firebase-tools-3540 +firebase__firebase-tools-3593 +firebase__firebase-tools-3611 +firebase__firebase-tools-3643 +firebase__firebase-tools-3674 +firebase__firebase-tools-4746 +firebase__firebase-tools-4815 +firebase__firebase-tools-5109 +firebase__firebase-tools-5261 +firebase__firebase-tools-5499 +firebase__firebase-tools-6166 +firebase__firebase-tools-6272 +firebase__firebase-tools-6389 +firebase__firebase-tools-6391 +firebase__firebase-tools-6479 +firebase__firebase-tools-6630 +firebase__firebase-tools-6713 +firecow__gitlab-ci-local-1175 +firecow__gitlab-ci-local-1193 +firecow__gitlab-ci-local-1223 +firecow__gitlab-ci-local-1341 +firecracker-microvm__firecracker-containerd-240 +firecracker-microvm__firecracker-containerd-244 +firecracker-microvm__firecracker-containerd-270 +firecracker-microvm__firecracker-containerd-308 +firecracker-microvm__firecracker-containerd-346 +firecracker-microvm__firecracker-containerd-355 +fission__fission-2755 +fission__fission-2772 +fitzgen__bumpalo-205 +fitzgen__bumpalo-67 +flatpickr__flatpickr-1742 +flatpickr__flatpickr-1753 +flatpickr__flatpickr-1983 +flatpickr__flatpickr-2278 +flatpickr__flatpickr-2281 +flekschas__regl-scatterplot-202 +flekschas__regl-scatterplot-207 +flekschas__regl-scatterplot-208 +flekschas__regl-scatterplot-210 +flexmeasures__flexmeasures-899 +florianholzapfel__express-restify-mongoose-360 +fluentlenium__fluentlenium-149 +fluentlenium__fluentlenium-159 +fluentlenium__fluentlenium-198 +fluid-cloudnative__fluid-3786 +fluid-cloudnative__fluid-3788 +flutter-bounty-hunters__static_shock-153 +fluture-js__fluture-73 +fluuxio__go-xmpp-114 +fluuxio__go-xmpp-115 +fluuxio__go-xmpp-39 +fluuxio__go-xmpp-46 +fluxcd__flagger-1408 +fluxcd__flux-3193 +fluxcd__image-reflector-controller-780 +fluxcd__notification-controller-426 +fluxml__optimisers.jl-188 +fluxml__optimisers.jl-190 +fluxml__optimisers.jl-209 +fluxml__optimisers.jl-36 +fluxml__optimisers.jl-68 +fluxml__optimisers.jl-89 +fontoxml__fontoxpath-512 +fontoxml__fontoxpath-540 +fontoxml__fontoxpath-673 +foolip__mdn-bcd-collector-1813 +foolip__mdn-bcd-collector-2157 +foolip__mdn-bcd-collector-791 +formidablelabs__spectacle-347 +formidablelabs__spectacle-542 +formidablelabs__spectacle-574 +formidablelabs__spectacle-606 +formidablelabs__spectacle-864 +formidablelabs__urql-1040 +formidablelabs__urql-1046 +formidablelabs__urql-1077 +formidablelabs__urql-1117 +formidablelabs__urql-1208 +formidablelabs__urql-1219 +formidablelabs__urql-1308 +formidablelabs__urql-1357 +formidablelabs__urql-1375 +formidablelabs__urql-1379 +formidablelabs__urql-1509 +formidablelabs__urql-1626 +formidablelabs__urql-1641 +formidablelabs__urql-1780 +formidablelabs__urql-1859 +formidablelabs__urql-1869 +formidablelabs__urql-2295 +formidablelabs__urql-2431 +formidablelabs__urql-256 +formidablelabs__urql-281 +formidablelabs__urql-305 +formidablelabs__urql-321 +formidablelabs__urql-348 +formidablelabs__urql-357 +formidablelabs__urql-383 +formidablelabs__urql-401 +formidablelabs__urql-410 +formidablelabs__urql-485 +formidablelabs__urql-515 +formidablelabs__urql-607 +formidablelabs__urql-629 +formidablelabs__urql-650 +formidablelabs__urql-669 +formidablelabs__urql-695 +formidablelabs__urql-718 +formidablelabs__urql-727 +formidablelabs__urql-772 +formidablelabs__urql-826 +formidablelabs__urql-880 +formidablelabs__urql-962 +fortio__fortio-414 +fortio__fortio-415 +fortio__fortio-511 +fortio__fortio-516 +fortio__fortio-536 +fortio__fortio-552 +fortio__fortio-589 +fortio__fortio-594 +fortio__fortio-621 +fortio__fortio-625 +fortio__fortio-649 +fortio__fortio-688 +fortio__fortio-974 +foundationdb__fdb-kubernetes-operator-1865 +foundationdb__fdb-kubernetes-operator-2227 +frain-dev__convoy-1045 +frain-dev__convoy-2216 +frain-dev__convoy-635 +frain-dev__convoy-672 +frain-dev__convoy-677 +frain-dev__convoy-904 +francescov1__mongoose-tsgen-100 +francescov1__mongoose-tsgen-138 +francescov1__mongoose-tsgen-146 +francescov1__mongoose-tsgen-147 +francescov1__mongoose-tsgen-148 +francescov1__mongoose-tsgen-150 +francescov1__mongoose-tsgen-154 +francescov1__mongoose-tsgen-48 +francescov1__mongoose-tsgen-55 +francescov1__mongoose-tsgen-82 +francoismassart__eslint-plugin-tailwindcss-103 +francoismassart__eslint-plugin-tailwindcss-115 +francoismassart__eslint-plugin-tailwindcss-158 +francoismassart__eslint-plugin-tailwindcss-185 +francoismassart__eslint-plugin-tailwindcss-217 +francoismassart__eslint-plugin-tailwindcss-244 +francoismassart__eslint-plugin-tailwindcss-246 +francoismassart__eslint-plugin-tailwindcss-33 +francoismassart__eslint-plugin-tailwindcss-58 +fraserxu__electron-pdf-237 +fraserxu__electron-pdf-250 +fraserxu__electron-pdf-284 +fredrikekre__runic.jl-110 +fredrikekre__runic.jl-116 +fredrikekre__runic.jl-138 +fredrikekre__runic.jl-152 +fredrikekre__runic.jl-170 +fredrikekre__runic.jl-42 +fredrikekre__runic.jl-44 +fredrikekre__runic.jl-55 +fredrikekre__runic.jl-59 +frictionlessdata__datapackage-py-257 +frictionlessdata__datapackage-py-260 +frictionlessdata__datapackage-py-262 +frictionlessdata__frictionless-py-1729 +frictionlessdata__tabulator-py-107 +frictionlessdata__tabulator-py-108 +frictionlessdata__tabulator-py-125 +frictionlessdata__tabulator-py-129 +frictionlessdata__tabulator-py-192 +frictionlessdata__tabulator-py-207 +frictionlessdata__tabulator-py-60 +frictionlessdata__tabulator-py-67 +frictionlessdata__tabulator-py-69 +friendsofsymfony__foshttpcachebundle-644 +friendsoftwig__twigcs-247 +fsnotify__fsnotify-479 +fsnotify__fsnotify-516 +fsouza__fake-gcs-server-1020 +fsouza__fake-gcs-server-1035 +fsouza__fake-gcs-server-1141 +fsouza__fake-gcs-server-1150 +fsouza__fake-gcs-server-1519 +fsouza__fake-gcs-server-290 +fsouza__fake-gcs-server-528 +fsouza__fake-gcs-server-803 +fsspec__filesystem_spec-1829 +fsspec__gcsfs-502 +fsspec__gcsfs-550 +fsspec__gcsfs-551 +fsspec__gcsfs-571 +fsspec__universal_pathlib-102 +fsspec__universal_pathlib-134 +fsspec__universal_pathlib-148 +fsspec__universal_pathlib-203 +fsspec__universal_pathlib-204 +fsspec__universal_pathlib-254 +fsspec__universal_pathlib-261 +fsspec__universal_pathlib-264 +fsspec__universal_pathlib-265 +fsspec__universal_pathlib-293 +fsspec__universal_pathlib-294 +fsspec__universal_pathlib-372 +fsspec__universal_pathlib-86 +fterh__heimdall-25 +fterh__heimdall-44 +fterh__heimdall-45 +fuellabs__fuel-vm-205 +fuellabs__fuel-vm-238 +fuellabs__fuel-vm-240 +fuellabs__fuel-vm-262 +fuellabs__fuel-vm-404 +fuellabs__fuel-vm-407 +fuellabs__fuelup-104 +fuellabs__fuelup-126 +fuellabs__fuelup-410 +fuellabs__fuelup-423 +fujiapple852__trippy-1008 +fujiapple852__trippy-1063 +fujiapple852__trippy-1218 +fujiapple852__trippy-1338 +fujiapple852__trippy-1353 +fujiapple852__trippy-1464 +fujiapple852__trippy-928 +furiko-io__furiko-114 +furiko-io__furiko-125 +furiko-io__furiko-34 +furiko-io__furiko-48 +furiko-io__furiko-52 +furiko-io__furiko-62 +fxamacker__cbor-217 +fxamacker__cbor-219 +fxamacker__cbor-222 +fxamacker__cbor-224 +fxamacker__cbor-225 +fxamacker__cbor-226 +fxamacker__cbor-230 +fxamacker__cbor-243 +fxamacker__cbor-253 +fxamacker__cbor-255 +fxamacker__cbor-257 +fxamacker__cbor-259 +fxamacker__cbor-308 +fxamacker__cbor-322 +fxamacker__cbor-325 +fxamacker__cbor-342 +fxamacker__cbor-379 +fxamacker__cbor-380 +fxamacker__cbor-381 +fxamacker__cbor-387 +fxamacker__cbor-400 +fxamacker__cbor-410 +fxamacker__cbor-456 +fxamacker__cbor-457 +fxamacker__cbor-461 +fxamacker__cbor-464 +fxamacker__cbor-485 +fyne-io__fyne-1479 +fyne-io__fyne-1609 +fyne-io__fyne-1662 +fyne-io__fyne-1670 +fyne-io__fyne-1691 +fyne-io__fyne-1695 +fyne-io__fyne-1799 +fyne-io__fyne-1810 +fyne-io__fyne-1816 +fyne-io__fyne-1817 +fyne-io__fyne-5554 +fyne-io__fyne-5563 +fyne-io__fyne-5570 +fyne-io__fyne-5643 +fyne-io__fyne-5712 +fyne-io__fyne-5759 +fyne-io__fyne-5805 +fyne-io__fyne-5862 +g-rath__osv-detector-15 +g-research__fasttrackml-1174 +gabriel-vasile__mimetype-268 +gabriel-vasile__mimetype-41 +gabriel-vasile__mimetype-466 +gabriel-vasile__mimetype-621 +gaearon__react-hot-loader-639 +gajus__eslint-plugin-jsdoc-1007 +gajus__eslint-plugin-jsdoc-951 +galileo-galilei__kedro-mlflow-368 +galileo-galilei__kedro-mlflow-585 +galileo-galilei__kedro-mlflow-615 +galileo-galilei__kedro-mlflow-629 +galileo-galilei__kedro-mlflow-633 +galileo-galilei__kedro-mlflow-640 +gammapy__gammapy-5300 +gammapy__gammapy-5342 +gammapy__gammapy-5366 +gammapy__gammapy-5389 +gammapy__gammapy-5409 +gammapy__gammapy-5508 +gammapy__gammapy-5525 +gammapy__gammapy-5674 +gammapy__gammapy-5720 +gammapy__gammapy-5958 +gammazero__nexus-72 +gammazero__nexus-85 +gardener__etcd-druid-1103 +gardener__external-dns-management-481 +gardener__machine-controller-manager-316 +gardener__machine-controller-manager-416 +gardener__machine-controller-manager-480 +gardener__machine-controller-manager-492 +gardener__machine-controller-manager-495 +gardener__machine-controller-manager-564 +gardener__machine-controller-manager-605 +gardener__machine-controller-manager-803 +gardener__machine-controller-manager-821 +gardener__machine-controller-manager-866 +gardener__machine-controller-manager-949 +garmeeh__next-seo-1062 +garmeeh__next-seo-1080 +garmeeh__next-seo-1122 +garmeeh__next-seo-1224 +garmeeh__next-seo-45 +garmeeh__next-seo-6 +gavv__httpexpect-189 +gavv__httpexpect-194 +gavv__httpexpect-214 +gavv__httpexpect-230 +gavv__httpexpect-243 +gavv__httpexpect-247 +gavv__httpexpect-257 +gavv__httpexpect-266 +gavv__httpexpect-278 +gavv__httpexpect-287 +gavv__httpexpect-318 +gavv__httpexpect-337 +gavv__httpexpect-341 +gavv__httpexpect-342 +gcanti__fp-ts-1063 +gcanti__fp-ts-1066 +gcanti__fp-ts-1257 +gcanti__fp-ts-1434 +gcanti__fp-ts-1450 +gcanti__fp-ts-1487 +gcanti__fp-ts-1591 +gcanti__fp-ts-1676 +gcanti__fp-ts-768 +gcanti__fp-ts-794 +gcanti__fp-ts-801 +gcanti__fp-ts-804 +gcanti__fp-ts-915 +gcanti__io-ts-222 +gcanti__io-ts-355 +gcanti__io-ts-398 +gcanti__io-ts-408 +gcanti__io-ts-417 +gcanti__io-ts-421 +gcanti__io-ts-425 +gcanti__io-ts-451 +gcanti__io-ts-534 +gcanti__io-ts-types-133 +gcanti__io-ts-types-157 +gcanti__io-ts-types-45 +gcanti__io-ts-types-52 +gcanti__io-ts-types-85 +gcanti__io-ts-types-86 +gcanti__tcomb-166 +gcanti__tcomb-171 +gcanti__tcomb-173 +gcanti__tcomb-175 +gcanti__tcomb-186 +gcanti__tcomb-196 +gcanti__tcomb-215 +gcanti__tcomb-228 +gcanti__tcomb-233 +gcanti__tcomb-237 +gcanti__tcomb-244 +gcanti__tcomb-246 +gcanti__tcomb-251 +gcanti__tcomb-256 +gcanti__tcomb-258 +gcanti__tcomb-268 +gcanti__tcomb-298 +gcanti__tcomb-313 +geal__nom-1354 +geal__nom-486 +gembaadvantage__uplift-28 +gembaadvantage__uplift-373 +gembaadvantage__uplift-374 +gembaadvantage__uplift-94 +general-cbic__poolex-127 +general-cbic__poolex-141 +general-cbic__poolex-144 +general-cbic__poolex-145 +general-cbic__poolex-15 +general-cbic__poolex-23 +general-cbic__poolex-35 +general-cbic__poolex-54 +general-cbic__poolex-59 +genjidb__genji-101 +genjidb__genji-114 +genjidb__genji-119 +genjidb__genji-120 +genjidb__genji-126 +genjidb__genji-127 +genjidb__genji-147 +genjidb__genji-153 +genjidb__genji-171 +genjidb__genji-174 +genjidb__genji-193 +genjidb__genji-216 +genjidb__genji-223 +genjidb__genji-229 +genjidb__genji-242 +genjidb__genji-260 +genjidb__genji-272 +genjidb__genji-279 +genjidb__genji-280 +genjidb__genji-282 +genjidb__genji-307 +genjidb__genji-313 +genjidb__genji-323 +genjidb__genji-324 +genjidb__genji-326 +genjidb__genji-342 +genjidb__genji-348 +genjidb__genji-352 +genjidb__genji-370 +genjidb__genji-373 +genjidb__genji-374 +genjidb__genji-378 +genjidb__genji-382 +genjidb__genji-384 +genjidb__genji-86 +genjidb__genji-98 +genshinsim__gcsim-316 +genshinsim__gcsim-377 +geoffrich__svelte-adapter-azure-swa-107 +geoffrich__svelte-adapter-azure-swa-142 +geoffrich__svelte-adapter-azure-swa-144 +geoffrich__svelte-adapter-azure-swa-177 +geoffrich__svelte-adapter-azure-swa-201 +geoffrich__svelte-adapter-azure-swa-74 +geofileops__geofileops-555 +geofileops__geofileops-592 +geopandas__geopandas-2284 +geopandas__geopandas-2298 +geopandas__geopandas-2305 +geopandas__geopandas-3202 +geopandas__geopandas-3272 +geopandas__geopandas-3395 +geopandas__geopandas-3541 +geopandas__geopandas-3564 +geopandas__geopandas-3591 +geopandas__geopandas-3599 +geopy__geopy-294 +geopy__geopy-339 +georust__geo-1310 +geoswift__geoswift-197 +geoswift__geoswift-224 +geoswift__geoswift-235 +geoswift__geoswift-236 +geoswift__geoswift-250 +geoswift__geoswift-264 +geoswift__geoswift-284 +geoswift__geoswift-307 +getgauge__gauge-1643 +getgauge__gauge-1701 +getgauge__gauge-1720 +getgauge__gauge-1750 +getgauge__gauge-1858 +getgauge__gauge-2433 +getgrit__gritql-143 +getgrit__gritql-151 +getindata__kedro-kubeflow-14 +getindata__kedro-kubeflow-27 +getindata__kedro-kubeflow-46 +getindata__kedro-kubeflow-52 +getindiekit__indiekit-696 +getindiekit__indiekit-712 +getindiekit__indiekit-719 +getindiekit__indiekit-730 +getkin__kin-openapi-140 +getkin__kin-openapi-150 +getkin__kin-openapi-160 +getkin__kin-openapi-205 +getkin__kin-openapi-207 +getkin__kin-openapi-229 +getkin__kin-openapi-237 +getkin__kin-openapi-291 +getkin__kin-openapi-292 +getkin__kin-openapi-320 +getkin__kin-openapi-337 +getkin__kin-openapi-346 +getkin__kin-openapi-355 +getkin__kin-openapi-377 +getkin__kin-openapi-393 +getkin__kin-openapi-403 +getkin__kin-openapi-431 +getkin__kin-openapi-445 +getkin__kin-openapi-453 +getkin__kin-openapi-469 +getkin__kin-openapi-501 +getkin__kin-openapi-544 +getkin__kin-openapi-552 +getkin__kin-openapi-559 +getkin__kin-openapi-565 +getkin__kin-openapi-575 +getkin__kin-openapi-592 +getkin__kin-openapi-628 +getkin__kin-openapi-649 +getkin__kin-openapi-729 +getkin__kin-openapi-734 +getkin__kin-openapi-747 +getkin__kin-openapi-752 +getkin__kin-openapi-770 +getkin__kin-openapi-795 +getkin__kin-openapi-93 +getmoto__moto-5835 +getmoto__moto-5843 +getmoto__moto-5844 +getmoto__moto-5847 +getmoto__moto-5849 +getmoto__moto-5853 +getmoto__moto-5862 +getmoto__moto-5864 +getmoto__moto-5865 +getmoto__moto-5870 +getmoto__moto-5873 +getmoto__moto-5876 +getmoto__moto-5878 +getmoto__moto-5885 +getmoto__moto-5893 +getmoto__moto-5895 +getmoto__moto-5899 +getmoto__moto-5940 +getmoto__moto-5960 +getmoto__moto-5968 +getmoto__moto-5969 +getmoto__moto-5980 +getmoto__moto-5989 +getmoto__moto-5991 +getmoto__moto-5997 +getmoto__moto-5999 +getmoto__moto-6022 +getmoto__moto-6028 +getmoto__moto-6038 +getmoto__moto-6049 +getmoto__moto-6056 +getmoto__moto-6085 +getmoto__moto-6086 +getmoto__moto-6106 +getmoto__moto-6114 +getmoto__moto-6127 +getmoto__moto-6176 +getmoto__moto-6185 +getmoto__moto-6208 +getmoto__moto-6212 +getmoto__moto-6226 +getmoto__moto-6238 +getmoto__moto-6240 +getmoto__moto-6255 +getmoto__moto-6299 +getmoto__moto-6306 +getmoto__moto-6308 +getmoto__moto-6312 +getmoto__moto-6317 +getmoto__moto-6350 +getmoto__moto-6355 +getmoto__moto-6387 +getmoto__moto-6391 +getmoto__moto-6408 +getmoto__moto-6444 +getmoto__moto-6469 +getmoto__moto-6492 +getmoto__moto-6535 +getmoto__moto-6536 +getmoto__moto-6557 +getmoto__moto-6567 +getmoto__moto-6588 +getmoto__moto-6618 +getmoto__moto-6637 +getmoto__moto-6641 +getmoto__moto-6687 +getmoto__moto-6701 +getmoto__moto-6716 +getmoto__moto-6720 +getmoto__moto-6724 +getmoto__moto-6726 +getmoto__moto-6734 +getmoto__moto-6736 +getmoto__moto-6755 +getmoto__moto-6756 +getmoto__moto-6784 +getmoto__moto-6785 +getmoto__moto-6795 +getmoto__moto-6802 +getmoto__moto-6804 +getmoto__moto-6807 +getmoto__moto-6810 +getmoto__moto-6816 +getmoto__moto-6828 +getmoto__moto-6854 +getmoto__moto-6857 +getmoto__moto-6863 +getmoto__moto-6864 +getmoto__moto-6867 +getmoto__moto-6868 +getmoto__moto-6875 +getmoto__moto-6905 +getmoto__moto-6906 +getmoto__moto-6913 +getmoto__moto-6919 +getmoto__moto-6920 +getmoto__moto-6923 +getmoto__moto-6953 +getmoto__moto-6988 +getmoto__moto-6998 +getmoto__moto-7023 +getmoto__moto-7029 +getmoto__moto-7035 +getmoto__moto-7061 +getmoto__moto-7085 +getmoto__moto-7102 +getmoto__moto-7105 +getmoto__moto-7111 +getmoto__moto-7119 +getmoto__moto-7144 +getmoto__moto-7148 +getmoto__moto-7153 +getmoto__moto-7167 +getmoto__moto-7177 +getmoto__moto-7208 +getmoto__moto-7211 +getmoto__moto-7212 +getmoto__moto-7233 +getmoto__moto-7270 +getmoto__moto-7271 +getmoto__moto-7283 +getmoto__moto-7324 +getmoto__moto-7328 +getmoto__moto-7331 +getmoto__moto-7348 +getmoto__moto-7361 +getmoto__moto-7365 +getmoto__moto-7371 +getmoto__moto-7373 +getmoto__moto-7385 +getmoto__moto-7390 +getmoto__moto-7393 +getmoto__moto-7434 +getmoto__moto-7439 +getmoto__moto-7484 +getmoto__moto-7490 +getmoto__moto-7495 +getmoto__moto-7514 +getmoto__moto-7524 +getmoto__moto-7537 +getmoto__moto-7566 +getmoto__moto-7567 +getmoto__moto-7579 +getmoto__moto-7580 +getmoto__moto-7607 +getmoto__moto-7608 +getmoto__moto-7635 +getmoto__moto-7646 +getmoto__moto-7647 +getmoto__moto-7650 +getmoto__moto-7704 +getmoto__moto-7721 +getmoto__moto-7728 +getmoto__moto-7729 +getmoto__moto-7773 +getmoto__moto-7795 +getmoto__moto-7798 +getmoto__moto-7820 +getmoto__moto-7821 +getmoto__moto-7828 +getmoto__moto-7835 +getmoto__moto-7838 +getmoto__moto-7850 +getmoto__moto-7874 +getmoto__moto-7928 +getmoto__moto-7934 +getmoto__moto-7939 +getmoto__moto-7940 +getmoto__moto-7943 +getmoto__moto-7945 +getmoto__moto-7954 +getmoto__moto-7955 +getmoto__moto-7960 +getmoto__moto-7961 +getmoto__moto-7963 +getmoto__moto-7964 +getmoto__moto-7965 +getmoto__moto-7968 +getmoto__moto-7969 +getmoto__moto-7983 +getmoto__moto-7992 +getmoto__moto-7993 +getmoto__moto-8005 +getmoto__moto-8007 +getmoto__moto-8009 +getmoto__moto-8013 +getmoto__moto-8014 +getmoto__moto-8015 +getmoto__moto-8020 +getmoto__moto-8031 +getmoto__moto-8032 +getmoto__moto-8049 +getmoto__moto-8055 +getmoto__moto-8062 +getmoto__moto-8094 +getmoto__moto-8109 +getmoto__moto-8120 +getmoto__moto-8129 +getmoto__moto-8131 +getmoto__moto-8199 +getmoto__moto-8202 +getmoto__moto-8205 +getmoto__moto-8215 +getmoto__moto-8237 +getmoto__moto-8280 +getmoto__moto-8281 +getmoto__moto-8296 +getmoto__moto-8303 +getmoto__moto-8315 +getmoto__moto-8342 +getmoto__moto-8350 +getmoto__moto-8365 +getmoto__moto-8379 +getmoto__moto-8390 +getmoto__moto-8392 +getmoto__moto-8423 +getmoto__moto-8441 +getmoto__moto-8469 +getmoto__moto-8491 +getmoto__moto-8499 +getmoto__moto-8504 +getmoto__moto-8529 +getmoto__moto-8538 +getmoto__moto-8551 +getmoto__moto-8581 +getmoto__moto-8609 +getmoto__moto-8621 +getmoto__moto-8645 +getmoto__moto-8739 +getmoto__moto-8745 +getmoto__moto-8751 +getmoto__moto-8780 +getmoto__moto-8796 +getmoto__moto-8816 +getmoto__moto-8828 +getmoto__moto-8833 +getmoto__moto-8869 +getmoto__moto-8923 +getmoto__moto-8984 +getmoto__moto-9005 +getmoto__moto-9051 +getporter__porter-1712 +getporter__porter-2137 +getsentry__responses-397 +getsentry__responses-530 +getsentry__sentry-capacitor-139 +getsentry__sentry-capacitor-145 +getsentry__sentry-capacitor-370 +getsentry__sentry-capacitor-454 +getsentry__sentry-capacitor-480 +getsentry__sentry-capacitor-602 +getsentry__sentry-capacitor-664 +getsentry__sentry-cli-1579 +getsentry__sentry-cli-2189 +getsentry__sentry-laravel-478 +getsentry__sentry-laravel-495 +getsentry__sentry-laravel-633 +getsentry__sentry-laravel-651 +getsentry__sentry-laravel-656 +getsentry__sentry-laravel-751 +getsentry__sentry-laravel-756 +getsentry__sentry-laravel-783 +getsentry__sentry-php-1276 +getsentry__sentry-php-1280 +getsentry__sentry-php-1294 +getsentry__sentry-php-1321 +getsentry__sentry-php-1334 +getsentry__sentry-php-1339 +getsentry__sentry-php-1349 +getsentry__sentry-php-1370 +getsentry__sentry-php-1378 +getsentry__sentry-php-1396 +getsentry__sentry-php-1407 +getsentry__sentry-php-1416 +getsentry__sentry-php-1424 +getsentry__sentry-php-1451 +getsentry__sentry-php-1467 +getsentry__sentry-php-1481 +getsentry__sentry-php-1483 +getsentry__sentry-rust-340 +getslash__slash-1035 +getslash__slash-1052 +gfx-rs__naga-343 +gfx-rs__naga-647 +gfx-rs__naga-897 +ghiscoding__angular-slickgrid-911 +ghiscoding__slickgrid-universal-472 +gilbsgilbs__babel-plugin-i18next-extract-10 +gilbsgilbs__babel-plugin-i18next-extract-120 +gilbsgilbs__babel-plugin-i18next-extract-174 +gilbsgilbs__babel-plugin-i18next-extract-214 +gilbsgilbs__babel-plugin-i18next-extract-64 +gillespie59__eslint-plugin-angular-543 +gimli-rs__addr2line-61 +gimli-rs__object-645 +gimli-rs__object-699 +gimli-rs__object-710 +gin-gonic__gin-1817 +gin-gonic__gin-1891 +gin-gonic__gin-1949 +gin-gonic__gin-2149 +gin-gonic__gin-2487 +gin-gonic__gin-2767 +gin-gonic__gin-2796 +gin-gonic__gin-2924 +gin-gonic__gin-3759 +gin-gonic__gin-3945 +gin-gonic__gin-3971 +gin-gonic__gin-4240 +git-lfs__git-lfs-3235 +git-lfs__git-lfs-3259 +git-lfs__git-lfs-3270 +git-lfs__git-lfs-3353 +git-lfs__git-lfs-3391 +git-lfs__git-lfs-3417 +git-lfs__git-lfs-3918 +git-lfs__git-lfs-3972 +git-lfs__git-lfs-4084 +git-lfs__git-lfs-4102 +git-lfs__git-lfs-4259 +git-lfs__git-lfs-4282 +git-lfs__git-lfs-4741 +git-lfs__git-lfs-4813 +git-lfs__git-lfs-4970 +git-lfs__git-lfs-5136 +git-lfs__git-lfs-5168 +git-lfs__git-lfs-5905 +gitbookio__markup-it-42 +gitbookio__markup-it-56 +gitbookio__markup-it-86 +github__git-lfs-1616 +github__issue-metrics-265 +github__issue-metrics-313 +github__issue-metrics-433 +github__issue-metrics-553 +github__issue-metrics-81 +gitify-app__gitify-1092 +gitify-app__gitify-1128 +gitify-app__gitify-1159 +gitify-app__gitify-1232 +gitify-app__gitify-1333 +gitify-app__gitify-1443 +gitify-app__gitify-1572 +gitify-app__gitify-1665 +gitify-app__gitify-1752 +gitify-app__gitify-1779 +gitify-app__gitify-713 +gitify-app__gitify-777 +gitify-app__gitify-787 +gitify-app__gitify-789 +gitify-app__gitify-812 +gitify-app__gitify-860 +gitify-app__gitify-898 +gitify-app__gitify-929 +gitify-app__gitify-946 +gitlabphp__client-750 +gitlabphp__client-769 +gitpython-developers__gitpython-496 +glasskube__glasskube-1158 +glasskube__glasskube-1160 +glayzzle__php-parser-142 +glayzzle__php-parser-143 +glayzzle__php-parser-85 +gleam-lang__gleam-3393 +gleam-lang__gleam-3486 +gleam-lang__gleam-3490 +gleam-lang__gleam-3510 +gleam-lang__gleam-3554 +gleam-lang__gleam-3654 +gleam-lang__gleam-3714 +gleam-lang__gleam-3721 +gleam-lang__gleam-3880 +gleam-lang__gleam-4102 +gleam-lang__gleam-4150 +gleam-lang__gleam-4155 +gleam-lang__gleam-4169 +gleam-lang__gleam-4184 +gleam-lang__gleam-4198 +gleam-lang__gleam-4236 +gleam-lang__gleam-4267 +gleam-lang__gleam-4293 +gleam-lang__gleam-4374 +gleam-lang__gleam-4377 +gleam-lang__gleam-4384 +gleam-lang__gleam-4392 +gleam-lang__gleam-4432 +gleam-lang__gleam-4433 +gleam-lang__gleam-4437 +gleam-lang__gleam-4455 +gleam-lang__gleam-4478 +gleam-lang__gleam-4483 +gleam-lang__gleam-4500 +gleam-lang__gleam-4508 +gleam-lang__gleam-4516 +gleam-lang__gleam-4534 +gleam-lang__gleam-4550 +gleam-lang__gleam-4573 +gleam-lang__gleam-4633 +gleam-lang__gleam-4655 +gleam-lang__tree-sitter-gleam-26 +glennjones__hapi-swagger-533 +glennjones__hapi-swagger-537 +glennjones__hapi-swagger-551 +glennjones__hapi-swagger-575 +glennjones__hapi-swagger-595 +glennjones__hapi-swagger-620 +globocom__huskyci-478 +globocom__huskyci-515 +globocom__huskyci-516 +globocom__huskyci-518 +globus__globus-sdk-python-251 +glotzerlab__signac-127 +glotzerlab__signac-185 +glotzerlab__signac-199 +glotzerlab__signac-253 +glotzerlab__signac-324 +glotzerlab__signac-336 +gluesql__gluesql-34 +gluesql__gluesql-89 +gluesql__gluesql-91 +gnolang__gno-3239 +gnolang__gno-3748 +gnolang__gno-3752 +gnolang__gno-3794 +gnolang__gno-3797 +gnolang__gno-3814 +gnolang__gno-3876 +gnolang__gno-3920 +gnolang__gno-3952 +gnolang__gno-3968 +go-bdd__gobdd-103 +go-bdd__gobdd-104 +go-bdd__gobdd-123 +go-bdd__gobdd-140 +go-bdd__gobdd-146 +go-bdd__gobdd-154 +go-bdd__gobdd-40 +go-bdd__gobdd-42 +go-bdd__gobdd-56 +go-bdd__gobdd-61 +go-bdd__gobdd-67 +go-bdd__gobdd-79 +go-bdd__gobdd-94 +go-co-op__gocron-122 +go-co-op__gocron-126 +go-co-op__gocron-635 +go-co-op__gocron-809 +go-co-op__gocron-811 +go-critic__go-critic-1372 +go-critic__go-critic-1377 +go-critic__go-critic-1437 +go-critic__go-critic-1445 +go-critic__go-critic-1470 +go-critic__go-critic-1486 +go-critic__go-critic-618 +go-delve__delve-3501 +go-delve__delve-3648 +go-delve__delve-3649 +go-delve__delve-3655 +go-git__go-git-1531 +go-git__go-git-1556 +go-jet__jet-367 +go-kit__kit-1212 +go-kit__kit-971 +go-kit__kit-974 +go-kivik__kivik-1049 +go-kivik__kivik-1057 +go-kivik__kivik-677 +go-kivik__kivik-702 +go-kivik__kivik-705 +go-kivik__kivik-707 +go-kivik__kivik-819 +go-kivik__kivik-861 +go-kivik__kivik-865 +go-kratos__kratos-1061 +go-kratos__kratos-1070 +go-kratos__kratos-1135 +go-kratos__kratos-1341 +go-kratos__kratos-1731 +go-kratos__kratos-1945 +go-kratos__kratos-1950 +go-kratos__kratos-2112 +go-kratos__kratos-2181 +go-kratos__kratos-2468 +go-kratos__kratos-2518 +go-kratos__kratos-2541 +go-kratos__kratos-2560 +go-kratos__kratos-2847 +go-kratos__kratos-3069 +go-kratos__kratos-3134 +go-kratos__kratos-3265 +go-kratos__kratos-3359 +go-ldap__ldap-111 +go-ldap__ldap-352 +go-ldap__ldap-425 +go-logr__logr-121 +go-logr__logr-124 +go-logr__logr-130 +go-logr__logr-153 +go-logr__logr-159 +go-logr__logr-203 +go-logr__logr-218 +go-logr__logr-28 +go-logr__logr-81 +go-logr__logr-96 +go-openapi__runtime-149 +go-openapi__runtime-200 +go-openapi__runtime-237 +go-openapi__runtime-248 +go-openapi__runtime-256 +go-openapi__strfmt-144 +go-openapi__strfmt-148 +go-openapi__strfmt-151 +go-piv__piv-go-130 +go-playground__validator-1064 +go-playground__validator-1080 +go-playground__validator-1114 +go-playground__validator-1122 +go-playground__validator-1163 +go-playground__validator-1214 +go-playground__validator-1313 +go-playground__validator-746 +go-playground__validator-769 +go-playground__validator-873 +go-python__gpython-74 +go-resty__resty-417 +go-resty__resty-438 +go-resty__resty-444 +go-resty__resty-452 +go-resty__resty-582 +go-resty__resty-583 +go-resty__resty-587 +go-resty__resty-605 +go-resty__resty-635 +go-resty__resty-637 +go-resty__resty-664 +go-resty__resty-674 +go-resty__resty-693 +go-resty__resty-698 +go-resty__resty-702 +go-resty__resty-774 +go-resty__resty-779 +go-resty__resty-813 +go-resty__resty-838 +go-resty__resty-885 +go-resty__resty-953 +go-resty__resty-956 +go-sprout__sprout-68 +go-sprout__sprout-75 +go-sprout__sprout-94 +go-sprout__sprout-98 +go-swagger__go-swagger-2143 +go-swagger__go-swagger-2226 +go-swagger__go-swagger-2325 +go-swagger__go-swagger-2327 +go-swagger__go-swagger-2341 +go-swagger__go-swagger-2365 +go-swagger__go-swagger-2434 +go-swagger__go-swagger-2440 +go-swagger__go-swagger-2458 +go-swagger__go-swagger-2460 +go-swagger__go-swagger-2461 +go-swagger__go-swagger-2478 +go-swagger__go-swagger-2502 +go-swagger__go-swagger-2514 +go-swagger__go-swagger-3033 +go-swagger__go-swagger-3034 +go-swagger__go-swagger-3040 +go-swagger__go-swagger-3157 +go-swagger__go-swagger-3180 +go-task__task-211 +go-task__task-64 +go-to-k__delstack-112 +go-to-k__delstack-296 +go-to-k__delstack-298 +go-to-k__delstack-341 +go-to-k__delstack-345 +go-to-k__delstack-83 +go-webauthn__webauthn-341 +goadesign__goa-2158 +goadesign__goa-2159 +goadesign__goa-2172 +goadesign__goa-2183 +goadesign__goa-2200 +goadesign__goa-2245 +goadesign__goa-2249 +goadesign__goa-2375 +goadesign__goa-2409 +goadesign__goa-2505 +goadesign__goa-2517 +goadesign__goa-2538 +goadesign__goa-2570 +goadesign__goa-2579 +goadesign__goa-2633 +goadesign__goa-2658 +goadesign__goa-2660 +goadesign__goa-2676 +goadesign__goa-2678 +goadesign__goa-2682 +goadesign__goa-2688 +goadesign__goa-2696 +goadesign__goa-2708 +goadesign__goa-2742 +goadesign__goa-2983 +goadesign__goa-2990 +goadesign__goa-2996 +goadesign__goa-3028 +goadesign__goa-3125 +goadesign__goa-3126 +goadesign__goa-3127 +goadesign__goa-3140 +goadesign__goa-3142 +goadesign__goa-3170 +goadesign__goa-3178 +goadesign__goa-3184 +goadesign__goa-3190 +goadesign__goa-3222 +goadesign__goa-3273 +goadesign__goa-3322 +goadesign__goa-3374 +goadesign__goa-3381 +goadesign__goa-3487 +goadesign__goa-3490 +goadesign__goa-3491 +goadesign__goa-3497 +goadesign__goa-3506 +goadesign__goa-3584 +goadesign__goa-3633 +goadesign__goa-3666 +goadesign__goa-3674 +goadesign__goa-3687 +goadesign__goa-3730 +goadesign__goa-3731 +gobuffalo__buffalo-2216 +gobuffalo__buffalo-2246 +gobuffalo__buffalo-2345 +gobuffalo__pop-708 +gobuffalo__pop-775 +gobuffalo__pop-781 +gobuffalo__pop-797 +goby-lang__goby-664 +goby-lang__goby-683 +goby-lang__goby-832 +goby-lang__goby-837 +goccy__go-json-430 +goccy__go-json-431 +goccy__go-json-435 +goccy__go-json-438 +goccy__go-json-442 +goccy__go-json-473 +goccy__go-json-6 +goccy__go-json-9 +goccy__go-yaml-103 +goccy__go-yaml-126 +goccy__go-yaml-138 +goccy__go-yaml-147 +goccy__go-yaml-149 +goccy__go-yaml-158 +goccy__go-yaml-206 +goccy__go-yaml-207 +goccy__go-yaml-212 +goccy__go-yaml-229 +goccy__go-yaml-231 +goccy__go-yaml-270 +goccy__go-yaml-278 +goccy__go-yaml-32 +goccy__go-yaml-328 +goccy__go-yaml-330 +goccy__go-yaml-35 +goccy__go-yaml-370 +goccy__go-yaml-442 +goccy__go-yaml-462 +goccy__go-yaml-47 +goccy__go-yaml-485 +goccy__go-yaml-507 +goccy__go-yaml-529 +goccy__go-yaml-6 +goccy__go-yaml-615 +goccy__go-yaml-623 +goccy__go-yaml-630 +goccy__go-yaml-647 +goccy__go-yaml-90 +gocql__gocql-1368 +gocql__gocql-1402 +godaddy__kubernetes-external-secrets-179 +godaddy__kubernetes-external-secrets-215 +godaddy__kubernetes-external-secrets-219 +godaddy__kubernetes-external-secrets-221 +godaddy__kubernetes-external-secrets-353 +godaddy__kubernetes-external-secrets-497 +godaddy__kubernetes-external-secrets-95 +godbus__dbus-152 +godbus__dbus-156 +godbus__dbus-161 +godbus__dbus-180 +godbus__dbus-192 +godbus__dbus-204 +godbus__dbus-232 +godbus__dbus-269 +godbus__dbus-297 +godot-rust__godot-rust-961 +godot-rust__godot-rust-970 +gofiber__fiber-2069 +gohanlon__swift-memberwise-init-macro-13 +gohanlon__swift-memberwise-init-macro-18 +gohanlon__swift-memberwise-init-macro-29 +gohanlon__swift-memberwise-init-macro-3 +gohanlon__swift-memberwise-init-macro-9 +gohugoio__hugo-13690 +gohugoio__hugo-13696 +gohugoio__hugo-13744 +gohugoio__hugo-13812 +gojek__feast-596 +gojek__feast-641 +gokcehan__lf-1308 +gokcehan__lf-1681 +gokcehan__lf-1818 +gokcehan__lf-1912 +gokcehan__lf-1932 +gokcehan__lf-238 +gokcehan__lf-305 +gokcehan__lf-394 +golang__mock-603 +golang__mock-89 +goldibex__targaryen-106 +goldibex__targaryen-109 +goldibex__targaryen-126 +goldibex__targaryen-132 +goldibex__targaryen-39 +goldibex__targaryen-41 +goldibex__targaryen-5 +goldibex__targaryen-66 +goldibex__targaryen-76 +goldibex__targaryen-87 +goldibex__targaryen-90 +gomods__athens-1986 +gomodule__redigo-476 +gomodule__redigo-488 +gomodule__redigo-490 +gomodule__redigo-527 +gomodule__redigo-530 +gonum__gonum-1117 +gonum__gonum-1988 +gonum__plot-549 +google__argh-49 +google__argh-64 +google__autocxx-123 +google__autocxx-181 +google__autocxx-182 +google__autocxx-256 +google__autocxx-306 +google__autocxx-341 +google__autocxx-73 +google__cadvisor-3565 +google__certificate-transparency-go-1085 +google__closure-compiler-1047 +google__closure-compiler-1079 +google__closure-compiler-1127 +google__closure-compiler-1137 +google__closure-compiler-1144 +google__closure-compiler-1245 +google__closure-compiler-868 +google__exposure-notifications-server-1527 +google__exposure-notifications-server-378 +google__exposure-notifications-server-550 +google__go-cloud-3505 +google__go-cloud-3513 +google__go-containerregistry-1762 +google__go-containerregistry-604 +google__go-containerregistry-656 +google__go-containerregistry-684 +google__go-flow-levee-126 +google__go-flow-levee-213 +google__go-flow-levee-248 +google__go-flow-levee-25 +google__go-flow-levee-252 +google__go-flow-levee-283 +google__go-flow-levee-322 +google__go-flow-levee-327 +google__go-github-1092 +google__go-github-1107 +google__go-github-1124 +google__go-github-1125 +google__go-github-1187 +google__go-github-1384 +google__go-github-1386 +google__go-github-1388 +google__go-github-1409 +google__go-github-1431 +google__go-github-1433 +google__go-github-1776 +google__go-github-1794 +google__go-github-1844 +google__go-github-1847 +google__go-github-1850 +google__go-github-1997 +google__go-github-1998 +google__go-github-2032 +google__go-github-2036 +google__go-github-2086 +google__go-github-2195 +google__go-github-2205 +google__go-github-2226 +google__go-github-2235 +google__go-github-2258 +google__go-github-2266 +google__go-github-2280 +google__go-github-2281 +google__go-github-2282 +google__go-github-2284 +google__go-github-2290 +google__go-github-2326 +google__go-github-2395 +google__go-github-2407 +google__go-github-2417 +google__go-github-2494 +google__go-github-2637 +google__go-github-2728 +google__go-github-2732 +google__go-github-2744 +google__go-github-2746 +google__go-github-2857 +google__go-github-2969 +google__go-github-2971 +google__go-github-2975 +google__go-github-2981 +google__go-github-2988 +google__go-github-2995 +google__go-github-3023 +google__go-github-3032 +google__go-github-3047 +google__go-github-3169 +google__go-github-3185 +google__go-github-3239 +google__go-github-3249 +google__go-github-3281 +google__go-github-3284 +google__go-github-3285 +google__go-github-3294 +google__go-github-3371 +google__go-github-3373 +google__go-github-3545 +google__go-github-3556 +google__go-github-3613 +google__go-github-3619 +google__go-github-3628 +google__go-github-733 +google__go-safeweb-104 +google__go-safeweb-114 +google__go-safeweb-123 +google__go-safeweb-135 +google__go-safeweb-140 +google__go-safeweb-146 +google__go-safeweb-170 +google__go-safeweb-185 +google__go-safeweb-198 +google__go-safeweb-207 +google__go-safeweb-209 +google__go-safeweb-242 +google__go-safeweb-244 +google__go-safeweb-251 +google__go-safeweb-262 +google__go-safeweb-263 +google__go-safeweb-275 +google__go-safeweb-301 +google__go-safeweb-309 +google__go-safeweb-321 +google__go-safeweb-346 +google__go-safeweb-41 +google__go-safeweb-45 +google__go-safeweb-50 +google__go-safeweb-53 +google__go-safeweb-54 +google__go-safeweb-58 +google__go-safeweb-65 +google__go-safeweb-71 +google__go-safeweb-93 +google__go-safeweb-95 +google__go-safeweb-98 +google__go-tpm-110 +google__go-tpm-155 +google__go-tpm-178 +google__go-tpm-338 +google__go-tpm-371 +google__go-tpm-391 +google__google-api-python-client-295 +google__google-api-python-client-347 +google__google-api-python-client-358 +google__google-api-python-client-465 +google__google-api-python-client-467 +google__google-api-python-client-546 +google__jax-20558 +google__jax-20731 +google__jax-21774 +google__jax-22541 +google__jax-22543 +google__jax-22744 +google__jax-22879 +google__jax-22897 +google__jax-23502 +google__kf-864 +google__ko-731 +google__osv-scanner-16 +google__osv-scanner-31 +google__pprof-565 +google__pprof-649 +google__pprof-684 +google__pprof-691 +google__starlark-go-398 +google__starlark-go-422 +google__starlark-go-453 +google__starlark-go-466 +google__starlark-go-599 +google__swift-benchmark-28 +google__swift-benchmark-37 +google__turbinia-321 +google__turbinia-484 +google__wire-126 +google__wire-159 +google__wire-175 +google__wire-210 +google__wire-220 +google__yamlfmt-105 +google__yamlfmt-106 +google__yamlfmt-159 +google__yamlfmt-17 +google__yamlfmt-19 +google__yamlfmt-216 +google__yamlfmt-239 +google__yamlfmt-24 +google__yamlfmt-248 +google__yamlfmt-259 +google__yamlfmt-36 +google__yamlfmt-4 +google__yamlfmt-40 +google__yamlfmt-42 +google__yamlfmt-50 +google__yamlfmt-55 +google__yamlfmt-64 +google__yamlfmt-90 +google__yapf-59 +googleapis__api-linter-1261 +googleapis__api-linter-309 +googleapis__api-linter-319 +googleapis__api-linter-411 +googleapis__api-linter-471 +googleapis__api-linter-477 +googleapis__api-linter-540 +googleapis__api-linter-543 +googleapis__api-linter-560 +googleapis__gapic-generator-go-1580 +googleapis__google-api-python-client-1623 +googleapis__google-api-python-client-2368 +googleapis__google-cloud-go-6596 +googleapis__google-http-java-client-1405 +googleapis__google-http-java-client-1411 +googleapis__google-http-java-client-1423 +googleapis__java-datastore-1011 +googleapis__java-datastore-1012 +googleapis__java-datastore-1055 +googleapis__java-datastore-1457 +googleapis__java-datastore-56 +googleapis__java-spanner-jdbc-1444 +googleapis__java-spanner-jdbc-1691 +googleapis__java-spanner-jdbc-284 +googleapis__java-spanner-jdbc-323 +googleapis__java-spanner-jdbc-326 +googleapis__java-spanner-jdbc-343 +googleapis__java-spanner-jdbc-36 +googleapis__java-spanner-jdbc-388 +googleapis__java-spanner-jdbc-397 +googleapis__java-spanner-jdbc-42 +googleapis__java-spanner-jdbc-445 +googleapis__java-spanner-jdbc-454 +googleapis__java-storage-102 +googleapis__java-storage-1354 +googleapis__java-storage-1389 +googleapis__java-storage-141 +googleapis__java-storage-1615 +googleapis__java-storage-162 +googleapis__java-storage-173 +googleapis__java-storage-19 +googleapis__java-storage-214 +googleapis__java-storage-218 +googleapis__java-storage-22 +googleapis__java-storage-229 +googleapis__java-storage-2547 +googleapis__java-storage-2583 +googleapis__java-storage-2661 +googleapis__java-storage-269 +googleapis__java-storage-308 +googleapis__java-storage-390 +googleapis__java-storage-396 +googleapis__java-storage-438 +googleapis__java-storage-449 +googleapis__java-storage-456 +googleapis__java-storage-479 +googleapis__java-storage-604 +googleapis__java-storage-636 +googleapis__java-storage-677 +googleapis__java-storage-726 +googleapis__java-storage-746 +googleapis__java-storage-82 +googleapis__java-storage-852 +googleapis__java-storage-872 +googleapis__python-api-core-115 +googleapis__python-api-core-184 +googleapis__python-api-core-197 +googleapis__python-api-core-200 +googleapis__python-api-core-228 +googleapis__python-api-core-237 +googleapis__python-api-core-30 +googleapis__python-api-core-621 +googleapis__python-api-core-821 +googleapis__python-api-core-86 +googleapis__python-bigquery-1879 +googleapis__python-bigquery-1937 +googleapis__python-bigquery-1989 +googleapis__python-bigquery-2039 +googleapis__python-bigquery-2097 +googleapis__python-bigquery-2135 +googleapis__python-bigquery-2140 +googleapis__python-bigquery-2218 +googlechrome__lighthouse-5846 +googlechrome__lighthouse-6347 +googlechrome__lighthouse-6447 +googlechrome__lighthouse-6549 +googlechrome__lighthouse-6835 +googlechrome__lighthouse-8216 +googlechrome__lighthouse-8407 +googlechrome__sw-precache-21 +googlechrome__sw-precache-28 +googlechrome__sw-precache-44 +googlechrome__sw-precache-65 +googlechromelabs__ps-analysis-tool-83 +googlechromelabs__ps-analysis-tool-84 +googlechromelabs__ps-analysis-tool-87 +googlechromelabs__ps-analysis-tool-88 +googlecloudplatform__cloud-bigtable-client-1727 +googlecloudplatform__cloud-bigtable-client-1875 +googlecloudplatform__cloud-bigtable-client-1894 +googlecloudplatform__cloud-bigtable-client-1950 +googlecloudplatform__cloud-bigtable-client-2005 +googlecloudplatform__cloud-sql-proxy-1496 +googlecloudplatform__cloud-sql-proxy-operator-338 +googlecloudplatform__cloud-sql-python-connector-1108 +googlecloudplatform__cloud-sql-python-connector-1118 +googlecloudplatform__cloud-sql-python-connector-1172 +googlecloudplatform__cloud-sql-python-connector-1201 +googlecloudplatform__cloud-sql-python-connector-1221 +googlecloudplatform__cloud-sql-python-connector-1241 +googlecloudplatform__cloud-sql-python-connector-1246 +googlecloudplatform__cloud-sql-python-connector-304 +googlecloudplatform__cloud-sql-python-connector-410 +googlecloudplatform__cloud-sql-python-connector-449 +googlecloudplatform__cloud-sql-python-connector-475 +googlecloudplatform__cloud-sql-python-connector-476 +googlecloudplatform__cloud-sql-python-connector-880 +googlecloudplatform__cloud-sql-python-connector-898 +googlecloudplatform__cloud-sql-python-connector-906 +googlecloudplatform__cloud-sql-python-connector-983 +googlecloudplatform__cloudsql-proxy-1068 +googlecloudplatform__functions-framework-python-137 +googlecloudplatform__functions-framework-python-214 +googlecloudplatform__gcp-service-broker-527 +googlecloudplatform__google-auth-library-python-128 +googlecloudplatform__google-auth-library-python-145 +googlecloudplatform__google-auth-library-python-188 +googlecloudplatform__google-auth-library-python-195 +googlecloudplatform__google-auth-library-python-262 +googlecloudplatform__google-auth-library-python-89 +googlecloudplatform__opentelemetry-operations-go-365 +googlecloudplatform__spark-on-k8s-operator-1261 +googlecloudplatform__spark-on-k8s-operator-1633 +googlecontainertools__kpt-2027 +googlecontainertools__krew-158 +googlecontainertools__skaffold-5538 +googlefonts__glyphslib-563 +googlefonts__ufo2ft-480 +googlefonts__ufo2ft-764 +googlefonts__ufo2ft-930 +googleforgames__open-saves-248 +googleforgames__open-saves-441 +googlemaps__google-maps-services-go-251 +googlemaps__google-maps-services-go-283 +googlemaps__google-maps-services-go-285 +googlemaps__google-maps-services-js-344 +googlemaps__google-maps-services-js-357 +googlemaps__google-maps-services-js-360 +googlemaps__google-maps-services-js-376 +googlemaps__google-maps-services-js-413 +googlemaps__google-maps-services-js-424 +googlemaps__google-maps-services-js-432 +googlemaps__google-maps-services-js-640 +googlemaps__js-api-loader-102 +googlemaps__js-api-loader-803 +googlemaps__js-api-loader-843 +gopcua__opcua-168 +gopcua__opcua-767 +gophercloud__gophercloud-3211 +gophercloud__gophercloud-3214 +gorakhargosh__watchdog-1101 +gorakhargosh__watchdog-940 +gorakhargosh__watchdog-946 +goreleaser__nfpm-482 +goreleaser__nfpm-576 +goreleaser__nfpm-578 +goreleaser__nfpm-601 +goreleaser__nfpm-691 +goreleaser__nfpm-701 +goreleaser__nfpm-715 +goreleaser__nfpm-725 +goreleaser__nfpm-754 +goreleaser__nfpm-779 +goreleaser__nfpm-794 +goreleaser__nfpm-808 +goreleaser__nfpm-834 +goreleaser__nfpm-836 +goreleaser__nfpm-841 +goreleaser__nfpm-854 +gorilla__mux-383 +gorilla__mux-477 +gorilla__mux-510 +gorilla__mux-535 +gorilla__mux-672 +gorilla__mux-712 +gorilla__mux-748 +gorilla__mux-760 +gorilla__websocket-773 +gorilla__websocket-942 +gorilla__websocket-945 +gotd__td-886 +gotenberg__gotenberg-1010 +gotenberg__gotenberg-1012 +gotenberg__gotenberg-1015 +gotenberg__gotenberg-382 +gotenberg__gotenberg-388 +gotenberg__gotenberg-736 +gotenberg__gotenberg-754 +gotenberg__gotenberg-802 +gotenberg__gotenberg-812 +gotenberg__gotenberg-813 +gotenberg__gotenberg-848 +gotenberg__gotenberg-901 +gotestyourself__gotestsum-149 +govuk-react__govuk-react-1118 +gpbl__react-day-picker-413 +gpbl__react-day-picker-435 +gpbl__react-day-picker-450 +gpbl__react-day-picker-502 +gpbl__react-day-picker-513 +gpbl__react-day-picker-550 +gpbl__react-day-picker-561 +gpbl__react-day-picker-568 +gpbl__react-day-picker-581 +gpbl__react-day-picker-596 +gpbl__react-day-picker-604 +gpbl__react-day-picker-715 +gpbl__react-day-picker-939 +gphotosuploader__gphotos-uploader-cli-153 +grafana__agent-6971 +grafana__dskit-146 +grafana__dskit-175 +grafana__dskit-357 +grafana__dskit-388 +grafana__dskit-445 +grafana__dskit-522 +grafana__dskit-577 +grafana__dskit-95 +grafana__grafana-plugin-sdk-go-1069 +grafana__grafana-plugin-sdk-go-1312 +grafana__grafana-plugin-sdk-go-149 +grafana__grafana-plugin-sdk-go-152 +grafana__grafana-plugin-sdk-go-204 +grafana__grafana-plugin-sdk-go-23 +grafana__grafana-plugin-sdk-go-330 +grafana__grafana-plugin-sdk-go-369 +grafana__grafana-plugin-sdk-go-408 +grafana__grafana-plugin-sdk-go-512 +grafana__grafana-plugin-sdk-go-535 +grafana__grafana-plugin-sdk-go-66 +grafana__grafana-plugin-sdk-go-663 +grafana__grafana-plugin-sdk-go-765 +grafana__grafana-plugin-sdk-go-830 +grafana__grafana-plugin-sdk-go-848 +grafana__grafana-plugin-sdk-go-863 +grafana__k6-operator-113 +grafana__k6-operator-154 +grafana__k6-operator-166 +grafana__k6-operator-202 +grafana__k6-operator-247 +grafana__k6-operator-71 +grafana__tanka-130 +grafana__tanka-162 +grafana__tanka-170 +grafana__tanka-198 +grafana__tanka-208 +grafana__tanka-216 +grafana__tanka-306 +grafana__tanka-338 +grafana__tanka-339 +grafana__tanka-381 +grafana__tanka-413 +grafana__tanka-572 +grafana__tanka-576 +grafana__tanka-667 +grafana__tanka-695 +grafana__tanka-702 +grafana__tanka-799 +grafana__tanka-84 +grafana__tanka-97 +graph-gophers__graphql-go-316 +graph-gophers__graphql-go-364 +graph-gophers__graphql-go-409 +graph-gophers__graphql-go-412 +graph-gophers__graphql-go-443 +graphprotocol__graph-tooling-1810 +graphprotocol__graph-tooling-1867 +graphprotocol__graph-tooling-1870 +graphprotocol__graph-tooling-1892 +graphprotocol__graph-tooling-1965 +graphprotocol__graph-tooling-1966 +graphprotocol__graph-tooling-1969 +graphql-java-kickstart__graphql-java-tools-375 +graphql-java-kickstart__graphql-java-tools-398 +graphql-java-kickstart__graphql-java-tools-404 +graphql-java-kickstart__graphql-java-tools-414 +graphql-java-kickstart__graphql-java-tools-435 +graphql-java-kickstart__graphql-java-tools-445 +graphql-java-kickstart__graphql-java-tools-453 +graphql-java-kickstart__graphql-java-tools-455 +graphql-java-kickstart__graphql-java-tools-462 +graphql-java-kickstart__graphql-java-tools-464 +graphql-java-kickstart__graphql-java-tools-559 +graphql-java-kickstart__graphql-java-tools-593 +graphql-java-kickstart__graphql-java-tools-596 +graphql-java-kickstart__graphql-java-tools-756 +graphql-java-kickstart__graphql-java-tools-757 +graphql-java-kickstart__graphql-java-tools-763 +graphql-java-kickstart__graphql-java-tools-764 +graphql-markdown__graphql-markdown-1583 +graphql-markdown__graphql-markdown-2215 +graphql-python__graphene-864 +graphql__graphql-js-3223 +graphql__graphql-js-3273 +graphql__graphql-js-3375 +graphql__graphql-js-3706 +graphql__graphql-js-3707 +graphql__graphql-js-3810 +graphql__graphql-js-3948 +graphql__graphql-js-3969 +graphql__graphql-js-4206 +graphql__graphql-js-4367 +gravity-ui__uikit-196 +gravity-ui__uikit-509 +gravity-ui__uikit-825 +gravity-ui__uikit-960 +graylog2__graylog2-server-23079 +great-expectations__great_expectations-11276 +greenmaskio__greenmask-178 +greenmaskio__greenmask-242 +greenmaskio__greenmask-293 +greenmaskio__greenmask-308 +gregberge__svgr-627 +gregberge__svgr-638 +gregberge__svgr-661 +gregberge__svgr-729 +gregnb__mui-datatables-167 +gregnb__mui-datatables-178 +gregnb__mui-datatables-250 +gregnb__mui-datatables-307 +gregnb__mui-datatables-341 +gregnb__mui-datatables-469 +gregnb__mui-datatables-480 +gregnb__mui-datatables-574 +gregnb__mui-datatables-984 +gresau__schemars-152 +gresau__schemars-234 +gresau__schemars-248 +gresau__schemars-304 +gresau__schemars-415 +gresau__schemars-421 +gresau__schemars-458 +greyli__apiflask-178 +greyli__apiflask-232 +greyli__apiflask-236 +greyli__apiflask-239 +greyli__apiflask-260 +gridtools__gt4py-1380 +gridtools__gt4py-1411 +gridtools__gt4py-1449 +grpc-ecosystem__go-grpc-middleware-547 +grpc__grpc-dotnet-2618 +grpc__grpc-go-8377 +grpc__grpc-swift-1107 +grpc__grpc-swift-1127 +grpc__grpc-swift-1139 +gruntwork-io__cloud-nuke-890 +gruntwork-io__terragrunt-4491 +gtalarico__pyairtable-250 +gtalarico__pyairtable-252 +gtalarico__pyairtable-262 +gtalarico__pyairtable-268 +gtalarico__pyairtable-381 +gtalarico__pyairtable-386 +gtalarico__pyairtable-396 +gtalarico__pyairtable-405 +gtalarico__pyairtable-416 +gtalarico__pyairtable-422 +gtalarico__pyairtable-431 +guacsec__guac-2391 +guacsec__guac-2394 +guillaumegomez__sysinfo-1162 +guillaumegomez__sysinfo-977 +gulpjs__vinyl-fs-100 +gulpjs__vinyl-fs-131 +gulpjs__vinyl-fs-188 +gulpjs__vinyl-fs-340 +gulpjs__vinyl-fs-341 +guzzle__psr7-492 +guzzle__psr7-514 +guzzle__psr7-532 +guzzle__psr7-568 +guzzle__psr7-594 +h5py__h5py-2433 +h5py__h5py-2463 +h5py__h5py-2577 +hacker0x01__react-datepicker-3999 +hacker0x01__react-datepicker-4282 +hacker0x01__react-datepicker-4319 +hacker0x01__react-datepicker-4336 +hacker0x01__react-datepicker-4392 +hacker0x01__react-datepicker-4394 +hacker0x01__react-datepicker-4417 +hacker0x01__react-datepicker-4430 +hacker0x01__react-datepicker-4457 +hacker0x01__react-datepicker-4512 +hacker0x01__react-datepicker-4533 +hacker0x01__react-datepicker-4568 +hacker0x01__react-datepicker-4601 +hacker0x01__react-datepicker-4602 +hacker0x01__react-datepicker-4603 +hacker0x01__react-datepicker-4608 +hacker0x01__react-datepicker-4609 +hacker0x01__react-datepicker-4624 +hacker0x01__react-datepicker-4634 +hacker0x01__react-datepicker-4643 +hacker0x01__react-datepicker-4652 +hacker0x01__react-datepicker-4698 +hacker0x01__react-datepicker-4848 +hacker0x01__react-datepicker-4903 +hacker0x01__react-datepicker-5151 +hacker0x01__react-datepicker-5291 +hacker0x01__react-datepicker-5503 +hacker0x01__react-datepicker-5524 +hacker0x01__react-datepicker-5539 +hacker0x01__react-datepicker-5584 +hairyhenderson__gomplate-2284 +hairyhenderson__gomplate-2287 +hairyhenderson__gomplate-2291 +hamba__avro-137 +hamba__avro-139 +hamba__avro-153 +hamba__avro-515 +hamba__avro-517 +hapijs__boom-45 +hapijs__boom-52 +hapijs__boom-80 +hapijs__code-121 +hapijs__code-25 +hapijs__code-26 +hapijs__code-36 +hapijs__code-48 +hapijs__code-58 +hapijs__code-62 +hapijs__code-71 +hapijs__code-73 +hapijs__good-338 +hapijs__good-356 +hapijs__good-446 +hapijs__joi-602 +hapijs__joi-616 +hapijs__joi-688 +hapijs__joi-730 +hapijs__joi-791 +hapijs__joi-830 +hapijs__wreck-70 +hapijs__wreck-77 +hapijs__wreck-94 +hapijs__wreck-97 +harrisiirak__cron-parser-368 +harrisiirak__cron-parser-374 +harrisiirak__cron-parser-379 +harttle__liquidjs-631 +harttle__liquidjs-661 +harttle__liquidjs-701 +harttle__liquidjs-780 +hashgraph__hedera-local-node-533 +hashgraph__hedera-local-node-539 +hashgraph__hedera-local-node-620 +hashgraph__hedera-local-node-659 +hashgraph__hedera-local-node-686 +hashgraph__hedera-local-node-734 +hashgraph__hedera-local-node-866 +hashgraph__hedera-local-node-868 +hashicorp__consul-10576 +hashicorp__consul-11514 +hashicorp__consul-18113 +hashicorp__consul-22189 +hashicorp__consul-6623 +hashicorp__consul-7245 +hashicorp__consul-7280 +hashicorp__consul-7583 +hashicorp__consul-7971 +hashicorp__consul-8234 +hashicorp__consul-8290 +hashicorp__consul-9067 +hashicorp__consul-9230 +hashicorp__go-hclog-136 +hashicorp__go-hclog-141 +hashicorp__go-hclog-16 +hashicorp__go-hclog-9 +hashicorp__terraform-28724 +hashicorp__terraform-28819 +hashicorp__terraform-28824 +hatoo__oha-167 +hatoo__oha-198 +hatoo__oha-232 +hatoo__oha-309 +hazelcast__hazelcast-go-client-964 +hazelcast__hazelcast-kubernetes-134 +hazelcast__hazelcast-kubernetes-137 +hazelcast__hazelcast-kubernetes-147 +hazelcast__hazelcast-kubernetes-148 +hazelcast__hazelcast-kubernetes-159 +hazelcast__hazelcast-kubernetes-294 +hazelcast__hazelcast-kubernetes-98 +hdmf-dev__hdmf-1081 +hdmf-dev__hdmf-1089 +hdmf-dev__hdmf-1122 +hdmf-dev__hdmf-1143 +hdmf-dev__hdmf-1149 +hdmf-dev__hdmf-1172 +hdmf-dev__hdmf-1183 +hdmf-dev__hdmf-1189 +hdmf-dev__hdmf-1258 +hdmf-dev__hdmf-1270 +hdmf-dev__hdmf-657 +hdmf-dev__hdmf-683 +hdmf-dev__hdmf-694 +hdmf-dev__hdmf-751 +hdmf-dev__hdmf-752 +hdmf-dev__hdmf-765 +hdmf-dev__hdmf-779 +hdmf-dev__hdmf-790 +hdmf-dev__hdmf-808 +hdmf-dev__hdmf-839 +hdmf-dev__hdmf-848 +hdmf-dev__hdmf-853 +hdmf-dev__hdmf-855 +hedhyw__json-log-viewer-14 +hedhyw__json-log-viewer-16 +heketi__heketi-994 +helm__chart-testing-280 +helm__chart-testing-591 +helm__chart-testing-735 +helm__helm-6555 +helm__helm-6602 +heptio__contour-1450 +heptio__contour-1465 +heptio__contour-1468 +heroku__react-refetch-106 +heroku__react-refetch-150 +hetznercloud__cli-987 +hetznercloud__hcloud-cloud-controller-manager-130 +hetznercloud__hcloud-cloud-controller-manager-137 +hetznercloud__hcloud-cloud-controller-manager-169 +hetznercloud__hcloud-cloud-controller-manager-194 +hetznercloud__hcloud-cloud-controller-manager-432 +hetznercloud__hcloud-cloud-controller-manager-55 +hetznercloud__hcloud-cloud-controller-manager-652 +hetznercloud__hcloud-cloud-controller-manager-66 +hetznercloud__hcloud-cloud-controller-manager-675 +hetznercloud__hcloud-cloud-controller-manager-715 +hetznercloud__hcloud-cloud-controller-manager-94 +hetznercloud__hcloud-go-266 +hetznercloud__hcloud-go-41 +hetznercloud__hcloud-go-42 +hetznercloud__hcloud-go-43 +hetznercloud__hcloud-go-44 +hetznercloud__hcloud-go-45 +hetznercloud__hcloud-go-46 +hetznercloud__hcloud-go-49 +hetznercloud__hcloud-go-50 +hetznercloud__hcloud-go-53 +hetznercloud__hcloud-go-54 +hetznercloud__hcloud-go-547 +hetznercloud__hcloud-go-56 +hetznercloud__hcloud-go-58 +hexpm__hex-945 +hgrecco__pint-pandas-195 +hgrecco__pint-pandas-239 +hgrecco__pint-pandas-273 +hhursev__recipe-scrapers-1230 +hibiken__asynq-120 +hibiken__asynq-159 +hibiken__asynq-276 +hibiken__asynq-319 +hibiken__asynq-350 +hibiken__asynq-627 +hibiken__asynq-65 +hibiken__asynq-72 +hibiken__asynq-81 +hibiken__asynq-946 +hibiken__asynq-95 +highcharts-for-python__highcharts-core-125 +highcharts-for-python__highcharts-core-132 +highcharts-for-python__highcharts-core-133 +highcharts-for-python__highcharts-core-145 +highcharts-for-python__highcharts-core-203 +highcharts-for-python__highcharts-core-33 +highcharts-for-python__highcharts-core-68 +highcharts-for-python__highcharts-core-69 +highcharts-for-python__highcharts-core-79 +highcharts-for-python__highcharts-core-83 +highcharts-for-python__highcharts-core-85 +hikari-py__hikari-1022 +hikari-py__hikari-1284 +hikari-py__hikari-1386 +hikari-py__hikari-1459 +hikari-py__hikari-1627 +hikari-py__hikari-1661 +hikari-py__hikari-1679 +hikari-py__hikari-1812 +hikari-py__hikari-1828 +hikari-py__hikari-2168 +hikari-py__hikari-2195 +hikari-py__hikari-2224 +hikari-py__hikari-2241 +hikari-py__hikari-398 +hikari-py__hikari-703 +hikari-py__hikari-763 +hikari-py__hikari-785 +hikari-py__hikari-803 +hikari-py__hikari-897 +hngprojects__hng_boilerplate_expressjs-180 +hngprojects__hng_boilerplate_expressjs-192 +hngprojects__hng_boilerplate_expressjs-302 +hngprojects__hng_boilerplate_expressjs-305 +hngprojects__hng_boilerplate_expressjs-444 +hngprojects__hng_boilerplate_expressjs-495 +hngprojects__hng_boilerplate_expressjs-517 +hoburg__gpkit-1152 +hoburg__gpkit-791 +hoburg__gpkit-840 +holoviz__holoviews-5568 +holoviz__holoviews-6403 +holoviz__holoviews-6534 +holunda-io__camunda-bpm-taskpool-838 +holunda-io__camunda-bpm-taskpool-869 +home-assistant__frontend-7541 +home-assistant__frontend-8971 +honeybadger-io__honeybadger-elixir-495 +honeybadger-io__honeybadger-elixir-609 +honeycombio__beeline-nodejs-110 +honeycombio__beeline-nodejs-213 +honeycombio__beeline-nodejs-514 +honeycombio__beeline-nodejs-533 +honeycombio__beeline-nodejs-551 +honeycombio__beeline-nodejs-94 +honeycombio__beeline-nodejs-98 +honeycombio__honeycomb-kubernetes-agent-198 +honeycombio__honeycomb-kubernetes-agent-206 +honeycombio__honeycomb-kubernetes-agent-241 +honeycombio__honeycomb-kubernetes-agent-302 +honeycombio__honeycomb-kubernetes-agent-348 +honeycombio__refinery-1358 +honeycombio__refinery-1431 +honeycombio__terraform-provider-honeycombio-110 +honeycombio__terraform-provider-honeycombio-112 +honeycombio__terraform-provider-honeycombio-210 +honeycombio__terraform-provider-honeycombio-211 +honeycombio__terraform-provider-honeycombio-236 +honeycombio__terraform-provider-honeycombio-282 +honeycombio__terraform-provider-honeycombio-345 +honeycombio__terraform-provider-honeycombio-353 +honeycombio__terraform-provider-honeycombio-444 +honeydipper__honeydipper-256 +honeydipper__honeydipper-270 +honojs__honox-230 +honojs__honox-251 +honojs__honox-252 +honojs__honox-266 +honojs__honox-297 +honojs__honox-302 +honojs__node-server-30 +hopding__pdf-lib-259 +hopding__pdf-lib-502 +hopding__pdf-lib-687 +horike37__serverless-step-functions-192 +horike37__serverless-step-functions-194 +horike37__serverless-step-functions-202 +horike37__serverless-step-functions-204 +horike37__serverless-step-functions-207 +horike37__serverless-step-functions-212 +horike37__serverless-step-functions-214 +horike37__serverless-step-functions-216 +horike37__serverless-step-functions-219 +horike37__serverless-step-functions-227 +horike37__serverless-step-functions-235 +horike37__serverless-step-functions-237 +horike37__serverless-step-functions-246 +horike37__serverless-step-functions-247 +horike37__serverless-step-functions-258 +horike37__serverless-step-functions-264 +horike37__serverless-step-functions-268 +horike37__serverless-step-functions-288 +horike37__serverless-step-functions-296 +horike37__serverless-step-functions-297 +horiuchi__dtsgenerator-409 +horiuchi__dtsgenerator-425 +horiuchi__dtsgenerator-437 +horiuchi__dtsgenerator-449 +horiuchi__dtsgenerator-455 +horiuchi__dtsgenerator-480 +horiuchi__dtsgenerator-486 +horiuchi__dtsgenerator-488 +horiuchi__dtsgenerator-491 +horiuchi__dtsgenerator-501 +horstoeko__zugferd-158 +horstoeko__zugferd-170 +horstoeko__zugferd-191 +horstoeko__zugferd-209 +horstoeko__zugferd-247 +horstoeko__zugferd-271 +horstoeko__zugferd-278 +horstoeko__zugferd-283 +horstoeko__zugferd-287 +horstoeko__zugferd-69 +horstoeko__zugferd-95 +horstoeko__zugferd-97 +hospitalrun__hospitalrun-frontend-2504 +hospitalrun__hospitalrun-frontend-2565 +hospitalrun__hospitalrun-frontend-2644 +hotmeteor__spectator-104 +hotmeteor__spectator-124 +hotmeteor__spectator-126 +hotmeteor__spectator-129 +hotmeteor__spectator-173 +hotmeteor__spectator-174 +hotmeteor__spectator-175 +hotmeteor__spectator-179 +hotmeteor__spectator-181 +hotmeteor__spectator-182 +hotmeteor__spectator-186 +hotmeteor__spectator-188 +hotmeteor__spectator-211 +hotmeteor__spectator-89 +housepower__clickhouse-native-jdbc-178 +housepower__clickhouse-native-jdbc-279 +hovancik__stretchly-260 +hovancik__stretchly-794 +hpcng__warewulf-948 +hpcng__warewulf-949 +hrzndhrn__recode-72 +hrzndhrn__recode-84 +http-apis__hydrus-308 +http-apis__hydrus-554 +http-apis__hydrus-556 +http-apis__hydrus-574 +http-apis__hydrus-580 +http-apis__hydrus-590 +http-apis__hydrus-591 +http-apis__hydrus-593 +http-apis__hydrus-599 +huff-language__huff-rs-180 +huff-language__huff-rs-182 +huff-language__huff-rs-185 +huff-language__huff-rs-194 +huff-language__huff-rs-293 +huff-language__huff-rs-313 +huge-success__sanic-1397 +huge-success__sanic-1539 +huggingface__huggingface_hub-1040 +huggingface__huggingface_hub-1214 +huggingface__huggingface_hub-2172 +huggingface__huggingface_hub-2653 +huggingface__huggingface_hub-2683 +huggingface__huggingface_hub-2770 +huggingface__huggingface_hub-2786 +huggingface__huggingface_hub-2911 +huggingface__huggingface_hub-3180 +huggingface__huggingface_hub-3200 +huggingface__huggingface_hub-815 +huggingface__huggingface_hub-889 +huggingface__transformers-19219 +huggingface__transformers-34197 +huggingface__transformers-36184 +huggingface__transformers-36497 +huggingface__transformers-36903 +humbug__php-scoper-1024 +humbug__php-scoper-417 +humbug__php-scoper-598 +humbug__php-scoper-882 +hummingbird-project__hummingbird-167 +hummingbird-project__hummingbird-173 +hummingbird-project__hummingbird-189 +huntabyte__shadcn-svelte-2129 +huozhi__bunchee-150 +huozhi__bunchee-159 +huozhi__bunchee-172 +huozhi__bunchee-196 +huozhi__sugar-high-107 +huozhi__sugar-high-117 +huozhi__sugar-high-77 +huozhi__sugar-high-95 +huozhi__sugar-high-99 +hustcc__jest-canvas-mock-111 +hustcc__jest-canvas-mock-116 +hustcc__jest-canvas-mock-35 +hustcc__jest-canvas-mock-49 +hustcc__jest-canvas-mock-58 +hustcc__jest-canvas-mock-7 +hwi__hwioauthbundle-1768 +hwi__hwioauthbundle-1890 +hwi__hwioauthbundle-1990 +hybridgroup__gobot-1071 +hylang__hy-2214 +hylang__hy-2389 +hynek__structlog-283 +hynek__structlog-331 +hyperbrain__serverless-aws-alias-113 +hyperbrain__serverless-aws-alias-114 +hyperbrain__serverless-aws-alias-39 +hyperbrain__serverless-aws-alias-46 +hyperbrain__serverless-aws-alias-47 +hyperbrain__serverless-aws-alias-53 +hyperbrain__serverless-aws-alias-55 +hyperbrain__serverless-aws-alias-58 +hyperbrain__serverless-aws-alias-65 +hyperbrain__serverless-aws-alias-82 +hyperbrain__serverless-aws-alias-95 +hyperbrain__serverless-aws-alias-97 +hyperium__tonic-26 +hyperjumptech__monika-1091 +hyperjumptech__monika-1105 +hyperjumptech__monika-1199 +hyperjumptech__monika-1271 +hyperjumptech__monika-1340 +hyperledger__aries-framework-go-3452 +hyperledger__aries-framework-go-3460 +hyperledger__aries-framework-go-3472 +hyperledger__aries-framework-go-3473 +hyperledger__aries-framework-go-3475 +hyperledger__aries-framework-go-3481 +hyperledger__aries-framework-go-3483 +hyperledger__aries-framework-go-3495 +hyperledger__aries-framework-go-3520 +hyperledger__aries-framework-go-3522 +hyperledger__firefly-1017 +hyperledger__firefly-1035 +hyperledger__firefly-1351 +hyperledger__firefly-928 +hyperledger__firefly-956 +hyperledger__quilt-215 +hyperledger__quilt-216 +hyperledger__quilt-372 +hyperledger__quilt-454 +hypothesisworks__hypothesis-2316 +hypothesisworks__hypothesis-2322 +hypothesisworks__hypothesis-2344 +hypothesisworks__hypothesis-2354 +hypothesisworks__hypothesis-2363 +hypothesisworks__hypothesis-2366 +hypothesisworks__hypothesis-2420 +hypothesisworks__hypothesis-2421 +hypothesisworks__hypothesis-2422 +hypothesisworks__hypothesis-2429 +hypothesisworks__hypothesis-2435 +hypothesisworks__hypothesis-2441 +hypothesisworks__hypothesis-2446 +hypothesisworks__hypothesis-2457 +hypothesisworks__hypothesis-2506 +hypothesisworks__hypothesis-2511 +hypothesisworks__hypothesis-2515 +hypothesisworks__hypothesis-2524 +hypothesisworks__hypothesis-2541 +hypothesisworks__hypothesis-2550 +hypothesisworks__hypothesis-2573 +hypothesisworks__hypothesis-2597 +hypothesisworks__hypothesis-2601 +hypothesisworks__hypothesis-2602 +hypothesisworks__hypothesis-2606 +hypothesisworks__hypothesis-2619 +hypothesisworks__hypothesis-2634 +hypothesisworks__hypothesis-2646 +hypothesisworks__hypothesis-2649 +hypothesisworks__hypothesis-2653 +hypothesisworks__hypothesis-2660 +hypothesisworks__hypothesis-2688 +hypothesisworks__hypothesis-2695 +hypothesisworks__hypothesis-2697 +hypothesisworks__hypothesis-2723 +hypothesisworks__hypothesis-2726 +hypothesisworks__hypothesis-2738 +hypothesisworks__hypothesis-2742 +hypothesisworks__hypothesis-2783 +hypothesisworks__hypothesis-2793 +hypothesisworks__hypothesis-2874 +hypothesisworks__hypothesis-2880 +hypothesisworks__hypothesis-2883 +hypothesisworks__hypothesis-2887 +hypothesisworks__hypothesis-2889 +hypothesisworks__hypothesis-2915 +hypothesisworks__hypothesis-2924 +hypothesisworks__hypothesis-2932 +hypothesisworks__hypothesis-2952 +hypothesisworks__hypothesis-2965 +hypothesisworks__hypothesis-2970 +hypothesisworks__hypothesis-2983 +hypothesisworks__hypothesis-3015 +hypothesisworks__hypothesis-3052 +hypothesisworks__hypothesis-3063 +hypothesisworks__hypothesis-3088 +hypothesisworks__hypothesis-3139 +hypothesisworks__hypothesis-3152 +hypothesisworks__hypothesis-3163 +hypothesisworks__hypothesis-3186 +hypothesisworks__hypothesis-3203 +hypothesisworks__hypothesis-3237 +hypothesisworks__hypothesis-3246 +hypothesisworks__hypothesis-3251 +hypothesisworks__hypothesis-3279 +hypothesisworks__hypothesis-3284 +hypothesisworks__hypothesis-3327 +hypothesisworks__hypothesis-3334 +hypothesisworks__hypothesis-3343 +hypothesisworks__hypothesis-3344 +hypothesisworks__hypothesis-3371 +hypothesisworks__hypothesis-3386 +hypothesisworks__hypothesis-3409 +hypothesisworks__hypothesis-3412 +hypothesisworks__hypothesis-3427 +hypothesisworks__hypothesis-3455 +hypothesisworks__hypothesis-3521 +hypothesisworks__hypothesis-3536 +hypothesisworks__hypothesis-3537 +hypothesisworks__hypothesis-3540 +hypothesisworks__hypothesis-3555 +hypothesisworks__hypothesis-3572 +hypothesisworks__hypothesis-3675 +hypothesisworks__hypothesis-3683 +hypothesisworks__hypothesis-3738 +hypothesisworks__hypothesis-3760 +hypothesisworks__hypothesis-3766 +hypothesisworks__hypothesis-3785 +hypothesisworks__hypothesis-3807 +hypothesisworks__hypothesis-3813 +hypothesisworks__hypothesis-3820 +hypothesisworks__hypothesis-3824 +hypothesisworks__hypothesis-3834 +hypothesisworks__hypothesis-3847 +hypothesisworks__hypothesis-3882 +hypothesisworks__hypothesis-3894 +hypothesisworks__hypothesis-3920 +hypothesisworks__hypothesis-3924 +hypothesisworks__hypothesis-3983 +hypothesisworks__hypothesis-4043 +hypothesisworks__hypothesis-4065 +hypothesisworks__hypothesis-4079 +hypothesisworks__hypothesis-4110 +hypothesisworks__hypothesis-4119 +hypothesisworks__hypothesis-4129 +hypothesisworks__hypothesis-4159 +hypothesisworks__hypothesis-4212 +hypothesisworks__hypothesis-4279 +hypothesisworks__hypothesis-4285 +hypothesisworks__hypothesis-4298 +hypothesisworks__hypothesis-4349 +hyrodium__basicbspline.jl-134 +hyrodium__basicbspline.jl-138 +hyrodium__basicbspline.jl-149 +hyrodium__basicbspline.jl-153 +hyrodium__basicbspline.jl-155 +hyrodium__basicbspline.jl-156 +hyrodium__basicbspline.jl-167 +hyrodium__basicbspline.jl-189 +hyrodium__basicbspline.jl-209 +hyrodium__basicbspline.jl-215 +hyrodium__basicbspline.jl-220 +hyrodium__basicbspline.jl-221 +hyrodium__basicbspline.jl-252 +hyrodium__basicbspline.jl-259 +hyrodium__basicbspline.jl-267 +hyrodium__basicbspline.jl-283 +hyrodium__basicbspline.jl-299 +hyrodium__basicbspline.jl-316 +hyrodium__basicbspline.jl-332 +hyrodium__basicbspline.jl-336 +hyrodium__basicbspline.jl-342 +hyrodium__basicbspline.jl-345 +i18next__i18next-parser-1083 +i18next__i18next-parser-217 +i18next__i18next-parser-301 +i18next__i18next-parser-637 +i18next__i18next-parser-700 +i18next__i18next-parser-871 +i18next__i18next-parser-892 +i18next__i18next-parser-909 +i18next__i18next-parser-932 +i18next__i18next-parser-957 +i18next__i18next-parser-994 +iamconsortium__pyam-202 +iamconsortium__pyam-236 +iamconsortium__pyam-261 +iamconsortium__pyam-297 +iamconsortium__pyam-305 +iamconsortium__pyam-92 +iamconsortium__pyam-93 +iamkun__dayjs-2175 +iamkun__dayjs-2231 +iamkun__dayjs-2367 +iamkun__dayjs-2377 +iamkun__dayjs-2429 +iamolegga__nestjs-pino-1663 +iamolegga__nestjs-pino-385 +iamolegga__nestjs-pino-443 +iamolegga__nestjs-pino-522 +iamolegga__nestjs-pino-523 +iamolegga__nestjs-pino-650 +iamolegga__nestjs-pino-663 +ianvs__prettier-plugin-sort-imports-184 +ianvs__prettier-plugin-sort-imports-192 +ice-lab__icestark-527 +icebob__fastest-validator-226 +icebob__fastest-validator-23 +icebob__fastest-validator-231 +icebob__fastest-validator-239 +icebob__fastest-validator-26 +icebob__fastest-validator-284 +icebob__fastest-validator-34 +icebob__fastest-validator-351 +icebob__fastest-validator-37 +icssc__antalmanac-713 +icssc__antalmanac-897 +icssc__antalmanac-912 +idaes__idaes-pse-1425 +idsia__sacred-765 +idsia__sacred-868 +iduxfe__components-121 +iduxfe__components-15 +iduxfe__components-152 +iduxfe__components-155 +iduxfe__components-162 +iduxfe__components-176 +iduxfe__components-58 +iduxfe__components-6 +iduxfe__components-66 +iduxfe__components-68 +iduxfe__components-97 +igorbenav__fastcrud-107 +igorbenav__fastcrud-190 +igorbenav__fastcrud-29 +igorbenav__fastcrud-35 +igorbenav__fastcrud-56 +igorbenav__fastcrud-69 +igorbenav__fastcrud-87 +igorkamyshev__farfetched-450 +igorkamyshev__farfetched-475 +igorkamyshev__farfetched-477 +igorkamyshev__farfetched-494 +illinois__queue-128 +illinois__queue-208 +illinois__queue-249 +illinois__queue-93 +illinois__queue-95 +illinois__queue-96 +image-rs__image-tiff-174 +image-rs__image-tiff-235 +image-rs__image-tiff-255 +image-rs__image-tiff-289 +image-rs__image-tiff-66 +imanneo__fl_chart-1864 +imanneo__fl_chart-1893 +imanneo__fl_chart-1959 +imanneo__fl_chart-1979 +imdario__mergo-177 +imdario__mergo-231 +imgix__react-imgix-151 +imgix__react-imgix-201 +imgix__react-imgix-225 +imgix__react-imgix-322 +imgix__react-imgix-404 +imgix__react-imgix-484 +imgix__react-imgix-496 +imgix__react-imgix-592 +immerjs__immer-1105 +immerjs__immer-417 +immerjs__immer-651 +immerjs__immer-664 +immerjs__immer-682 +immerjs__immer-702 +immobiliare__fastify-metrics-61 +immunant__c2rust-1265 +immutable-js__immutable-js-2004 +immutable-js__immutable-js-2065 +import-js__eslint-import-resolver-typescript-423 +import-js__eslint-plugin-import-2112 +import-js__eslint-plugin-import-2282 +import-js__eslint-plugin-import-2387 +import-js__eslint-plugin-import-2473 +import-js__eslint-plugin-import-2568 +import-js__eslint-plugin-import-2778 +import-js__eslint-plugin-import-2835 +import-js__eslint-plugin-import-3024 +import-js__eslint-plugin-import-3032 +import-js__eslint-plugin-import-3052 +import-js__eslint-plugin-import-3124 +inbucket__inbucket-398 +inbucket__inbucket-477 +inditextech__gh-sherpa-114 +inertiajs__inertia-laravel-592 +inertiajs__inertia-laravel-641 +inetaf__netaddr-3 +inetaf__netaddr-6 +infernojs__inferno-1193 +infernojs__inferno-1232 +infernojs__inferno-1615 +infinitered__solidarity-125 +infinitered__solidarity-135 +infinitered__solidarity-257 +influxdata__influxdb-client-go-134 +influxdata__influxdb-client-go-152 +influxdata__influxdb-client-go-175 +influxdata__influxdb-client-go-180 +influxdata__influxdb-client-go-187 +influxdata__influxdb-client-go-192 +influxdata__influxdb-client-go-193 +influxdata__influxdb-client-go-209 +influxdata__influxdb-client-go-229 +influxdata__influxdb-client-go-237 +influxdata__influxdb-client-go-252 +influxdata__influxdb-client-go-285 +influxdata__influxdb-client-go-287 +influxdata__influxdb-client-go-302 +influxdata__influxdb-client-go-308 +influxdata__influxdb-client-go-344 +influxdata__influxdb-client-go-350 +influxdata__influxdb-client-go-358 +influxdata__influxdb-client-go-364 +influxdata__influxdb-client-js-604 +influxdata__kapacitor-2560 +influxdata__telegraf-operator-108 +influxdata__telegraf-operator-28 +influxdata__telegraf-operator-75 +influxdata__telegraf-operator-8 +influxdata__telegraf-operator-86 +influxdata__telegraf-operator-89 +infracloudio__botkube-583 +innobi__pantab-15 +innobi__pantab-9 +inovex__scrumlr.io-1709 +inovex__scrumlr.io-1877 +inovex__scrumlr.io-1972 +inovex__scrumlr.io-2267 +inovex__scrumlr.io-2420 +inovex__scrumlr.io-2735 +inovex__scrumlr.io-3687 +inovex__scrumlr.io-3864 +inovex__scrumlr.io-3868 +inovex__scrumlr.io-3908 +input-output-hk__mithril-499 +input-output-hk__mithril-694 +instagram__libcst-162 +instrumenta__conftest-296 +intake__intake-857 +intel__intel-device-plugins-for-kubernetes-1786 +intel__intel-device-plugins-for-kubernetes-761 +intel__rohd-130 +intel__rohd-131 +intel__rohd-136 +intel__rohd-155 +intel__rohd-156 +intel__rohd-171 +intel__rohd-184 +intel__rohd-187 +intel__rohd-190 +intel__rohd-196 +intel__rohd-21 +intel__rohd-215 +intel__rohd-220 +intel__rohd-229 +intel__rohd-231 +intel__rohd-245 +intel__rohd-247 +intel__rohd-294 +intel__rohd-303 +intel__rohd-319 +intel__rohd-340 +intel__rohd-350 +intel__rohd-356 +intel__rohd-357 +intel__rohd-362 +intel__rohd-368 +intel__rohd-373 +intel__rohd-383 +intel__rohd-386 +intel__rohd-393 +intel__rohd-403 +intel__rohd-410 +intel__rohd-420 +intel__rohd-421 +intel__rohd-440 +intel__rohd-458 +intel__rohd-478 +intel__rohd-487 +intel__rohd-491 +intel__rohd-492 +intel__rohd-503 +intel__rohd-535 +intel__rohd-543 +intel__rohd-550 +intel__rohd-576 +intel__rohd-583 +intel__rohd-593 +intel__rohd-606 +intel__rohd-617 +intel__rohd-62 +intel__rohd-624 +intel__rohd-65 +intel__rohd-75 +intel__rohd-85 +intel__rohd-88 +intel__rohd-94 +interledger__web-monetization-extension-103 +interledger__web-monetization-extension-70 +interledger__web-monetization-extension-748 +interledger__web-monetization-extension-91 +interledger__web-monetization-extension-96 +interuss__dss-1052 +intlify__eslint-plugin-vue-i18n-499 +intlify__eslint-plugin-vue-i18n-616 +intlify__vue-i18n-next-1751 +intlify__vue-i18n-next-1797 +intlify__vue-i18n-next-1813 +intuit__auto-1762 +intuit__auto-1802 +intuit__auto-2115 +intuit__auto-2277 +intuit__auto-538 +intuit__auto-540 +intuit__auto-560 +intuit__auto-888 +intuit__auto-927 +invenia__nameddims.jl-101 +invenia__nameddims.jl-118 +invenia__nameddims.jl-124 +invenia__nameddims.jl-131 +invenia__nameddims.jl-132 +invenia__nameddims.jl-141 +invenia__nameddims.jl-144 +invenia__nameddims.jl-159 +invenia__nameddims.jl-165 +invenia__nameddims.jl-176 +invenia__nameddims.jl-186 +invenia__nameddims.jl-188 +invenia__nameddims.jl-194 +invenia__nameddims.jl-199 +invenia__nameddims.jl-201 +invertase__react-native-firebase-7886 +invertase__react-native-firebase-8470 +invertase__react-native-firebase-8529 +iobroker__iobroker.js-controller-2714 +ioos__compliance-checker-1147 +ioos__compliance-checker-1212 +ioos__compliance-checker-730 +ioos__compliance-checker-837 +ioos__compliance-checker-978 +iopipe__iopipe-js-core-267 +iopipe__iopipe-js-core-297 +iotaledger__iota-core-640 +iotexproject__iotex-core-3676 +iotexproject__iotex-core-3709 +iotexproject__iotex-core-3738 +iotexproject__iotex-core-4214 +iov-one__weave-1119 +iov-one__weave-1138 +iov-one__weave-1147 +ipfs__go-bitswap-494 +ipfs__ipfs-cluster-1556 +ipfs__ipfs-cluster-1637 +ipld__go-car-18 +ipni__storetheindex-1797 +ipni__storetheindex-2671 +ipython__traitlets-264 +ipython__traitlets-274 +ipython__traitlets-293 +ipython__traitlets-306 +ipython__traitlets-319 +ipython__traitlets-332 +ipython__traitlets-517 +ipython__traitlets-613 +ipython__traitlets-615 +ipython__traitlets-619 +ipython__traitlets-629 +ipython__traitlets-630 +ipython__traitlets-670 +ipython__traitlets-687 +ipython__traitlets-724 +ipython__traitlets-727 +ipython__traitlets-773 +ipython__traitlets-903 +irasoro__peri-110 +irasoro__peri-150 +irasoro__peri-183 +irasoro__peri-274 +irasoro__peri-84 +irasoro__peri-93 +irrdnet__irrd-443 +irrdnet__irrd-881 +irrdnet__irrd-894 +irrdnet__irrd-987 +ishepard__pydriller-119 +ishepard__pydriller-122 +ishepard__pydriller-173 +ishepard__pydriller-82 +ishepard__pydriller-84 +ishepard__pydriller-92 +istanbuljs__istanbuljs-706 +istanbuljs__nyc-1012 +istanbuljs__nyc-1019 +istanbuljs__nyc-1031 +istanbuljs__nyc-1068 +istio-ecosystem__authservice-256 +istio__fortio-132 +istio__fortio-136 +istio__fortio-150 +istio__fortio-153 +istio__fortio-167 +istio__fortio-173 +istio__fortio-203 +istio__fortio-206 +istio__fortio-217 +istio__fortio-218 +istio__istio-25451 +iterative__cml-1100 +iterative__cml-1263 +iterative__cml-1272 +iterative__cml-236 +iterative__cml-781 +iterative__cml-831 +iterative__cml-861 +iterative__cml-992 +iterative__dvc-10174 +iterative__dvc-10345 +iterative__dvc-10778 +iterative__dvc-9071 +iterative__dvc-9212 +iterative__dvc-9353 +iterative__dvc-9365 +iterative__dvc-9689 +iterative__dvc-9747 +iterative__dvc-9888 +iterative__shtab-182 +iterative__shtab-19 +iver56__audiomentations-394 +jaegertracing__jaeger-6608 +jaegertracing__jaeger-6699 +jaegertracing__jaeger-7132 +jaegertracing__jaeger-7245 +jamesmh__coravel-443 +jamesramsay__hercule-180 +jamesramsay__hercule-220 +janephp__janephp-639 +janephp__janephp-698 +janephp__janephp-798 +japaric__libm-79 +jaredpalmer__formik-101 +jaredpalmer__formik-103 +jaredpalmer__formik-1429 +jaredpalmer__formik-165 +jaredpalmer__formik-181 +jaredpalmer__formik-20 +jaredpalmer__formik-261 +jaredpalmer__formik-444 +jaredpalmer__formik-85 +jaredpalmer__formik-97 +jashkenas__underscore-2757 +jasonetco__todo-170 +jasonetco__todo-172 +jasonetco__todo-178 +jasonetco__todo-242 +jasonetco__todo-40 +javierbrea__eslint-plugin-boundaries-175 +javierbrea__eslint-plugin-boundaries-299 +javierbrea__eslint-plugin-boundaries-300 +javierbrea__eslint-plugin-boundaries-55 +javierbrea__eslint-plugin-boundaries-70 +jax-ml__jax-23998 +jax-ml__jax-24722 +jax-ml__jax-24823 +jax-ml__jax-25239 +jax-ml__jax-25511 +jax-ml__jax-25650 +jax-ml__jax-25787 +jax-ml__jax-25957 +jax-ml__jax-27059 +jax-ml__jax-27616 +jax-ml__jax-27803 +jax-ml__jax-27807 +jax-ml__jax-28022 +jax-ml__jax-28584 +jax-ml__jax-28612 +jaybizzle__crawler-detect-558 +jazzband__django-axes-1022 +jazzband__django-axes-1033 +jazzband__django-axes-1080 +jazzband__django-axes-1198 +jazzband__django-axes-865 +jazzband__django-axes-885 +jazzband__django-axes-911 +jazzband__django-axes-950 +jazzband__pip-tools-1547 +jazzband__pip-tools-1723 +jazzband__pip-tools-1766 +jazzband__pip-tools-1904 +jazzband__pip-tools-1919 +jazzband__pip-tools-2060 +jazzband__pip-tools-2082 +jazzband__pip-tools-706 +jazzband__pip-tools-715 +jazzband__pip-tools-720 +jazzband__pip-tools-723 +jazzband__pip-tools-737 +jazzband__pip-tools-798 +jazzband__pip-tools-800 +jazzband__pip-tools-822 +jazzband__pip-tools-837 +jazzband__pip-tools-842 +jazzband__pip-tools-864 +jazzband__pip-tools-873 +jazzband__pip-tools-879 +jazzband__pip-tools-909 +jazzband__pip-tools-964 +jazzband__pip-tools-975 +jazzband__pip-tools-999 +jazzband__tablib-454 +jazzband__tablib-456 +jazzband__tablib-470 +jazzband__tablib-490 +jazzband__tablib-497 +jazzband__tablib-510 +jazzband__tablib-547 +jazzband__tablib-555 +jazzband__tablib-563 +jazzband__tablib-573 +jazzband__tablib-579 +jazzband__tablib-584 +jazzband__tablib-596 +jazzband__tablib-613 +jbetancur__react-data-table-component-1127 +jbetancur__react-data-table-component-778 +jbetancur__react-data-table-component-797 +jbetancur__react-data-table-component-821 +jbetancur__react-data-table-component-822 +jbetancur__react-data-table-component-924 +jcmturner__gokrb5-239 +jcrist__msgspec-181 +jcrist__msgspec-225 +jcrist__msgspec-410 +jcrist__msgspec-538 +jcrist__msgspec-566 +jcrist__msgspec-571 +jcrist__msgspec-626 +jcrist__msgspec-772 +jcrist__skein-114 +jcrist__skein-141 +jcrist__skein-146 +jcrist__skein-147 +jcrist__skein-148 +jcrist__skein-162 +jcrist__skein-87 +jedib0t__go-pretty-253 +jedib0t__go-pretty-259 +jedib0t__go-pretty-277 +jedib0t__go-pretty-306 +jedib0t__go-pretty-335 +jedib0t__go-pretty-341 +jedib0t__go-pretty-361 +jedwatson__react-select-4634 +jeffail__benthos-1113 +jeffail__benthos-253 +jelmer__dulwich-1020 +jelmer__dulwich-1057 +jelmer__dulwich-1069 +jelmer__dulwich-1073 +jelmer__dulwich-1108 +jelmer__dulwich-1160 +jelmer__dulwich-1167 +jelmer__dulwich-1171 +jelmer__dulwich-1392 +jelmer__dulwich-1441 +jelmer__dulwich-1482 +jelmer__dulwich-1500 +jelmer__dulwich-1515 +jelmer__dulwich-1555 +jelmer__dulwich-1558 +jelmer__dulwich-1568 +jelmer__dulwich-1578 +jelmer__dulwich-1586 +jelmer__dulwich-1619 +jelmer__dulwich-1699 +jelmer__dulwich-982 +jeltef__derive_more-252 +jeltef__derive_more-371 +jeltef__derive_more-387 +jeltef__derive_more-459 +jeltef__derive_more-465 +jeltef__derive_more-467 +jeltef__derive_more-489 +jenkins-x__lighthouse-1015 +jenkins-x__lighthouse-1028 +jenkins-x__lighthouse-1144 +jenkins-x__lighthouse-1266 +jenkins-x__lighthouse-1395 +jenkins-x__lighthouse-1407 +jenkins-x__lighthouse-777 +jenkins-x__lighthouse-883 +jenkins-x__lighthouse-890 +jenkins-x__lighthouse-935 +jensneuse__graphql-go-tools-101 +jensneuse__graphql-go-tools-119 +jensneuse__graphql-go-tools-145 +jensneuse__graphql-go-tools-155 +jensneuse__graphql-go-tools-161 +jensneuse__graphql-go-tools-174 +jensneuse__graphql-go-tools-295 +jensneuse__graphql-go-tools-315 +jensneuse__graphql-go-tools-319 +jensneuse__graphql-go-tools-84 +jeregrine__jsonapi-113 +jeregrine__jsonapi-149 +jeregrine__jsonapi-164 +jeregrine__jsonapi-166 +jeregrine__jsonapi-208 +jeregrine__jsonapi-63 +jeregrine__jsonapi-70 +jeregrine__jsonapi-91 +jeremydaly__dynamodb-toolbox-229 +jeremydaly__dynamodb-toolbox-256 +jeremydaly__dynamodb-toolbox-278 +jeremydaly__dynamodb-toolbox-281 +jeremydaly__dynamodb-toolbox-283 +jeremydaly__dynamodb-toolbox-288 +jeremydaly__dynamodb-toolbox-307 +jeremydaly__dynamodb-toolbox-329 +jeremydaly__dynamodb-toolbox-352 +jeremydaly__dynamodb-toolbox-499 +jeremydaly__dynamodb-toolbox-503 +jeremydaly__dynamodb-toolbox-521 +jeremydaly__dynamodb-toolbox-53 +jeremydaly__dynamodb-toolbox-590 +jeremydaly__dynamodb-toolbox-593 +jeremydaly__dynamodb-toolbox-737 +jeremydaly__dynamodb-toolbox-89 +jeremyjh__dialyxir-272 +jeremyjh__dialyxir-538 +jest-community__eslint-plugin-jest-822 +jest-community__eslint-plugin-jest-922 +jest-community__eslint-plugin-jest-923 +jetpack-io__devbox-1743 +jetpack-io__devbox-1941 +jetstack__cert-manager-4640 +jhillyerd__enmime-114 +jhillyerd__enmime-116 +jhillyerd__enmime-178 +jhillyerd__enmime-203 +jhillyerd__enmime-208 +jhillyerd__enmime-209 +jhillyerd__enmime-234 +jhillyerd__enmime-245 +jhillyerd__enmime-270 +jhillyerd__enmime-360 +jhipster__generator-jhipster-10015 +jhipster__generator-jhipster-10085 +jhipster__generator-jhipster-10163 +jhipster__generator-jhipster-10307 +jhipster__generator-jhipster-10319 +jhipster__generator-jhipster-10549 +jhipster__generator-jhipster-10807 +jhipster__generator-jhipster-11584 +jhipster__generator-jhipster-11588 +jhipster__generator-jhipster-11631 +jhipster__generator-jhipster-11729 +jhipster__generator-jhipster-11765 +jhipster__generator-jhipster-11825 +jhipster__generator-jhipster-6964 +jhipster__generator-jhipster-7254 +jhipster__generator-jhipster-7311 +jhipster__generator-jhipster-7424 +jhipster__generator-jhipster-7498 +jhipster__generator-jhipster-7929 +jhipster__generator-jhipster-8016 +jhipster__generator-jhipster-8834 +jhipster__generator-jhipster-8993 +jhipster__generator-jhipster-9044 +jhipster__generator-jhipster-9154 +jhipster__generator-jhipster-9405 +jhipster__generator-jhipster-9485 +jhipster__generator-jhipster-9710 +jhipster__jhipster-control-center-24 +jhipster__jhipster-control-center-25 +jhipster__jhipster-vuejs-496 +jhlywa__chess.js-546 +jhugman__uniffi-bindgen-react-native-123 +jhugman__uniffi-bindgen-react-native-84 +jhump__protoreflect-272 +jhump__protoreflect-294 +jhump__protoreflect-337 +jhump__protoreflect-343 +jhump__protoreflect-373 +jhump__protoreflect-384 +jhump__protoreflect-385 +jhump__protoreflect-401 +jhump__protoreflect-408 +jhump__protoreflect-446 +jhump__protoreflect-449 +jhump__protoreflect-455 +jhump__protoreflect-457 +jhump__protoreflect-459 +jhump__protoreflect-512 +jhump__protoreflect-523 +jhump__protoreflect-592 +jhump__protoreflect-594 +jhump__protoreflect-621 +jiangzhe__xngin-20 +jiangzhe__xngin-80 +jimhester__lintr-1116 +jimhester__lintr-1119 +jimhester__lintr-1130 +jimhester__lintr-503 +jimhester__lintr-533 +jimhester__lintr-535 +jimhester__lintr-551 +jimhester__lintr-562 +jimhester__lintr-575 +jimhester__lintr-578 +jimhester__lintr-620 +jimhester__lintr-622 +jimhester__lintr-674 +jimhester__lintr-732 +jimhester__lintr-751 +jimhester__lintr-759 +jimhester__lintr-765 +jimhester__lintr-775 +jimhester__lintr-830 +jimhester__lintr-865 +jimhester__lintr-883 +jimhester__lintr-905 +jimhester__lintr-928 +jimhester__lintr-937 +jimhester__lintr-977 +jira-node__node-jira-client-160 +jira-node__node-jira-client-175 +jira-node__node-jira-client-176 +jira-node__node-jira-client-177 +jira-node__node-jira-client-202 +jira-node__node-jira-client-215 +jira-node__node-jira-client-266 +jira-node__node-jira-client-278 +jira-node__node-jira-client-28 +jira-node__node-jira-client-280 +jira-node__node-jira-client-282 +jira-node__node-jira-client-286 +jira-node__node-jira-client-55 +jkk__honeysql-237 +jkroepke__openvpn-auth-oauth2-223 +jkroepke__openvpn-auth-oauth2-272 +jkroepke__openvpn-auth-oauth2-458 +jkroepke__openvpn-auth-oauth2-519 +jlfwong__speedscope-282 +jlfwong__speedscope-322 +jlfwong__speedscope-331 +jlfwong__speedscope-407 +jlfwong__speedscope-423 +jlfwong__speedscope-449 +jlowin__fastmcp-1214 +jlowin__fastmcp-1222 +jlowin__fastmcp-128 +jlowin__fastmcp-129 +jlowin__fastmcp-161 +jlowin__fastmcp-164 +jlowin__fastmcp-246 +jlowin__fastmcp-279 +jlowin__fastmcp-283 +jlowin__fastmcp-284 +jlowin__fastmcp-287 +jlowin__fastmcp-299 +jlowin__fastmcp-301 +jlowin__fastmcp-309 +jlowin__fastmcp-317 +jlowin__fastmcp-434 +jlowin__fastmcp-448 +jlowin__fastmcp-449 +jlowin__fastmcp-63 +jmcgeheeiv__pyfakefs-597 +jmcgeheeiv__pyfakefs-633 +jmcgeheeiv__pyfakefs-724 +jmcgeheeiv__pyfakefs-725 +jmorganca__ollama-1393 +jmorganca__ollama-1420 +jmorganca__ollama-1828 +jmorganca__ollama-897 +jneen__parsimmon-250 +jnothman__upsetplot-253 +jnothman__upsetplot-261 +jnothman__upsetplot-264 +jnothman__upsetplot-30 +jnothman__upsetplot-50 +jnothman__upsetplot-55 +jnothman__upsetplot-61 +jnothman__upsetplot-69 +jnothman__upsetplot-76 +joblib__joblib-1136 +joelittlejohn__jsonschema2pojo-1457 +joelittlejohn__jsonschema2pojo-1458 +joelittlejohn__jsonschema2pojo-1465 +joelittlejohn__jsonschema2pojo-1522 +joelittlejohn__jsonschema2pojo-501 +joelittlejohn__jsonschema2pojo-529 +joerick__cibuildwheel-295 +joerick__cibuildwheel-408 +joerick__cibuildwheel-553 +joerick__cibuildwheel-570 +johnkerl__miller-1840 +joinmarket-webui__jam-450 +joinmarket-webui__jam-485 +joinmarket-webui__jam-684 +joinmarket-webui__jam-693 +joinmarket-webui__jam-697 +joinmarket-webui__jam-738 +joinmarket-webui__jam-739 +joinmarket-webui__jam-862 +joinmarket-webui__joinmarket-webui-158 +joinmarket-webui__joinmarket-webui-165 +joinmarket-webui__joinmarket-webui-198 +joinmarket-webui__joinmarket-webui-263 +joinmarket-webui__joinmarket-webui-284 +joinmarket-webui__joinmarket-webui-349 +joinmarket-webui__joinmarket-webui-378 +joinmarket-webui__joinmarket-webui-379 +joke2k__django-environ-514 +joke2k__faker-1122 +joke2k__faker-1124 +joke2k__faker-1580 +joke2k__faker-1758 +joke2k__faker-1802 +joke2k__faker-1806 +joke2k__faker-1887 +joke2k__faker-1946 +joke2k__faker-2091 +joke2k__faker-2099 +joke2k__faker-2104 +joke2k__faker-2111 +joke2k__faker-2123 +joke2k__faker-2186 +joke2k__faker-2203 +jolocom__smartwallet-app-1308 +jolocom__smartwallet-app-1409 +jolocom__smartwallet-app-1414 +jolocom__smartwallet-app-1449 +jolocom__smartwallet-app-1487 +jolocom__smartwallet-app-1523 +jomei__notionapi-184 +jonasbb__serde_with-566 +jonasbb__serde_with-627 +jonathanj__eliottree-61 +jonathonreinhart__scuba-105 +jonathonreinhart__scuba-107 +jonathonreinhart__scuba-111 +jonathonreinhart__scuba-42 +jonathonreinhart__scuba-67 +jonathonreinhart__scuba-68 +jorgecarleitao__arrow2-1278 +jorgecarleitao__arrow2-593 +josdejong__mathjs-1003 +josdejong__mathjs-1032 +josdejong__mathjs-541 +josdejong__mathjs-726 +josdejong__mathjs-800 +josdejong__mathjs-840 +joshuadavidthomas__django-bird-165 +joshuadavidthomas__django-bird-183 +joshuadavidthomas__django-bird-212 +joshuadavidthomas__django-bird-219 +joshuakgoldberg__bingo-208 +joshuakgoldberg__bingo-225 +joshuakgoldberg__bingo-227 +joshuakgoldberg__bingo-229 +joshuakgoldberg__bingo-241 +joshuakgoldberg__bingo-245 +joshuakgoldberg__bingo-252 +joshuakgoldberg__bingo-263 +joshuakgoldberg__bingo-270 +joshuakgoldberg__bingo-271 +joshuakgoldberg__bingo-274 +joshuakgoldberg__bingo-276 +joshuakgoldberg__bingo-278 +joshuakgoldberg__bingo-280 +joshuakgoldberg__bingo-316 +joshuakgoldberg__bingo-328 +joshuakgoldberg__bingo-341 +joshuakgoldberg__bingo-358 +joshuakgoldberg__create-typescript-app-1000 +joshuakgoldberg__create-typescript-app-1529 +joshuakgoldberg__create-typescript-app-1533 +joshuakgoldberg__create-typescript-app-1595 +joshuakgoldberg__create-typescript-app-1596 +joshuakgoldberg__create-typescript-app-1599 +joshuakgoldberg__create-typescript-app-1604 +joshuakgoldberg__create-typescript-app-1609 +joshuakgoldberg__create-typescript-app-1611 +joshuakgoldberg__create-typescript-app-1612 +joshuakgoldberg__create-typescript-app-1614 +joshuakgoldberg__create-typescript-app-1615 +joshuakgoldberg__create-typescript-app-1620 +joshuakgoldberg__create-typescript-app-1625 +joshuakgoldberg__create-typescript-app-1627 +joshuakgoldberg__create-typescript-app-1630 +joshuakgoldberg__create-typescript-app-1636 +joshuakgoldberg__create-typescript-app-1663 +joshuakgoldberg__create-typescript-app-1665 +joshuakgoldberg__create-typescript-app-1695 +joshuakgoldberg__create-typescript-app-1696 +joshuakgoldberg__create-typescript-app-1697 +joshuakgoldberg__create-typescript-app-1724 +joshuakgoldberg__create-typescript-app-1727 +joshuakgoldberg__create-typescript-app-1733 +joshuakgoldberg__create-typescript-app-1734 +joshuakgoldberg__create-typescript-app-1735 +joshuakgoldberg__create-typescript-app-1798 +joshuakgoldberg__create-typescript-app-1800 +joshuakgoldberg__create-typescript-app-1806 +joshuakgoldberg__create-typescript-app-1879 +joshuakgoldberg__create-typescript-app-1958 +joshuakgoldberg__create-typescript-app-1961 +joshuakgoldberg__create-typescript-app-1963 +joshuakgoldberg__create-typescript-app-1972 +joshuakgoldberg__create-typescript-app-1986 +joshuakgoldberg__create-typescript-app-1989 +joshuakgoldberg__create-typescript-app-2004 +joshuakgoldberg__create-typescript-app-2006 +joshuakgoldberg__create-typescript-app-2007 +joshuakgoldberg__create-typescript-app-2011 +joshuakgoldberg__create-typescript-app-2012 +joshuakgoldberg__create-typescript-app-2015 +joshuakgoldberg__create-typescript-app-2019 +joshuakgoldberg__create-typescript-app-2021 +joshuakgoldberg__create-typescript-app-2026 +joshuakgoldberg__create-typescript-app-2027 +joshuakgoldberg__create-typescript-app-2028 +joshuakgoldberg__create-typescript-app-2033 +joshuakgoldberg__create-typescript-app-2037 +joshuakgoldberg__create-typescript-app-2040 +joshuakgoldberg__create-typescript-app-2045 +joshuakgoldberg__create-typescript-app-2047 +joshuakgoldberg__create-typescript-app-2050 +joshuakgoldberg__create-typescript-app-2051 +joshuakgoldberg__create-typescript-app-2053 +joshuakgoldberg__create-typescript-app-2060 +joshuakgoldberg__create-typescript-app-2061 +joshuakgoldberg__create-typescript-app-2065 +joshuakgoldberg__create-typescript-app-2066 +joshuakgoldberg__create-typescript-app-2067 +joshuakgoldberg__create-typescript-app-2078 +joshuakgoldberg__create-typescript-app-2084 +joshuakgoldberg__create-typescript-app-2090 +joshuakgoldberg__create-typescript-app-2098 +joshuakgoldberg__create-typescript-app-2100 +joshuakgoldberg__create-typescript-app-2103 +joshuakgoldberg__create-typescript-app-2104 +joshuakgoldberg__create-typescript-app-2105 +joshuakgoldberg__create-typescript-app-2107 +joshuakgoldberg__create-typescript-app-2110 +joshuakgoldberg__create-typescript-app-2112 +joshuakgoldberg__create-typescript-app-2117 +joshuakgoldberg__create-typescript-app-2123 +joshuakgoldberg__create-typescript-app-2125 +joshuakgoldberg__create-typescript-app-2128 +joshuakgoldberg__create-typescript-app-2130 +joshuakgoldberg__create-typescript-app-2131 +joshuakgoldberg__create-typescript-app-2136 +joshuakgoldberg__create-typescript-app-2138 +joshuakgoldberg__create-typescript-app-2139 +joshuakgoldberg__create-typescript-app-2143 +joshuakgoldberg__create-typescript-app-2148 +joshuakgoldberg__create-typescript-app-2150 +joshuakgoldberg__create-typescript-app-2155 +joshuakgoldberg__create-typescript-app-2164 +joshuakgoldberg__create-typescript-app-2165 +joshuakgoldberg__create-typescript-app-2170 +joshuakgoldberg__create-typescript-app-2172 +joshuakgoldberg__create-typescript-app-2178 +joshuakgoldberg__create-typescript-app-2180 +joshuakgoldberg__create-typescript-app-2186 +joshuakgoldberg__create-typescript-app-2189 +joshuakgoldberg__create-typescript-app-2193 +joshuakgoldberg__create-typescript-app-2196 +joshuakgoldberg__create-typescript-app-2200 +joshuakgoldberg__create-typescript-app-2204 +joshuakgoldberg__create-typescript-app-2210 +joshuakgoldberg__create-typescript-app-2215 +joshuakgoldberg__create-typescript-app-2245 +joshuakgoldberg__eslint-plugin-package-json-1048 +joshuakgoldberg__eslint-plugin-package-json-1148 +joshuakgoldberg__eslint-plugin-package-json-1174 +joshuakgoldberg__template-typescript-node-package-473 +joshuakgoldberg__template-typescript-node-package-497 +joshuakgoldberg__template-typescript-node-package-505 +joshuakgoldberg__template-typescript-node-package-509 +joshuakgoldberg__template-typescript-node-package-513 +joshuakgoldberg__template-typescript-node-package-514 +joshuakgoldberg__template-typescript-node-package-520 +joshuakgoldberg__template-typescript-node-package-527 +joshuakgoldberg__template-typescript-node-package-530 +joshuakgoldberg__template-typescript-node-package-548 +joshuakgoldberg__template-typescript-node-package-560 +joshuakgoldberg__template-typescript-node-package-677 +joshuakgoldberg__template-typescript-node-package-679 +joshuakgoldberg__template-typescript-node-package-686 +joshuakgoldberg__template-typescript-node-package-693 +joshuakgoldberg__template-typescript-node-package-725 +joshuakgoldberg__template-typescript-node-package-727 +joshuakgoldberg__ts-api-utils-545 +joshuakgoldberg__tslint-to-eslint-config-121 +joshuakgoldberg__tslint-to-eslint-config-24 +joshuakgoldberg__tslint-to-eslint-config-25 +joshuakgoldberg__tslint-to-eslint-config-26 +joshuakgoldberg__tslint-to-eslint-config-30 +joshuakgoldberg__tslint-to-eslint-config-43 +joshuakgoldberg__tslint-to-eslint-config-48 +joshuakgoldberg__tslint-to-eslint-config-49 +joshuakgoldberg__tslint-to-eslint-config-56 +joshuakgoldberg__tslint-to-eslint-config-70 +joshuakgoldberg__tslint-to-eslint-config-75 +joshuakgoldberg__tslint-to-eslint-config-78 +joshuakgoldberg__tslint-to-eslint-config-82 +joshuakgoldberg__tslint-to-eslint-config-84 +joshuakgoldberg__tslint-to-eslint-config-87 +joshuakgoldberg__tslint-to-eslint-config-90 +joshuakgoldberg__typestat-2176 +joshuakgoldberg__typestat-2181 +joshuakgoldberg__typestat-2184 +jpadilla__pyjwt-316 +jprichardson__node-fs-extra-330 +jprichardson__node-fs-extra-333 +jprichardson__node-fs-extra-366 +jprichardson__node-fs-extra-415 +jprichardson__node-fs-extra-466 +jprichardson__node-fs-extra-502 +jprichardson__node-fs-extra-578 +jprichardson__node-fs-extra-679 +jprichardson__node-fs-extra-883 +jprichardson__node-fs-extra-888 +jprichardson__node-fs-extra-955 +jpsim__yams-198 +jpsim__yams-248 +jpsim__yams-394 +js-data__js-data-473 +js-data__js-data-499 +js-data__js-data-502 +jsdelivr__globalping-probe-245 +jsdelivr__globalping-probe-246 +jsdom__cssstyle-115 +jsdom__cssstyle-179 +jsdom__cssstyle-186 +jsdom__cssstyle-194 +jsdom__cssstyle-215 +jsdom__cssstyle-223 +jsdom__cssstyle-231 +jshint__jshint-2068 +jshint__jshint-2196 +jshint__jshint-2221 +jshint__jshint-2234 +jshint__jshint-2382 +jshint__jshint-3115 +jshint__jshint-3189 +jshint__jshint-3562 +jshint__jshint-3566 +json-schema-faker__json-schema-faker-744 +jsonata-js__jsonata-124 +jsonata-js__jsonata-141 +jsonata-js__jsonata-150 +jsonata-js__jsonata-151 +jsonata-js__jsonata-172 +jsonata-js__jsonata-173 +jsonata-js__jsonata-174 +jsonata-js__jsonata-175 +jsonata-js__jsonata-221 +jsonata-js__jsonata-224 +jsonata-js__jsonata-225 +jsonata-js__jsonata-263 +jsonata-js__jsonata-265 +jsonata-js__jsonata-267 +jsonata-js__jsonata-268 +jsonata-js__jsonata-269 +jsonata-js__jsonata-271 +jsonata-js__jsonata-280 +jsonata-js__jsonata-340 +jsonata-js__jsonata-342 +jsonata-js__jsonata-362 +jsonata-js__jsonata-372 +jsonata-js__jsonata-373 +jsonata-js__jsonata-383 +jsonata-js__jsonata-388 +jsonata-js__jsonata-407 +jsonata-js__jsonata-428 +jsonata-js__jsonata-435 +jsonata-js__jsonata-437 +jsonata-js__jsonata-482 +jsonata-js__jsonata-483 +jsonata-js__jsonata-506 +jsonata-js__jsonata-531 +jsonata-js__jsonata-534 +jsonata-js__jsonata-644 +jsonata-js__jsonata-692 +jsonata-js__jsonata-728 +jsonmapper__jsonmapper-11 +jsonmapper__jsonmapper-118 +jsonmapper__jsonmapper-122 +jsonmapper__jsonmapper-126 +jsonmapper__jsonmapper-135 +jsonmapper__jsonmapper-161 +jsonmapper__jsonmapper-164 +jsonmapper__jsonmapper-193 +jsonmapper__jsonmapper-46 +jsonmapper__jsonmapper-75 +jsonmapper__jsonmapper-82 +jsonmapper__jsonmapper-84 +jsonmapper__jsonmapper-95 +jsonmapper__jsonmapper-97 +jsonpickle__jsonpickle-338 +jsonpickle__jsonpickle-342 +jsonpickle__jsonpickle-344 +jsonpickle__jsonpickle-385 +jsonpickle__jsonpickle-387 +jsonpickle__jsonpickle-393 +jsonpickle__jsonpickle-434 +jsonpickle__jsonpickle-455 +jsonpickle__jsonpickle-469 +jsonpickle__jsonpickle-501 +jsonpickle__jsonpickle-534 +jsonpickle__jsonpickle-535 +jsonpickle__jsonpickle-565 +jsperf__jsperf.com-296 +jsperf__jsperf.com-308 +jsx-eslint__eslint-plugin-react-1591 +jsx-eslint__eslint-plugin-react-3249 +jsx-eslint__eslint-plugin-react-3317 +jsx-eslint__eslint-plugin-react-3335 +jsx-eslint__eslint-plugin-react-3369 +jsx-eslint__eslint-plugin-react-3377 +jsx-eslint__eslint-plugin-react-3385 +jsx-eslint__eslint-plugin-react-3402 +jsx-eslint__eslint-plugin-react-3419 +jsx-eslint__eslint-plugin-react-3673 +jsx-eslint__eslint-plugin-react-3677 +jsx-eslint__eslint-plugin-react-3694 +jsx-eslint__eslint-plugin-react-3748 +jsx-eslint__eslint-plugin-react-3772 +jsx-eslint__eslint-plugin-react-3798 +jsx-eslint__eslint-plugin-react-3829 +jugglerchris__rust-html2text-156 +jugglerchris__rust-html2text-165 +jugglerchris__rust-html2text-167 +jugglerchris__rust-html2text-172 +jugglerchris__rust-html2text-175 +jugglerchris__rust-html2text-197 +juicedata__juicefs-958 +juju__python-libjuju-555 +julia-vscode__cstparser.jl-212 +julia-vscode__cstparser.jl-237 +julia-vscode__cstparser.jl-249 +julia-vscode__cstparser.jl-258 +julia-vscode__cstparser.jl-279 +julia-vscode__cstparser.jl-294 +julia-vscode__cstparser.jl-312 +julia-vscode__cstparser.jl-329 +julia-vscode__cstparser.jl-330 +julia-vscode__cstparser.jl-344 +julia-vscode__cstparser.jl-347 +julia-vscode__cstparser.jl-351 +julia-vscode__cstparser.jl-369 +juliacollections__datastructures.jl-581 +juliacollections__datastructures.jl-612 +juliacollections__datastructures.jl-622 +juliacollections__datastructures.jl-627 +juliacollections__datastructures.jl-629 +juliacollections__datastructures.jl-644 +juliacollections__datastructures.jl-727 +juliacollections__datastructures.jl-771 +juliacollections__datastructures.jl-780 +juliacollections__datastructures.jl-858 +juliacollections__datastructures.jl-932 +juliadata__tables.jl-183 +juliadata__tables.jl-200 +juliadata__tables.jl-206 +juliadata__tables.jl-223 +juliadata__tables.jl-229 +juliadata__tables.jl-244 +juliadata__tables.jl-304 +juliadata__tables.jl-313 +juliadata__tables.jl-340 +juliadebug__cthulhu.jl-547 +juliadebug__cthulhu.jl-602 +juliadiff__finitedifferences.jl-197 +juliadiff__finitedifferences.jl-223 +juliadiff__finitedifferences.jl-228 +juliadiff__finitedifferences.jl-94 +juliadiff__finitedifferences.jl-95 +juliadiff__forwarddiff.jl-481 +juliadiff__forwarddiff.jl-739 +juliadiff__forwarddiff.jl-779 +juliadiff__reversediff.jl-166 +juliadiff__reversediff.jl-170 +juliadiff__reversediff.jl-202 +juliadiff__reversediff.jl-207 +juliadiff__taylorseries.jl-262 +juliadiff__taylorseries.jl-274 +juliadiff__taylorseries.jl-292 +juliadiff__taylorseries.jl-297 +juliadiff__taylorseries.jl-304 +juliadiff__taylorseries.jl-314 +juliadiff__taylorseries.jl-316 +juliadiff__taylorseries.jl-317 +juliadiff__taylorseries.jl-329 +juliadiff__taylorseries.jl-343 +juliadiff__taylorseries.jl-374 +juliadocs__docstringextensions.jl-131 +juliadocs__docstringextensions.jl-141 +juliadynamics__complexitymeasures.jl-210 +juliadynamics__complexitymeasures.jl-243 +juliadynamics__complexitymeasures.jl-272 +juliadynamics__complexitymeasures.jl-274 +juliadynamics__complexitymeasures.jl-293 +juliadynamics__complexitymeasures.jl-333 +juliadynamics__complexitymeasures.jl-351 +juliadynamics__complexitymeasures.jl-371 +juliadynamics__complexitymeasures.jl-373 +juliadynamics__complexitymeasures.jl-375 +juliadynamics__drwatson.jl-282 +juliadynamics__drwatson.jl-285 +juliadynamics__drwatson.jl-383 +juliaearth__coordrefsystems.jl-101 +juliaearth__coordrefsystems.jl-56 +juliaearth__coordrefsystems.jl-77 +juliaearth__coordrefsystems.jl-99 +juliafolds2__ohmythreads.jl-101 +juliafolds2__ohmythreads.jl-104 +juliafolds2__ohmythreads.jl-48 +juliafolds2__ohmythreads.jl-67 +juliafolds2__ohmythreads.jl-68 +juliafolds2__ohmythreads.jl-88 +juliageo__libgeos.jl-136 +juliagpu__kernelabstractions.jl-490 +juliagpu__kernelabstractions.jl-500 +juliagpu__kernelabstractions.jl-515 +juliagpu__kernelabstractions.jl-554 +juliagpu__kernelabstractions.jl-602 +juliainterop__rcall.jl-532 +juliainterop__rcall.jl-533 +juliainterop__rcall.jl-537 +juliaintervals__intervalarithmetic.jl-391 +juliaintervals__intervalarithmetic.jl-427 +juliaintervals__intervalarithmetic.jl-429 +juliaintervals__intervalarithmetic.jl-451 +juliaintervals__intervalarithmetic.jl-461 +juliaintervals__intervalarithmetic.jl-467 +juliaintervals__intervalarithmetic.jl-496 +juliaintervals__intervalarithmetic.jl-509 +juliaintervals__intervalarithmetic.jl-511 +juliaintervals__intervalarithmetic.jl-520 +juliaintervals__intervalarithmetic.jl-577 +juliaintervals__intervalarithmetic.jl-602 +juliaintervals__intervalarithmetic.jl-603 +juliaintervals__intervalarithmetic.jl-619 +juliaintervals__intervalarithmetic.jl-631 +juliaintervals__intervalarithmetic.jl-632 +juliaintervals__intervalarithmetic.jl-648 +juliaintervals__intervalarithmetic.jl-666 +juliaintervals__intervalarithmetic.jl-684 +juliaintervals__intervalarithmetic.jl-686 +juliaintervals__intervalarithmetic.jl-689 +juliaintervals__intervalarithmetic.jl-696 +juliaintervals__intervalarithmetic.jl-711 +juliaintervals__taylormodels.jl-74 +juliaintervals__taylormodels.jl-76 +julialang__juliasyntax.jl-102 +julialang__juliasyntax.jl-106 +julialang__juliasyntax.jl-12 +julialang__juliasyntax.jl-124 +julialang__juliasyntax.jl-130 +julialang__juliasyntax.jl-131 +julialang__juliasyntax.jl-155 +julialang__juliasyntax.jl-156 +julialang__juliasyntax.jl-171 +julialang__juliasyntax.jl-176 +julialang__juliasyntax.jl-196 +julialang__juliasyntax.jl-233 +julialang__juliasyntax.jl-251 +julialang__juliasyntax.jl-259 +julialang__juliasyntax.jl-260 +julialang__juliasyntax.jl-261 +julialang__juliasyntax.jl-269 +julialang__juliasyntax.jl-288 +julialang__juliasyntax.jl-306 +julialang__juliasyntax.jl-317 +julialang__juliasyntax.jl-32 +julialang__juliasyntax.jl-323 +julialang__juliasyntax.jl-325 +julialang__juliasyntax.jl-344 +julialang__juliasyntax.jl-367 +julialang__juliasyntax.jl-371 +julialang__juliasyntax.jl-373 +julialang__juliasyntax.jl-374 +julialang__juliasyntax.jl-393 +julialang__juliasyntax.jl-397 +julialang__juliasyntax.jl-452 +julialang__juliasyntax.jl-466 +julialang__juliasyntax.jl-47 +julialang__juliasyntax.jl-477 +julialang__juliasyntax.jl-478 +julialang__juliasyntax.jl-480 +julialang__juliasyntax.jl-486 +julialang__juliasyntax.jl-495 +julialang__juliasyntax.jl-497 +julialang__juliasyntax.jl-506 +julialang__juliasyntax.jl-518 +julialang__juliasyntax.jl-52 +julialang__juliasyntax.jl-523 +julialang__juliasyntax.jl-538 +julialang__juliasyntax.jl-566 +julialang__juliasyntax.jl-583 +julialang__juliasyntax.jl-60 +julialang__juliasyntax.jl-72 +julialang__juliasyntax.jl-75 +julialang__juliasyntax.jl-76 +julialinearalgebra__genericlinearalgebra.jl-101 +julialinearalgebra__genericlinearalgebra.jl-120 +julialinearalgebra__genericlinearalgebra.jl-122 +julialinearalgebra__genericlinearalgebra.jl-124 +julialinearalgebra__genericlinearalgebra.jl-125 +julialinearalgebra__genericlinearalgebra.jl-140 +julialinearalgebra__genericlinearalgebra.jl-145 +julialinearalgebra__genericlinearalgebra.jl-158 +julialinearalgebra__genericlinearalgebra.jl-69 +julialinearalgebra__genericlinearalgebra.jl-88 +juliamanifolds__manifoldsbase.jl-104 +juliamanifolds__manifoldsbase.jl-43 +juliamath__decfp.jl-151 +juliamath__decfp.jl-158 +juliamath__decfp.jl-187 +juliamath__polynomials.jl-405 +juliamath__polynomials.jl-411 +juliamath__polynomials.jl-453 +juliamath__polynomials.jl-470 +juliamath__polynomials.jl-472 +juliamath__polynomials.jl-617 +juliamath__roots.jl-210 +juliamath__roots.jl-280 +juliamath__roots.jl-422 +juliamath__roots.jl-459 +juliamath__specialfunctions.jl-210 +juliamath__specialfunctions.jl-223 +juliamath__specialfunctions.jl-258 +juliamath__specialfunctions.jl-260 +juliamath__specialfunctions.jl-273 +juliamath__specialfunctions.jl-275 +juliamath__specialfunctions.jl-278 +juliamath__specialfunctions.jl-347 +juliamath__specialfunctions.jl-353 +juliamath__specialfunctions.jl-376 +juliamath__specialfunctions.jl-386 +juliamath__specialfunctions.jl-388 +juliamath__specialfunctions.jl-392 +juliamath__specialfunctions.jl-401 +juliamath__specialfunctions.jl-404 +juliaml__mlutils.jl-27 +juliaml__mlutils.jl-28 +juliaml__tabletransforms.jl-102 +juliaml__tabletransforms.jl-110 +juliaml__tabletransforms.jl-161 +juliaml__tabletransforms.jl-179 +juliaml__tabletransforms.jl-236 +juliaml__tabletransforms.jl-237 +juliaml__tabletransforms.jl-24 +juliaml__tabletransforms.jl-252 +juliaml__tabletransforms.jl-254 +juliaml__tabletransforms.jl-256 +juliaml__tabletransforms.jl-267 +juliaml__tabletransforms.jl-271 +juliaml__tabletransforms.jl-60 +juliaml__tabletransforms.jl-63 +juliaml__tabletransforms.jl-97 +juliaplots__makie.jl-1159 +juliaplots__makie.jl-1739 +juliaplots__makie.jl-2108 +juliaplots__makie.jl-2110 +juliaplots__makie.jl-2113 +juliaplots__makie.jl-2116 +juliaplots__makie.jl-2124 +juliaplots__makie.jl-2184 +juliaplots__makie.jl-2285 +juliaplots__makie.jl-3058 +juliaplots__makie.jl-3253 +juliaplots__makie.jl-3275 +juliaplots__makie.jl-3312 +juliaplots__makie.jl-3401 +juliaplots__makie.jl-3586 +juliaplots__makie.jl-3596 +juliaplots__makie.jl-4871 +juliaplots__makie.jl-4884 +juliapy__pycall.jl-817 +juliareach__reachabilityanalysis.jl-209 +juliareach__reachabilityanalysis.jl-212 +juliareach__reachabilityanalysis.jl-383 +juliareach__reachabilityanalysis.jl-618 +juliaregistries__compathelper.jl-458 +juliaregistries__compathelper.jl-505 +juliarobotics__rigidbodydynamics.jl-621 +juliasmoothoptimizers__krylov.jl-467 +juliasmoothoptimizers__krylov.jl-669 +juliasmoothoptimizers__krylov.jl-803 +juliasmoothoptimizers__krylov.jl-849 +juliasmoothoptimizers__krylov.jl-996 +juliastats__distances.jl-164 +juliastats__distances.jl-198 +juliastats__distances.jl-221 +juliastats__distances.jl-260 +juliastats__distributions.jl-1349 +juliastats__distributions.jl-1489 +juliastats__distributions.jl-1583 +juliastats__distributions.jl-1604 +juliastats__distributions.jl-1639 +juliastats__distributions.jl-1657 +juliastats__distributions.jl-1664 +juliastats__distributions.jl-1682 +juliastats__distributions.jl-1683 +juliastats__glm.jl-559 +juliastats__glm.jl-560 +juliastats__hypothesistests.jl-243 +juliastats__hypothesistests.jl-296 +juliastats__mixedmodels.jl-470 +juliastats__mixedmodels.jl-482 +juliastats__mixedmodels.jl-489 +juliastats__mixedmodels.jl-490 +juliastats__mixedmodels.jl-508 +juliastats__mixedmodels.jl-547 +juliastats__mixedmodels.jl-552 +juliastats__mixedmodels.jl-561 +juliastats__mixedmodels.jl-564 +juliastats__mixedmodels.jl-837 +juliastats__mixedmodels.jl-858 +juliastats__pdmats.jl-144 +juliastats__pdmats.jl-165 +juliastats__pdmats.jl-172 +juliastats__pdmats.jl-175 +juliastats__pdmats.jl-179 +juliastats__pdmats.jl-210 +juliastats__pdmats.jl-221 +juliastats__pdmats.jl-223 +juliastats__timeseries.jl-447 +juliastats__timeseries.jl-489 +juliastats__timeseries.jl-500 +juliasymbolics__symbolics.jl-1129 +juliasymbolics__symbolics.jl-1207 +juliasymbolics__symbolics.jl-1255 +juliasymbolics__symbolics.jl-1257 +juliasymbolics__symbolics.jl-1289 +juliasymbolics__symbolics.jl-1338 +juliasymbolics__symbolics.jl-1384 +juliasymbolics__symbolics.jl-1400 +juliasymbolics__symbolics.jl-1453 +juliasymbolics__symbolics.jl-1454 +juliasymbolics__symbolics.jl-1469 +juliasymbolics__symbolics.jl-1524 +juliasymbolics__symbolics.jl-1536 +juliasymbolics__symbolics.jl-1613 +juliasymbolics__symbolics.jl-1639 +juliasymbolics__symbolics.jl-1673 +juliasymbolics__symbolics.jl-299 +juliasymbolics__symbolics.jl-407 +juliasymbolics__symbolics.jl-661 +juliasymbolics__symbolics.jl-677 +juliasymbolics__symbolics.jl-696 +juliasymbolics__symbolics.jl-755 +juliasymbolics__symbolics.jl-838 +juliasymbolics__symbolics.jl-844 +juliasymbolics__symbolics.jl-846 +juliasymbolics__symbolicutils.jl-26 +juliasymbolics__symbolicutils.jl-69 +juliasymbolics__symbolicutils.jl-715 +juliasymbolics__symbolicutils.jl-75 +juliasymbolics__symbolicutils.jl-81 +juliasymbolics__symbolicutils.jl-92 +jump-dev__ipopt.jl-241 +jump-dev__ipopt.jl-252 +jump-dev__ipopt.jl-289 +jump-dev__ipopt.jl-309 +jump-dev__ipopt.jl-318 +jump-dev__ipopt.jl-334 +jump-dev__ipopt.jl-350 +jump-dev__ipopt.jl-389 +jump-dev__jump.jl-2179 +jump-dev__jump.jl-2240 +jump-dev__jump.jl-2281 +jump-dev__jump.jl-2359 +jump-dev__jump.jl-2524 +jump-dev__jump.jl-2527 +jump-dev__jump.jl-2533 +jump-dev__jump.jl-2550 +jump-dev__jump.jl-2570 +jump-dev__jump.jl-2689 +jump-dev__jump.jl-2699 +jump-dev__jump.jl-2704 +jump-dev__jump.jl-2705 +jump-dev__jump.jl-2707 +jump-dev__jump.jl-2710 +jump-dev__jump.jl-2712 +jump-dev__jump.jl-2714 +jump-dev__jump.jl-2718 +jump-dev__jump.jl-2732 +jump-dev__jump.jl-2734 +jump-dev__jump.jl-2739 +jump-dev__jump.jl-2741 +jump-dev__jump.jl-2768 +jump-dev__jump.jl-2774 +jump-dev__jump.jl-2800 +jump-dev__jump.jl-2827 +jump-dev__jump.jl-2844 +jump-dev__jump.jl-2847 +jump-dev__jump.jl-2868 +jump-dev__jump.jl-2929 +jump-dev__jump.jl-2932 +jump-dev__jump.jl-2966 +jump-dev__jump.jl-2976 +jump-dev__jump.jl-2978 +jump-dev__jump.jl-3002 +jump-dev__jump.jl-3101 +jump-dev__jump.jl-3152 +jump-dev__jump.jl-3154 +jump-dev__jump.jl-3180 +jump-dev__jump.jl-3244 +jump-dev__jump.jl-3280 +jump-dev__jump.jl-3302 +jump-dev__jump.jl-3338 +jump-dev__jump.jl-3381 +jump-dev__jump.jl-3385 +jump-dev__jump.jl-3394 +jump-dev__jump.jl-3422 +jump-dev__jump.jl-3474 +jump-dev__jump.jl-3500 +jump-dev__jump.jl-3520 +jump-dev__jump.jl-3552 +jump-dev__jump.jl-3584 +jump-dev__jump.jl-3639 +jump-dev__jump.jl-3647 +jump-dev__jump.jl-3653 +jump-dev__jump.jl-3655 +jump-dev__jump.jl-3658 +jump-dev__jump.jl-3667 +jump-dev__jump.jl-3681 +jump-dev__jump.jl-3691 +jump-dev__jump.jl-3693 +jump-dev__jump.jl-3743 +jump-dev__jump.jl-3751 +jump-dev__jump.jl-3756 +jump-dev__jump.jl-3766 +jump-dev__jump.jl-3781 +jump-dev__jump.jl-3797 +jump-dev__jump.jl-3805 +jump-dev__jump.jl-3813 +jump-dev__jump.jl-3840 +jump-dev__jump.jl-3883 +jump-dev__jump.jl-3892 +jump-dev__jump.jl-3934 +jump-dev__jump.jl-3974 +jump-dev__jump.jl-3979 +jump-dev__jump.jl-3983 +jump-dev__jump.jl-4000 +jump-dev__jump.jl-4002 +jump-dev__jump.jl-4041 +jump-dev__jump.jl-4050 +jump-dev__jump.jl-4051 +jumptrading__influx-spout-94 +jumptrading__influx-spout-96 +jumptrading__influx-spout-97 +jupyter-incubator__sparkmagic-353 +jupyter-incubator__sparkmagic-371 +jupyter-incubator__sparkmagic-389 +jupyter-incubator__sparkmagic-542 +jupyter-incubator__sparkmagic-572 +jupyter__jupyter_client-1060 +jupyter__jupyter_client-274 +jupyter__jupyter_client-339 +jupyter__jupyter_client-697 +jupyter__jupyter_client-994 +jupyter__kernel_gateway-118 +jupyter__kernel_gateway-152 +jupyter__kernel_gateway-215 +jupyter__kernel_gateway-234 +jupyter__kernel_gateway-340 +jupyter__nbconvert-1981 +jupyter__nbconvert-2152 +jupyter__qtconsole-611 +jupyterhub__binderhub-1921 +jupyterhub__oauthenticator-579 +jupyterhub__oauthenticator-699 +jupyterhub__the-littlest-jupyterhub-1013 +jupyterhub__the-littlest-jupyterhub-876 +jupyterhub__the-littlest-jupyterhub-905 +justwatchcom__gopass-802 +juxt__aero-83 +k0sproject__k0s-834 +k0sproject__k0s-842 +k0sproject__k0sctl-181 +k0sproject__k0sctl-426 +k0sproject__k0sctl-466 +k0sproject__k0sctl-556 +k0sproject__k0sctl-685 +k0sproject__k0sctl-686 +k0sproject__k0sctl-770 +k0sproject__k0sctl-781 +k0sproject__k0sctl-784 +k0sproject__k0sctl-816 +k0sproject__k0sctl-853 +k1low__tbls-600 +k8ssandra__k8ssandra-operator-152 +k8ssandra__k8ssandra-operator-273 +k8ssandra__k8ssandra-operator-306 +k8ssandra__k8ssandra-operator-319 +k8ssandra__k8ssandra-operator-347 +k8ssandra__k8ssandra-operator-387 +k8ssandra__k8ssandra-operator-580 +k8ssandra__k8ssandra-operator-738 +k8ssandra__k8ssandra-operator-756 +k8ssandra__k8ssandra-operator-801 +k8ssandra__k8ssandra-operator-825 +k8ssandra__k8ssandra-operator-982 +k8ssandra__k8ssandra-operator-987 +kafka-ops__kafka-topology-builder-108 +kafka-ops__kafka-topology-builder-119 +kafka-ops__kafka-topology-builder-120 +kafka-ops__kafka-topology-builder-128 +kafka-ops__kafka-topology-builder-129 +kafka-ops__kafka-topology-builder-143 +kafka-ops__kafka-topology-builder-144 +kafka-ops__kafka-topology-builder-149 +kafka-ops__kafka-topology-builder-163 +kafka-ops__kafka-topology-builder-183 +kafka-ops__kafka-topology-builder-184 +kafka-ops__kafka-topology-builder-185 +kafka-ops__kafka-topology-builder-200 +kafka-ops__kafka-topology-builder-204 +kaliber5__ember-responsive-image-130 +kaliber5__ember-responsive-image-391 +kamilkisiela__graphql-inspector-353 +kamilkisiela__graphql-inspector-56 +kamilkisiela__graphql-inspector-94 +karma-runner__karma-3659 +karma-runner__karma-3718 +kaspanet__kaspad-1592 +kaspanet__kaspad-1800 +kata-containers__agent-242 +katex__katex-1784 +katex__katex-1794 +katex__katex-1796 +katex__katex-1813 +katex__katex-1814 +katex__katex-1841 +katex__katex-1921 +katex__katex-2040 +katex__katex-2054 +katex__katex-2080 +katex__katex-2116 +katex__katex-2118 +katex__katex-2186 +katex__katex-2220 +katex__katex-2278 +katex__katex-2459 +katex__katex-2618 +katex__katex-2679 +katex__katex-2703 +katex__katex-2877 +katex__katex-2947 +katex__katex-2949 +katex__katex-2991 +katex__katex-3009 +katex__katex-3018 +katex__katex-3963 +katex__katex-3997 +katex__katex-3999 +katex__katex-4000 +kayak__pypika-109 +kayak__pypika-112 +kayak__pypika-127 +kayak__pypika-135 +kayak__pypika-136 +kayak__pypika-148 +kayak__pypika-16 +kayak__pypika-170 +kayak__pypika-181 +kayak__pypika-182 +kayak__pypika-183 +kayak__pypika-185 +kayak__pypika-198 +kayak__pypika-201 +kayak__pypika-206 +kayak__pypika-23 +kayak__pypika-236 +kayak__pypika-242 +kayak__pypika-267 +kayak__pypika-306 +kayak__pypika-31 +kayak__pypika-33 +kayak__pypika-343 +kayak__pypika-38 +kayak__pypika-39 +kayak__pypika-49 +kayak__pypika-53 +kayak__pypika-54 +kayak__pypika-56 +kayak__pypika-64 +kayak__pypika-80 +kayak__pypika-96 +kaz-yos__tableone-66 +kbknapp__clap-rs-894 +kbsali__php-redmine-api-258 +kbsali__php-redmine-api-275 +kbsali__php-redmine-api-309 +kcl-lang__kcl-go-430 +kcl-lang__kcl-go-445 +keathley__finch-21 +keathley__finch-34 +keathley__finch-47 +keathley__norm-38 +keathley__norm-41 +keathley__norm-43 +keathley__norm-44 +keathley__norm-49 +keathley__norm-70 +keathley__norm-85 +keats__tera-260 +keats__tera-272 +keats__tera-278 +keats__tera-337 +keats__tera-426 +keats__tera-43 +keats__tera-430 +keats__tera-432 +keats__tera-744 +keats__tera-87 +keats__tera-908 +kedacore__http-add-on-1307 +keep-starknet-strange__beerus-119 +keep-starknet-strange__beerus-133 +keep-starknet-strange__beerus-174 +keepsafe__aiohttp-1580 +keichi__binary-parser-202 +keichi__binary-parser-203 +keikoproj__instance-manager-102 +keikoproj__instance-manager-110 +keikoproj__instance-manager-115 +keikoproj__instance-manager-125 +keikoproj__instance-manager-126 +keikoproj__instance-manager-138 +keikoproj__instance-manager-146 +keikoproj__instance-manager-157 +keikoproj__instance-manager-159 +keikoproj__instance-manager-160 +keikoproj__instance-manager-161 +keikoproj__instance-manager-169 +keikoproj__instance-manager-183 +keikoproj__instance-manager-252 +keikoproj__instance-manager-270 +keikoproj__instance-manager-271 +keikoproj__instance-manager-284 +keikoproj__instance-manager-309 +keikoproj__instance-manager-319 +keikoproj__instance-manager-323 +keikoproj__instance-manager-332 +keikoproj__instance-manager-344 +keikoproj__instance-manager-345 +keikoproj__instance-manager-36 +keikoproj__instance-manager-374 +keikoproj__instance-manager-42 +keikoproj__instance-manager-46 +keikoproj__instance-manager-62 +keikoproj__instance-manager-65 +keikoproj__upgrade-manager-35 +keikoproj__upgrade-manager-41 +keithamus__sort-package-json-330 +keithamus__sort-package-json-361 +kelektiv__node-cron-740 +kelektiv__node-cron-861 +kelektiv__node-cron-894 +kelektiv__node-cron-924 +kelektiv__node-cron-957 +kelektiv__node-cron-963 +kelektiv__node-cron-980 +kennethreitz__pipenv-1031 +kennethreitz__pipenv-1095 +kennethreitz__pipenv-1114 +kennethreitz__pipenv-976 +kentcdodds__dom-testing-library-222 +kentcdodds__dom-testing-library-29 +kentcdodds__dom-testing-library-4 +kentik__ktranslate-572 +kentik__ktranslate-696 +kentik__ktranslate-721 +kentik__ktranslate-813 +keon__algorithms-233 +keon__algorithms-235 +keon__algorithms-402 +keon__algorithms-432 +keon__algorithms-551 +keon__algorithms-563 +keon__algorithms-591 +keras-team__keras-18571 +keras-team__keras-19284 +keras-team__keras-19300 +keras-team__keras-19387 +keras-team__keras-19459 +keras-team__keras-19466 +keras-team__keras-19484 +keras-team__keras-19618 +keras-team__keras-19641 +keras-team__keras-19643 +keras-team__keras-19775 +keras-team__keras-19799 +keras-team__keras-19829 +keras-team__keras-19838 +keras-team__keras-19863 +keras-team__keras-19903 +keras-team__keras-19915 +keras-team__keras-19931 +keras-team__keras-19937 +keras-team__keras-19945 +keras-team__keras-19955 +keras-team__keras-19973 +keras-team__keras-20008 +keras-team__keras-20040 +keras-team__keras-20041 +keras-team__keras-20079 +keras-team__keras-20122 +keras-team__keras-20206 +keras-team__keras-20296 +keras-team__keras-20443 +keras-team__keras-20457 +keras-team__keras-20476 +keras-team__keras-20484 +keras-team__keras-20534 +keras-team__keras-20550 +keras-team__keras-20609 +keras-team__keras-20689 +keras-team__keras-nlp-143 +keras-team__keras-nlp-1520 +keras-team__keras-nlp-214 +keras-team__keras-nlp-59 +keras-team__keras-nlp-64 +keras-team__keras-nlp-715 +keras-team__keras-nlp-92 +kevin1024__vcrpy-510 +khan__flow-to-ts-124 +khan__flow-to-ts-145 +khan__flow-to-ts-151 +khan__flow-to-ts-172 +khan__flow-to-ts-179 +khan__flow-to-ts-216 +khan__flow-to-ts-220 +khan__flow-to-ts-240 +khan__flow-to-ts-241 +khan__flow-to-ts-242 +khan__flow-to-ts-243 +khan__flow-to-ts-245 +khan__flow-to-ts-247 +khan__flow-to-ts-27 +khan__flow-to-ts-35 +khan__flow-to-ts-43 +khan__flow-to-ts-45 +khan__flow-to-ts-64 +khan__flow-to-ts-91 +khan__flow-to-ts-92 +khan__flow-to-ts-96 +khan__genqlient-376 +khan__genqlient-81 +khan__katex-1723 +kibertoad__toad-scheduler-156 +kibertoad__toad-scheduler-180 +kibertoad__toad-scheduler-183 +kiegroup__github-action-build-chain-278 +kiegroup__github-action-build-chain-307 +kiegroup__github-action-build-chain-352 +kiegroup__github-action-build-chain-355 +kiegroup__github-action-build-chain-356 +kiegroup__github-action-build-chain-384 +kiegroup__github-action-build-chain-395 +kiegroup__github-action-build-chain-425 +kiegroup__github-action-build-chain-438 +kiegroup__github-action-build-chain-446 +kiegroup__github-action-build-chain-456 +kiegroup__github-action-build-chain-460 +kiegroup__github-action-build-chain-462 +kinto__kinto-1814 +kinto__kinto-1910 +kinto__kinto-1919 +kinto__kinto-1924 +kinto__kinto-1951 +kinto__kinto-1953 +kinto__kinto-1993 +kinto__kinto-2011 +kinto__kinto-2027 +kinto__kinto-2227 +kinto__kinto-2229 +kinto__kinto-2307 +kinto__kinto-2380 +kinto__kinto-http.py-122 +kinto__kinto-http.py-130 +kinto__kinto-http.py-131 +kinto__kinto-http.py-133 +kinto__kinto-http.py-135 +kinto__kinto-http.py-137 +kinto__kinto-http.py-138 +kinto__kinto-http.py-139 +kinto__kinto-http.py-168 +kinto__kinto-http.py-188 +kinto__kinto-http.py-189 +kinto__kinto-http.py-384 +kinvolk__lokomotive-1483 +kinvolk__lokomotive-1515 +kivikakk__comrak-219 +kivikakk__comrak-228 +kivikakk__comrak-266 +kivikakk__comrak-279 +kivikakk__comrak-373 +kivikakk__comrak-429 +kivikakk__comrak-438 +kivikakk__comrak-439 +kivikakk__comrak-499 +kivikakk__comrak-508 +kivikakk__comrak-574 +kivikakk__comrak-582 +kiwicom__mobile-916 +kiwicom__mobile-921 +klothoplatform__klotho-152 +klothoplatform__klotho-155 +klothoplatform__klotho-256 +klothoplatform__klotho-269 +klothoplatform__klotho-281 +klothoplatform__klotho-320 +klothoplatform__klotho-354 +klothoplatform__klotho-362 +klothoplatform__klotho-816 +kmesh-net__kmesh-1094 +kmyk__online-judge-tools-288 +kmyk__online-judge-tools-398 +kmyk__online-judge-tools-404 +kmyk__online-judge-tools-442 +kmyk__online-judge-tools-445 +kmyk__online-judge-tools-461 +kmyk__online-judge-tools-589 +kmyk__online-judge-tools-619 +knative-sandbox__eventing-kafka-1044 +knative-sandbox__eventing-kafka-172 +knative-sandbox__eventing-kafka-20 +knative-sandbox__eventing-kafka-237 +knative-sandbox__eventing-kafka-263 +knative-sandbox__eventing-kafka-30 +knative-sandbox__eventing-kafka-332 +knative-sandbox__eventing-kafka-439 +knative-sandbox__eventing-kafka-446 +knative-sandbox__eventing-kafka-458 +knative-sandbox__eventing-kafka-55 +knative-sandbox__eventing-kafka-621 +knative-sandbox__eventing-kafka-694 +knative-sandbox__eventing-kafka-705 +knative-sandbox__eventing-kafka-782 +knative-sandbox__eventing-kafka-795 +knative-sandbox__eventing-kafka-broker-1023 +knative-sandbox__eventing-kafka-broker-1597 +knative-sandbox__eventing-kafka-broker-212 +knative-sandbox__eventing-kafka-broker-2224 +knative-sandbox__eventing-kafka-broker-265 +knative-sandbox__eventing-kafka-broker-2773 +knative-sandbox__eventing-kafka-broker-2811 +knative-sandbox__eventing-kafka-broker-2829 +knative-sandbox__eventing-kafka-broker-2853 +knative-sandbox__eventing-kafka-broker-2971 +knative-sandbox__eventing-kafka-broker-595 +knative-sandbox__eventing-kafka-broker-747 +knative-sandbox__eventing-kafka-broker-880 +knative-sandbox__eventing-kafka-broker-912 +knative-sandbox__eventing-rabbitmq-1163 +knative-sandbox__eventing-rabbitmq-614 +knative-sandbox__eventing-rabbitmq-750 +knative-sandbox__eventing-rabbitmq-771 +knative-sandbox__eventing-rabbitmq-815 +knative-sandbox__eventing-rabbitmq-868 +knative-sandbox__eventing-rabbitmq-927 +knative-sandbox__kn-plugin-func-1185 +knative-sandbox__kn-plugin-func-1205 +knative-sandbox__net-kourier-1039 +knative__client-682 +knative__operator-1548 +knative__operator-1823 +knative__operator-2010 +knative__pkg-1293 +knative__pkg-1399 +knative__pkg-1403 +knative__pkg-1778 +knative__pkg-2002 +knative__pkg-2036 +knative__pkg-2339 +knative__pkg-2395 +knative__pkg-2402 +knative__pkg-2547 +knative__pkg-2566 +knative__pkg-2582 +knative__pkg-2717 +knative__pkg-2849 +knative__pkg-2861 +knative__serving-10645 +knative__serving-11798 +knope-dev__knope-1399 +knope-dev__knope-472 +knope-dev__knope-666 +knuckleswtf__scribe-318 +knuckleswtf__scribe-43 +knuckleswtf__scribe-492 +knuckleswtf__scribe-54 +knuckleswtf__scribe-609 +knuckleswtf__scribe-614 +knuckleswtf__scribe-667 +knuckleswtf__scribe-670 +knuckleswtf__scribe-713 +knuckleswtf__scribe-826 +knuckleswtf__scribe-886 +knurling-rs__defmt-198 +knurling-rs__defmt-211 +knurling-rs__defmt-226 +koajs__koa-434 +koajs__koa-781 +koajs__koa-807 +koaning__scikit-lego-736 +koaning__scikit-lego-738 +kong__deck-1344 +kong__kubernetes-ingress-controller-7538 +kong__kubernetes-ingress-controller-7583 +kong__swrv-123 +kong__swrv-127 +kong__swrv-132 +kong__swrv-134 +kong__swrv-205 +kong__swrv-49 +kong__swrv-59 +kong__swrv-65 +kong__swrv-81 +kong__swrv-95 +kovetskiy__mark-174 +kovetskiy__mark-175 +kovetskiy__mark-237 +kovetskiy__mark-244 +kovetskiy__mark-248 +kovetskiy__mark-33 +kovetskiy__mark-351 +kovetskiy__mark-496 +kovetskiy__mark-512 +kovetskiy__mark-542 +kozea__weasyprint-1012 +kozea__weasyprint-1016 +kozea__weasyprint-1832 +kozea__weasyprint-1895 +kozea__weasyprint-1899 +kozea__weasyprint-2087 +kozea__weasyprint-2252 +kozea__weasyprint-2300 +kozea__weasyprint-2301 +kozea__weasyprint-2326 +kozea__weasyprint-2404 +kozea__weasyprint-2405 +kozea__weasyprint-2416 +kozea__weasyprint-2425 +kozea__weasyprint-2494 +kozea__weasyprint-843 +kozistr__pytorch_optimizer-344 +kozistr__pytorch_optimizer-395 +kraigie__nostrum-369 +kraigie__nostrum-377 +kristofferc__pgfplotsx.jl-245 +kristofferc__pgfplotsx.jl-294 +kristofferc__pgfplotsx.jl-311 +ktr0731__evans-410 +ktr0731__evans-414 +ktr0731__evans-530 +ktsn__vuex-smart-module-243 +ktsn__vuex-smart-module-259 +ktsn__vuex-smart-module-366 +kubean-io__kubean-188 +kubean-io__kubean-362 +kubean-io__kubean-371 +kubean-io__kubean-488 +kubean-io__kubean-499 +kubean-io__kubean-83 +kubeapps__kubeapps-3970 +kubeapps__kubeapps-4359 +kubeclipper__kubeclipper-818 +kubeless__kubeless-1097 +kubermatic__kubermatic-10348 +kubermatic__kubermatic-10584 +kubermatic__kubermatic-10953 +kubermatic__kubermatic-11588 +kubermatic__kubermatic-11668 +kubermatic__kubermatic-11719 +kubermatic__kubermatic-11836 +kubermatic__kubermatic-11844 +kubermatic__kubermatic-11845 +kubermatic__kubermatic-11886 +kubermatic__kubermatic-11996 +kubermatic__kubermatic-12329 +kubermatic__kubermatic-12996 +kubermatic__kubermatic-13139 +kubermatic__kubermatic-13585 +kubermatic__kubermatic-8559 +kubermatic__kubermatic-8628 +kubermatic__kubermatic-9224 +kubermatic__kubermatic-9261 +kubermatic__kubermatic-9296 +kubermatic__kubermatic-9579 +kubermatic__kubermatic-9674 +kubermatic__machine-controller-1906 +kubernetes-client__javascript-1995 +kubernetes-client__javascript-2046 +kubernetes-client__javascript-2224 +kubernetes-client__javascript-2311 +kubernetes-client__javascript-2351 +kubernetes-client__javascript-2400 +kubernetes-client__javascript-2433 +kubernetes-client__python-1933 +kubernetes-client__python-2050 +kubernetes-client__python-2100 +kubernetes-client__python-2216 +kubernetes-client__python-2303 +kubernetes-csi__csi-driver-nfs-149 +kubernetes-csi__csi-driver-nfs-574 +kubernetes-csi__csi-driver-nfs-770 +kubernetes-csi__csi-driver-nfs-878 +kubernetes-csi__csi-driver-nfs-879 +kubernetes-csi__csi-driver-smb-18 +kubernetes-csi__external-attacher-193 +kubernetes-csi__external-attacher-209 +kubernetes-csi__external-attacher-213 +kubernetes-csi__external-attacher-227 +kubernetes-csi__external-attacher-338 +kubernetes-csi__external-attacher-342 +kubernetes-csi__external-provisioner-327 +kubernetes-csi__external-provisioner-337 +kubernetes-csi__external-provisioner-383 +kubernetes-csi__external-provisioner-387 +kubernetes-csi__external-provisioner-393 +kubernetes-csi__external-provisioner-399 +kubernetes-csi__external-provisioner-434 +kubernetes-csi__external-provisioner-448 +kubernetes-csi__external-provisioner-534 +kubernetes-csi__external-provisioner-612 +kubernetes-csi__external-provisioner-717 +kubernetes-csi__external-provisioner-739 +kubernetes-csi__external-provisioner-758 +kubernetes-csi__external-snapshotter-1015 +kubernetes-csi__external-snapshotter-1100 +kubernetes-csi__external-snapshotter-1152 +kubernetes-csi__external-snapshotter-1235 +kubernetes-csi__external-snapshotter-210 +kubernetes-csi__external-snapshotter-249 +kubernetes-csi__external-snapshotter-289 +kubernetes-csi__external-snapshotter-335 +kubernetes-csi__external-snapshotter-360 +kubernetes-csi__external-snapshotter-375 +kubernetes-csi__external-snapshotter-423 +kubernetes-csi__external-snapshotter-428 +kubernetes-csi__external-snapshotter-433 +kubernetes-csi__external-snapshotter-442 +kubernetes-csi__external-snapshotter-519 +kubernetes-csi__external-snapshotter-526 +kubernetes-csi__external-snapshotter-573 +kubernetes-csi__external-snapshotter-674 +kubernetes-incubator__client-python-107 +kubernetes-incubator__client-python-183 +kubernetes-incubator__client-python-247 +kubernetes-incubator__client-python-32 +kubernetes-incubator__client-python-50 +kubernetes-incubator__client-python-69 +kubernetes-incubator__client-python-78 +kubernetes-incubator__external-dns-1018 +kubernetes-incubator__external-dns-1102 +kubernetes-sigs__apiserver-network-proxy-31 +kubernetes-sigs__apiserver-network-proxy-754 +kubernetes-sigs__aws-alb-ingress-controller-1172 +kubernetes-sigs__aws-alb-ingress-controller-1179 +kubernetes-sigs__aws-alb-ingress-controller-1253 +kubernetes-sigs__aws-alb-ingress-controller-1459 +kubernetes-sigs__aws-ebs-csi-driver-2166 +kubernetes-sigs__aws-ebs-csi-driver-824 +kubernetes-sigs__aws-ebs-csi-driver-830 +kubernetes-sigs__azuredisk-csi-driver-657 +kubernetes-sigs__azuredisk-csi-driver-683 +kubernetes-sigs__azuredisk-csi-driver-715 +kubernetes-sigs__azurefile-csi-driver-2394 +kubernetes-sigs__azurefile-csi-driver-513 +kubernetes-sigs__cluster-api-5387 +kubernetes-sigs__cluster-api-bootstrap-provider-kubeadm-280 +kubernetes-sigs__cluster-api-provider-aws-5589 +kubernetes-sigs__cluster-api-provider-azure-1621 +kubernetes-sigs__cluster-api-provider-azure-1626 +kubernetes-sigs__cluster-api-provider-azure-1824 +kubernetes-sigs__cluster-api-provider-gcp-1434 +kubernetes-sigs__cluster-api-provider-kubevirt-151 +kubernetes-sigs__cluster-api-provider-kubevirt-157 +kubernetes-sigs__cluster-api-provider-kubevirt-159 +kubernetes-sigs__cluster-api-provider-kubevirt-164 +kubernetes-sigs__cluster-api-provider-kubevirt-235 +kubernetes-sigs__cluster-api-provider-kubevirt-277 +kubernetes-sigs__cluster-api-provider-kubevirt-93 +kubernetes-sigs__cluster-api-provider-kubevirt-99 +kubernetes-sigs__cluster-api-provider-vsphere-2590 +kubernetes-sigs__controller-runtime-2905 +kubernetes-sigs__descheduler-1451 +kubernetes-sigs__descheduler-967 +kubernetes-sigs__gcp-compute-persistent-disk-csi-driver-2057 +kubernetes-sigs__gcp-compute-persistent-disk-csi-driver-2091 +kubernetes-sigs__gcp-filestore-csi-driver-59 +kubernetes-sigs__ingress2gateway-26 +kubernetes-sigs__ingress2gateway-31 +kubernetes-sigs__ingress2gateway-53 +kubernetes-sigs__ingress2gateway-89 +kubernetes-sigs__kube-scheduler-simulator-418 +kubernetes-sigs__kubefed-1379 +kubernetes-sigs__kueue-152 +kubernetes-sigs__kueue-153 +kubernetes-sigs__kueue-163 +kubernetes-sigs__kwok-144 +kubernetes-sigs__kwok-347 +kubernetes-sigs__lws-229 +kubernetes-sigs__node-feature-discovery-1781 +kubernetes-sigs__scheduler-plugins-708 +kubernetes__cloud-provider-aws-667 +kubernetes__cloud-provider-aws-673 +kubernetes__dashboard-5182 +kubernetes__dashboard-5660 +kubernetes__ingress-nginx-6123 +kubernetes__klog-128 +kubernetes__klog-140 +kubernetes__klog-157 +kubernetes__klog-159 +kubernetes__klog-166 +kubernetes__klog-217 +kubernetes__klog-237 +kubernetes__klog-279 +kubernetes__klog-299 +kubernetes__klog-303 +kubernetes__klog-332 +kubernetes__klog-344 +kubernetes__klog-368 +kubernetes__klog-378 +kubernetes__klog-404 +kubernetes__kompose-2001 +kubernetes__kops-10073 +kubernetes__kops-10167 +kubernetes__kops-10239 +kubernetes__kops-10247 +kubernetes__kops-10405 +kubernetes__kops-10519 +kubernetes__kops-10910 +kubernetes__kops-11127 +kubernetes__kops-11312 +kubernetes__kops-11590 +kubernetes__kops-11962 +kubernetes__kops-12698 +kubernetes__kops-12728 +kubernetes__kops-13534 +kubernetes__kops-14194 +kubernetes__kops-14251 +kubernetes__kops-14287 +kubernetes__kops-14347 +kubernetes__kops-14370 +kubernetes__kops-14423 +kubernetes__kops-14503 +kubernetes__kops-14694 +kubernetes__kops-14709 +kubernetes__kops-14773 +kubernetes__kops-14887 +kubernetes__kops-15139 +kubernetes__kops-15462 +kubernetes__kops-15490 +kubernetes__kops-15579 +kubernetes__kops-15623 +kubernetes__kops-15746 +kubernetes__kops-15756 +kubernetes__kops-15795 +kubernetes__kops-16013 +kubernetes__kops-16318 +kubernetes__kops-16605 +kubernetes__kops-16615 +kubernetes__kops-16681 +kubernetes__kops-16682 +kubernetes__kops-17177 +kubernetes__kops-17270 +kubernetes__kops-17430 +kubernetes__kops-8074 +kubernetes__kops-8159 +kubernetes__kops-8980 +kubernetes__kops-9004 +kubernetes__kops-9052 +kubernetes__kops-9280 +kubernetes__kops-9348 +kubernetes__kops-9360 +kubernetes__kops-9454 +kubernetes__kops-9967 +kubernetes__kops-9998 +kubernetes__minikube-13775 +kubernetes__minikube-13782 +kubernetes__minikube-14123 +kubernetes__minikube-15622 +kubernetes__minikube-15762 +kubernetes__minikube-15782 +kubernetes__minikube-16124 +kubernetes__minikube-17116 +kubernetes__minikube-18648 +kubernetes__minikube-19790 +kubesphere__ks-devops-1001 +kubesphere__kubesphere-2672 +kudobuilder__kuttl-483 +kudobuilder__kuttl-560 +kudobuilder__kuttl-576 +kudobuilder__kuttl-581 +kumahq__kuma-1017 +kumahq__kuma-13872 +kurator-dev__kurator-667 +kurtosis-tech__kurtosis-1427 +kurtosis-tech__kurtosis-1446 +kurtosis-tech__kurtosis-2024 +kurtosis-tech__kurtosis-2424 +kyeotic__raviger-112 +kyeotic__raviger-118 +kyeotic__raviger-20 +kyeotic__raviger-25 +kyeotic__raviger-26 +kyeotic__raviger-29 +kyeotic__raviger-35 +kyeotic__raviger-43 +kyeotic__raviger-45 +kyeotic__raviger-51 +kyeotic__raviger-59 +kyeotic__raviger-72 +kyeotic__raviger-89 +kyleconroy__sqlc-336 +kyma-project__cli-1604 +kythe__kythe-5013 +kyverno__chainsaw-2140 +kyverno__kyverno-2788 +kyverno__kyverno-5817 +labgrid-project__labgrid-1558 +labgrid-project__labgrid-1591 +labstack__echo-1287 +labstack__echo-1413 +labstack__echo-1467 +labstack__echo-1480 +labstack__echo-1501 +labstack__echo-1524 +labstack__echo-1563 +labstack__echo-1588 +labstack__echo-1604 +labstack__echo-1659 +labstack__echo-1661 +labstack__echo-1667 +labstack__echo-1669 +labstack__echo-1674 +labstack__echo-1695 +labstack__echo-1704 +labstack__echo-1727 +labstack__echo-1741 +labstack__echo-1795 +labstack__echo-1802 +labstack__echo-1805 +labstack__echo-1835 +labstack__echo-1836 +labstack__echo-1861 +labstack__echo-1910 +labstack__echo-1929 +labstack__echo-1988 +labstack__echo-2007 +labstack__echo-2027 +labstack__echo-2047 +labstack__echo-2134 +labstack__echo-2191 +labstack__echo-2257 +labstack__echo-2411 +labstack__echo-2477 +lambda-fairy__maud-219 +lambda-fairy__maud-265 +lambda-fairy__maud-383 +lambdaclass__ethrex-2118 +lambdaclass__ethrex-70 +laminas__laminas-cli-118 +laminas__laminas-validator-372 +laminas__laminas-validator-375 +laminas__laminas-validator-412 +lanl-ansi__powermodels.jl-822 +lanl-ansi__powermodels.jl-871 +lanl-ansi__powermodelsdistribution.jl-320 +lanl-ansi__powermodelsdistribution.jl-331 +laravel-backpack__crud-5640 +laravel-shift__blueprint-376 +laravel-shift__blueprint-393 +laravel-shift__blueprint-394 +laravel-shift__blueprint-398 +laravel-shift__blueprint-403 +laravel-shift__blueprint-418 +laravel-shift__blueprint-427 +laravel-shift__blueprint-433 +laravel-shift__blueprint-445 +laravel-shift__blueprint-447 +laravel-shift__blueprint-470 +laravel-shift__blueprint-471 +laravel-shift__blueprint-477 +laravel-shift__blueprint-512 +laravel-shift__blueprint-522 +laravel-shift__blueprint-524 +laravel-shift__blueprint-534 +laravel-shift__blueprint-535 +laravel-shift__blueprint-551 +laravel-shift__blueprint-565 +laravel-shift__blueprint-577 +laravel-shift__blueprint-580 +laravel-shift__blueprint-581 +laravel-shift__blueprint-591 +laravel-shift__blueprint-592 +laravel-shift__blueprint-680 +laravel-shift__blueprint-681 +laravel-shift__blueprint-724 +laravel-shift__blueprint-737 +laravel__framework-35131 +laravel__framework-35827 +laravel__framework-35874 +laravel__framework-35966 +laravel__framework-36081 +laravel__framework-36240 +laravel__framework-36881 +laravel__framework-37432 +laravel__framework-37487 +laravel__framework-37596 +laravel__framework-37621 +laravel__framework-37810 +laravel__framework-37815 +laravel__framework-38642 +laravel__framework-38962 +laravel__framework-38979 +laravel__framework-39020 +laravel__framework-39041 +laravel__framework-39673 +laravel__framework-40245 +laravel__framework-40278 +laravel__framework-40303 +laravel__framework-40822 +laravel__framework-40921 +laravel__framework-40967 +laravel__framework-41120 +laravel__framework-41133 +laravel__framework-41429 +laravel__framework-42191 +laravel__framework-42281 +laravel__framework-42301 +laravel__framework-42316 +laravel__framework-42341 +laravel__framework-42517 +laravel__framework-42571 +laravel__framework-42606 +laravel__framework-42815 +laravel__framework-42929 +laravel__framework-42950 +laravel__framework-42963 +laravel__framework-43365 +laravel__framework-43426 +laravel__framework-43609 +laravel__framework-43635 +laravel__framework-43758 +laravel__framework-44237 +laravel__framework-44319 +laravel__framework-44330 +laravel__framework-44473 +laravel__framework-44979 +laravel__framework-45333 +laravel__framework-45533 +laravel__framework-45555 +laravel__framework-45584 +laravel__framework-45928 +laravel__framework-47522 +lark-parser__lark-1003 +lark-parser__lark-704 +laspy__laspy-182 +laspy__laspy-185 +laspy__laspy-195 +laspy__laspy-200 +laspy__laspy-220 +laspy__laspy-281 +laspy__laspy-289 +laspy__laspy-327 +laspy__laspy-342 +leafwing-studios__leafwing-input-manager-362 +leafwing-studios__leafwing-input-manager-422 +leafwing-studios__leafwing-input-manager-452 +leafwing-studios__leafwing-input-manager-504 +leafwing-studios__leafwing-input-manager-573 +leafwing-studios__leafwing-input-manager-601 +leafwing-studios__leafwing-input-manager-603 +league-of-foundry-developers__foundry-vtt-types-2671 +learningequality__studio-5156 +leifg__formulon-1239 +lektor__lektor-1143 +lektor__lektor-1155 +lektor__lektor-1161 +lektor__lektor-1172 +lektor__lektor-1214 +lektor__lektor-1224 +leptos-rs__leptos-2331 +leptos-rs__leptos-3520 +lerna-lite__lerna-lite-1065 +leshchenko1979__fast_bitrix24-114 +leshchenko1979__fast_bitrix24-178 +leshchenko1979__fast_bitrix24-217 +leshchenko1979__fast_bitrix24-233 +leshchenko1979__fast_bitrix24-237 +leshchenko1979__fast_bitrix24-257 +lesshint__lesshint-182 +lesshint__lesshint-189 +lesshint__lesshint-204 +lesshint__lesshint-206 +lesshint__lesshint-212 +lesshint__lesshint-229 +lesshint__lesshint-238 +lesshint__lesshint-243 +lesshint__lesshint-247 +lesshint__lesshint-248 +lesshint__lesshint-265 +lesshint__lesshint-273 +lesshint__lesshint-284 +lesshint__lesshint-286 +lesshint__lesshint-288 +lesshint__lesshint-294 +lesshint__lesshint-359 +lesshint__lesshint-398 +lesshint__lesshint-53 +lestrrat-go__jwx-180 +lexhide__xandra-55 +liamg__tfsec-139 +liampauling__flumine-199 +liampauling__flumine-200 +liampauling__flumine-232 +liampauling__flumine-348 +liampauling__flumine-467 +liampauling__flumine-479 +liampauling__flumine-503 +liampauling__flumine-520 +liampauling__flumine-523 +liampauling__flumine-546 +libbpf__libbpf-rs-130 +libbpf__libbpf-rs-90 +libgit2__git2go-446 +libgit2__git2go-733 +libgit2__git2go-734 +libgit2__git2go-735 +libgit2__git2go-736 +libgit2__git2go-738 +libgit2__git2go-740 +libgit2__git2go-741 +libgit2__git2go-742 +libgit2__git2go-743 +libgit2__pygit2-1282 +librenms__librenms-3348 +librosa__librosa-1560 +librosa__librosa-1561 +librosa__librosa-1916 +librosa__librosa-1958 +liftbridge-io__liftbridge-148 +liftbridge-io__liftbridge-349 +lightning-js__renderer-479 +lightninglabs__taproot-assets-1585 +lightningnetwork__lnd-4327 +lightningnetwork__lnd-6219 +lightningnetwork__lnd-6438 +lightningnetwork__lnd-8665 +lightningnetwork__lnd-8961 +lima-vm__lima-3514 +lima-vm__lima-3515 +lima-vm__lima-3637 +lindell__multi-gitter-140 +lindell__multi-gitter-171 +lindell__multi-gitter-210 +lindell__multi-gitter-215 +lindell__multi-gitter-222 +lindell__multi-gitter-232 +lindell__multi-gitter-366 +lindell__multi-gitter-397 +lindell__multi-gitter-399 +lindell__multi-gitter-466 +line__line-bot-sdk-go-286 +line__line-bot-sdk-go-298 +line__line-bot-sdk-go-319 +line__line-bot-sdk-go-336 +line__line-bot-sdk-go-343 +line__line-bot-sdk-nodejs-421 +line__line-bot-sdk-python-293 +linebender__vello-591 +lingui__js-lingui-1059 +lingui__js-lingui-1060 +lingui__js-lingui-1074 +lingui__js-lingui-1126 +lingui__js-lingui-1127 +lingui__js-lingui-1131 +lingui__js-lingui-389 +lingui__js-lingui-502 +lingui__js-lingui-682 +lingui__js-lingui-685 +lingui__js-lingui-754 +lingui__js-lingui-762 +lingui__js-lingui-763 +lingui__js-lingui-783 +lingui__js-lingui-784 +lingui__js-lingui-802 +lingui__js-lingui-803 +lingui__js-lingui-807 +lingui__js-lingui-818 +lingui__js-lingui-820 +lingui__js-lingui-854 +lingui__js-lingui-862 +lingui__js-lingui-871 +lingui__js-lingui-881 +lingui__js-lingui-889 +lingui__js-lingui-898 +lingui__js-lingui-906 +lingui__js-lingui-938 +lingui__js-lingui-942 +lingui__js-lingui-958 +linkerd__linkerd2-11875 +linkerd__linkerd2-5399 +linkerd__linkerd2-5406 +linkerd__linkerd2-5407 +linkerd__linkerd2-5454 +linkerd__linkerd2-7481 +linode__linode-cloud-controller-manager-109 +linode__linode-cloud-controller-manager-138 +linode__linode-cloud-controller-manager-143 +linode__linode-cloud-controller-manager-232 +linode__linode-cloud-controller-manager-78 +linode__linode-cloud-controller-manager-86 +lirantal__lockfile-lint-104 +lirantal__lockfile-lint-114 +lirantal__lockfile-lint-146 +lirantal__lockfile-lint-165 +lirantal__lockfile-lint-169 +lirantal__lockfile-lint-171 +lirantal__lockfile-lint-176 +lirantal__lockfile-lint-43 +lirantal__lockfile-lint-64 +lirantal__lockfile-lint-94 +liskhq__lisk-core-788 +litestar-org__litestar-4099 +litestar-org__litestar-4108 +litestar-org__litestar-4128 +litestar-org__polyfactory-224 +litestar-org__polyfactory-315 +litestar-org__polyfactory-319 +litestar-org__polyfactory-383 +litestar-org__polyfactory-405 +litestar-org__polyfactory-417 +litestar-org__polyfactory-420 +litestar-org__polyfactory-422 +litestar-org__polyfactory-433 +litestar-org__polyfactory-436 +litestar-org__polyfactory-468 +litestar-org__polyfactory-472 +litestar-org__polyfactory-479 +litestar-org__polyfactory-492 +litestar-org__polyfactory-499 +litestar-org__polyfactory-510 +litestar-org__polyfactory-513 +litestar-org__polyfactory-522 +litestar-org__polyfactory-587 +litestar-org__polyfactory-594 +litestar-org__polyfactory-602 +litestar-org__polyfactory-636 +litestar-org__polyfactory-643 +litestar-org__polyfactory-653 +litestar-org__polyfactory-679 +litestar-org__polyfactory-728 +livebook-dev__kino-151 +livebook-dev__kino-183 +livebook-dev__kino-231 +livebook-dev__kino-310 +livebook-dev__kino-314 +livebook-dev__kino-326 +livebook-dev__kino-33 +livebook-dev__kino-336 +livebook-dev__kino-362 +livebook-dev__kino-398 +livebook-dev__kino-465 +livepeer__go-livepeer-2222 +livepeer__go-livepeer-2267 +livepeer__go-livepeer-2775 +liveshowy__webauthn_components-71 +livewire__livewire-2223 +livewire__livewire-2229 +livewire__livewire-2350 +livewire__livewire-2386 +livewire__livewire-2413 +livewire__livewire-2434 +livewire__livewire-2481 +livewire__livewire-2505 +livewire__livewire-3596 +llk__scratch-render-776 +lo1tuma__eslint-plugin-mocha-109 +lo1tuma__eslint-plugin-mocha-114 +lo1tuma__eslint-plugin-mocha-149 +lo1tuma__eslint-plugin-mocha-23 +lo1tuma__eslint-plugin-mocha-253 +lo1tuma__eslint-plugin-mocha-255 +lo1tuma__eslint-plugin-mocha-256 +lo1tuma__eslint-plugin-mocha-260 +lo1tuma__eslint-plugin-mocha-266 +lo1tuma__eslint-plugin-mocha-28 +lo1tuma__eslint-plugin-mocha-293 +lo1tuma__eslint-plugin-mocha-304 +lo1tuma__eslint-plugin-mocha-315 +lo1tuma__eslint-plugin-mocha-316 +lo1tuma__eslint-plugin-mocha-336 +lo1tuma__eslint-plugin-mocha-369 +lo1tuma__eslint-plugin-mocha-46 +lo1tuma__eslint-plugin-mocha-58 +lo1tuma__eslint-plugin-mocha-68 +lo1tuma__eslint-plugin-mocha-81 +lo1tuma__eslint-plugin-mocha-84 +lo1tuma__eslint-plugin-mocha-94 +lo1tuma__eslint-plugin-mocha-99 +log4js-node__log4js-node-735 +log4js-node__log4js-node-755 +logaretm__vee-validate-4560 +logaretm__vee-validate-4594 +logaretm__vee-validate-4599 +logaretm__vee-validate-4607 +logaretm__vee-validate-4754 +logaretm__vee-validate-5006 +lokathor__bytemuck-256 +lomkit__laravel-rest-api-140 +lomkit__laravel-rest-api-159 +lomkit__laravel-rest-api-29 +lomkit__laravel-rest-api-64 +lomkit__laravel-rest-api-69 +lomkit__laravel-rest-api-70 +lomkit__laravel-rest-api-75 +lomkit__laravel-rest-api-89 +looplab__eventhorizon-354 +looplab__eventhorizon-366 +lorenwest__node-config-198 +lorenwest__node-config-322 +lorenwest__node-config-438 +lorenwest__node-config-459 +lorenwest__node-config-545 +lorenwest__node-config-561 +lorenwest__node-config-576 +lorenwest__node-config-640 +lorenwest__node-config-649 +lorenzwalthert__touchstone-37 +lorenzwalthert__touchstone-40 +losisin__helm-values-schema-json-227 +louislam__uptime-kuma-4322 +lovell__sharp-4036 +luin__ioredis-282 +luin__ioredis-314 +luin__ioredis-352 +luizalabs__teresa-388 +luizalabs__teresa-467 +luizalabs__teresa-470 +luizalabs__teresa-484 +luizalabs__teresa-534 +luizalabs__teresa-632 +luizalabs__teresa-635 +luizalabs__teresa-637 +lukeautry__tsoa-428 +lukeautry__tsoa-462 +lukeautry__tsoa-466 +lukeautry__tsoa-468 +lukeautry__tsoa-472 +lukeautry__tsoa-508 +lukeautry__tsoa-521 +lukeautry__tsoa-526 +lukeautry__tsoa-529 +lukeautry__tsoa-541 +lukeautry__tsoa-547 +lukeautry__tsoa-552 +lukeautry__tsoa-568 +lukeautry__tsoa-575 +lukeautry__tsoa-593 +lukeautry__tsoa-611 +lukeautry__tsoa-614 +lukeautry__tsoa-620 +lukeautry__tsoa-629 +lukeautry__tsoa-635 +lukeautry__tsoa-636 +lukeautry__tsoa-640 +lukeautry__tsoa-643 +lukeautry__tsoa-661 +lukeautry__tsoa-664 +lukeautry__tsoa-666 +lukeautry__tsoa-672 +lukeautry__tsoa-710 +lundberg__respx-254 +lxc__distrobuilder-820 +lyraproj__hiera-26 +lyraproj__hiera-28 +lyraproj__hiera-47 +lyraproj__hiera-52 +lyraproj__hiera-57 +lyraproj__hiera-80 +lz4__lz4-1442 +m3db__m3db-operator-266 +m3db__m3db-operator-271 +maas__python-libmaas-215 +maas__python-libmaas-218 +maas__python-libmaas-219 +maas__python-libmaas-221 +maas__python-libmaas-222 +maas__python-libmaas-224 +maas__python-libmaas-225 +maas__python-libmaas-227 +maas__python-libmaas-229 +macbre__analyze-css-322 +macbre__analyze-css-363 +maciejhirsz__json-rust-105 +maciejhirsz__json-rust-115 +maciejhirsz__json-rust-12 +maciejhirsz__json-rust-129 +maciejhirsz__json-rust-130 +maciejhirsz__json-rust-132 +maciejhirsz__json-rust-168 +maciejhirsz__json-rust-172 +maciejhirsz__json-rust-174 +maciejhirsz__json-rust-26 +maciejhirsz__json-rust-30 +maciejhirsz__json-rust-67 +maciejhirsz__json-rust-91 +maciejhirsz__json-rust-95 +magefile__mage-29 +magefile__mage-31 +magefile__mage-39 +magefile__mage-41 +magefile__mage-61 +mailbadger__app-1176 +mailbadger__app-1194 +mailgun__mailgun-go-157 +mailgun__mailgun-go-193 +mailgun__mailgun-go-198 +mailgun__mailgun-go-218 +mailgun__mailgun-go-249 +mailgun__mailgun-go-262 +mailgun__mailgun-go-265 +mailru__go-clickhouse-188 +mainflux__mainflux-1355 +mainflux__mainflux-1383 +mainflux__mainflux-1615 +maizzle__framework-675 +maizzle__framework-685 +maizzle__framework-765 +maizzle__framework-772 +malloydata__malloy-972 +mamba-org__quetz-633 +mandarons__icloud-drive-docker-108 +mandarons__icloud-drive-docker-109 +mandarons__icloud-drive-docker-114 +mandarons__icloud-drive-docker-118 +mandarons__icloud-drive-docker-119 +mandarons__icloud-drive-docker-162 +mandarons__icloud-drive-docker-192 +manevillef__hexx-26 +manevillef__hexx-38 +manevillef__hexx-44 +manevillef__hexx-47 +maniacallabs__bibliopixel-1100 +maniacallabs__bibliopixel-1105 +maniacallabs__bibliopixel-249 +maniacallabs__bibliopixel-634 +maniacallabs__bibliopixel-648 +maniacallabs__bibliopixel-658 +maniacallabs__bibliopixel-728 +maniacallabs__bibliopixel-759 +maniacallabs__bibliopixel-805 +maniacallabs__bibliopixel-807 +maniacallabs__bibliopixel-809 +maniacallabs__bibliopixel-814 +maniacallabs__bibliopixel-818 +maniacallabs__bibliopixel-832 +maniacallabs__bibliopixel-907 +manusa__electronim-110 +manusa__electronim-118 +manusa__electronim-129 +manusa__electronim-148 +manusa__electronim-167 +manusa__electronim-190 +manusa__electronim-193 +manusa__electronim-223 +manusa__electronim-369 +manusa__electronim-388 +manusa__electronim-43 +manusa__electronim-452 +manusa__electronim-53 +mapbox__batfish-160 +mapbox__batfish-233 +mapbox__batfish-243 +mapbox__batfish-279 +mapbox__batfish-287 +mapbox__mapbox-directions-swift-485 +mapbox__mapbox-directions-swift-490 +mapbox__mapbox-directions-swift-519 +mapbox__mapbox-directions-swift-529 +mapbox__mapbox-directions-swift-557 +mapbox__mapbox-directions-swift-583 +mapbox__mapbox-directions-swift-616 +mapbox__mapbox-directions-swift-623 +mapbox__mapbox-directions-swift-647 +mapbox__mapbox-directions-swift-688 +mapbox__mapbox-directions-swift-691 +mapbox__mapbox-directions-swift-728 +mapbox__mapbox-sdk-js-247 +mapbox__mapbox-sdk-js-252 +mapbox__mapbox-sdk-js-267 +mapbox__mapbox-sdk-js-269 +mapbox__mapbox-sdk-js-373 +mapbox__mapbox-sdk-js-390 +mapbox__mapbox-sdk-js-479 +mapbox__mapbox-sdk-py-136 +mapbox__mapbox-sdk-py-77 +mapbox__mapbox-sdk-py-9 +mapbox__mr-ui-148 +mapbox__mr-ui-192 +mapbox__mr-ui-193 +mapbox__mr-ui-20 +mapbox__mr-ui-34 +mapbox__mr-ui-77 +maproulette__maproulette3-1989 +maragudk__gomponents-126 +maragudk__gomponents-136 +maragudk__gomponents-181 +maragudk__gomponents-202 +maragudk__gomponents-25 +maragudk__gomponents-46 +maragudk__gomponents-86 +marcincichocki__breach-protocol-autosolver-120 +marcinorlowski__laravel-api-response-builder-257 +marcinorlowski__laravel-api-response-builder-264 +marcoieni__release-plz-126 +marcoieni__release-plz-1588 +marcoieni__release-plz-1765 +marcoieni__release-plz-1778 +marcoieni__release-plz-349 +marcoieni__release-plz-81 +marcoieni__release-plz-96 +marigold-ui__marigold-2025 +marigold-ui__marigold-2116 +marigold-ui__marigold-2333 +marigold-ui__marigold-2399 +marigold-ui__marigold-2610 +marigold-ui__marigold-2824 +marigold-ui__marigold-2826 +markbates__goth-558 +markedjs__marked-3172 +marketsquare__robotframework-robocop-1027 +marketsquare__robotframework-robocop-1030 +marketsquare__robotframework-robocop-1036 +marketsquare__robotframework-robocop-1079 +marketsquare__robotframework-robocop-1081 +marketsquare__robotframework-robocop-1094 +marketsquare__robotframework-robocop-1301 +marketsquare__robotframework-robocop-1322 +marketsquare__robotframework-robocop-1326 +marketsquare__robotframework-robocop-1329 +marketsquare__robotframework-robocop-1374 +marketsquare__robotframework-robocop-1397 +marketsquare__robotframework-robocop-755 +marketsquare__robotframework-robocop-775 +marketsquare__robotframework-robocop-802 +markus-wa__demoinfocs-golang-201 +marmelroy__phonenumberkit-652 +marmelroy__phonenumberkit-661 +marmelroy__phonenumberkit-854 +marp-team__marp-core-383 +marp-team__marp-core-384 +marp-team__marp-vscode-221 +marp-team__marp-vscode-260 +marp-team__marp-vscode-269 +marp-team__marp-vscode-285 +marp-team__marp-vscode-384 +marp-team__marp-vscode-412 +marp-team__marp-vscode-446 +marp-team__marp-vscode-510 +marpple__fxts-23 +marpple__fxts-25 +marpple__fxts-30 +marpple__fxts-48 +marpple__fxts-88 +marpple__fxts-89 +marpple__fxts-90 +marshmallow-code__apispec-365 +marshmallow-code__apispec-904 +martin-helmich__typo3-typoscript-lint-111 +martin-helmich__typo3-typoscript-lint-117 +martin-helmich__typo3-typoscript-lint-124 +martinfleis__momepy-112 +martinfleis__momepy-113 +martinfleis__momepy-148 +martinfleis__momepy-235 +martinfleis__momepy-280 +martinfleis__momepy-298 +martinfleis__momepy-94 +martinohmann__hcl-rs-273 +martinohmann__hcl-rs-295 +martinohmann__hcl-rs-429 +martinthoma__flake8-simplify-104 +martinthoma__flake8-simplify-109 +martinthoma__flake8-simplify-110 +martinthoma__flake8-simplify-112 +martinthoma__flake8-simplify-121 +martinthoma__flake8-simplify-122 +martinthoma__flake8-simplify-124 +martinthoma__flake8-simplify-132 +martinthoma__flake8-simplify-147 +martinthoma__flake8-simplify-173 +martinthoma__flake8-simplify-47 +martinthoma__flake8-simplify-90 +martinthoma__flake8-simplify-93 +martinthoma__flake8-simplify-94 +martinthoma__flake8-simplify-96 +martinthoma__flake8-simplify-97 +maskingtechnology__jitar-180 +maskingtechnology__jitar-199 +maskingtechnology__jitar-243 +maskingtechnology__jitar-294 +maskingtechnology__jitar-319 +maskingtechnology__jitar-395 +maskingtechnology__jitar-428 +maskingtechnology__jitar-430 +maskingtechnology__jitar-615 +masterminds__semver-186 +matchms__matchms-215 +matchms__matchms-255 +matchms__matchms-265 +matchms__matchms-414 +matchms__matchms-543 +matchms__matchms-628 +matchms__matchms-686 +matchms__matchms-809 +matejkob__swift-spyable-101 +matejkob__swift-spyable-130 +matejkob__swift-spyable-133 +matejkob__swift-spyable-14 +matejkob__swift-spyable-16 +matejkob__swift-spyable-51 +matejkob__swift-spyable-64 +matejkob__swift-spyable-69 +matejkob__swift-spyable-83 +matejkob__swift-spyable-85 +matejkob__swift-spyable-93 +materials-consortia__optimade-python-tools-1001 +materials-consortia__optimade-python-tools-1134 +materials-consortia__optimade-python-tools-142 +materials-consortia__optimade-python-tools-1844 +materials-consortia__optimade-python-tools-211 +materials-consortia__optimade-python-tools-221 +materials-consortia__optimade-python-tools-2224 +materials-consortia__optimade-python-tools-2250 +materials-consortia__optimade-python-tools-253 +materials-consortia__optimade-python-tools-279 +materials-consortia__optimade-python-tools-431 +materials-consortia__optimade-python-tools-484 +materials-consortia__optimade-python-tools-547 +materials-consortia__optimade-python-tools-582 +materials-consortia__optimade-python-tools-586 +materials-consortia__optimade-python-tools-796 +materials-consortia__optimade-python-tools-813 +materials-consortia__optimade-python-tools-903 +materials-consortia__optimade-python-tools-914 +materialsproject__custodian-183 +materialsproject__custodian-243 +materialsproject__custodian-381 +mateusjunges__laravel-kafka-136 +mateusjunges__laravel-kafka-223 +mateusjunges__laravel-kafka-249 +mateusjunges__laravel-kafka-70 +mateusjunges__laravel-kafka-76 +mathnet__mathnet-numerics-1072 +matrix-org__dendrite-3355 +matrixorigin__matrixcube-391 +matrixorigin__matrixcube-421 +matrixorigin__matrixcube-423 +matrixorigin__matrixcube-484 +matrixorigin__matrixcube-489 +matrixorigin__matrixcube-498 +matrixorigin__matrixcube-515 +matrixorigin__matrixcube-544 +matrixorigin__matrixcube-557 +matrixorigin__matrixcube-569 +matrixorigin__matrixcube-607 +matrixorigin__matrixone-20354 +mattallty__caporal.js-140 +mattallty__caporal.js-141 +mattallty__caporal.js-150 +mattallty__caporal.js-168 +matteogabriele__vue-gtag-618 +matter-labs__era-test-node-360 +matter-labs__era-test-node-476 +mattermost__mattermost-plugin-github-336 +mattgodbolt__compiler-explorer-1431 +matthewwithanm__python-markdownify-202 +matthewwithanm__python-markdownify-214 +matthewwithanm__python-markdownify-230 +maxcountryman__flask-login-746 +maxdesiatov__corexlsx-109 +maxdesiatov__corexlsx-122 +maxdesiatov__corexlsx-135 +maxdesiatov__corexlsx-139 +maxdesiatov__corexlsx-143 +maxgraph__maxgraph-286 +maxgraph__maxgraph-297 +maxgraph__maxgraph-359 +maxgraph__maxgraph-365 +maxgraph__maxgraph-379 +maxgraph__maxgraph-380 +maxgraph__maxgraph-443 +maxi-blocks__maxi-blocks-5175 +maxi-blocks__maxi-blocks-5934 +maxnowack__signaldb-1473 +maxnowack__signaldb-794 +maypok86__otter-102 +maypok86__otter-42 +maypok86__otter-60 +maypok86__otter-64 +maypok86__otter-65 +maypok86__otter-67 +mbrt__gmailctl-105 +mbrt__gmailctl-165 +mbrt__gmailctl-239 +mbrt__gmailctl-245 +mbrt__gmailctl-409 +mbrt__gmailctl-75 +mbrt__gmailctl-78 +mbrt__gmailctl-80 +mccutchen__go-httpbin-199 +mcollina__autocannon-220 +mcollina__autocannon-231 +mcollina__autocannon-267 +mdlayher__netlink-185 +mdx-js__mdx-analyzer-364 +mdx-js__mdx-analyzer-365 +mdx-js__mdx-analyzer-387 +mdx-js__mdx-analyzer-398 +mdx-js__mdx-analyzer-401 +mdx-js__mdx-analyzer-402 +mdx-js__mdx-analyzer-410 +mdx-js__mdx-analyzer-486 +mdx-js__mdx-analyzer-488 +mdx-js__mdx-analyzer-491 +mdx-js__mdx-analyzer-507 +medly__medly-components-726 +medly__medly-components-729 +megaease__easegress-579 +meggart__diskarrays.jl-100 +meggart__diskarrays.jl-105 +meggart__diskarrays.jl-107 +meggart__diskarrays.jl-134 +meggart__diskarrays.jl-151 +meggart__diskarrays.jl-156 +meggart__diskarrays.jl-166 +meggart__diskarrays.jl-169 +meggart__diskarrays.jl-193 +meggart__diskarrays.jl-194 +meggart__diskarrays.jl-228 +meggart__diskarrays.jl-232 +meggart__diskarrays.jl-260 +meggart__diskarrays.jl-264 +meggart__diskarrays.jl-280 +meggart__diskarrays.jl-33 +meggart__diskarrays.jl-52 +meggart__diskarrays.jl-62 +mehcode__config-rs-106 +mehcode__config-rs-184 +mehcode__config-rs-185 +mehcode__config-rs-189 +mehcode__config-rs-202 +mehcode__config-rs-207 +mehcode__config-rs-217 +mehcode__config-rs-255 +mehcode__config-rs-292 +mehcode__config-rs-316 +mehcode__config-rs-354 +mehcode__config-rs-59 +meilisearch__meilisearch-1174 +meilisearch__meilisearch-1184 +meilisearch__meilisearch-1469 +meilisearch__meilisearch-1746 +meilisearch__meilisearch-1878 +meilisearch__meilisearch-2006 +meilisearch__meilisearch-2007 +meilisearch__meilisearch-2008 +meilisearch__meilisearch-2025 +meilisearch__meilisearch-2054 +meilisearch__meilisearch-2524 +meilisearch__meilisearch-2579 +meilisearch__meilisearch-2678 +meilisearch__meilisearch-2819 +meilisearch__meilisearch-2845 +meilisearch__meilisearch-2922 +meilisearch__meilisearch-3122 +meilisearch__meilisearch-3136 +meilisearch__meilisearch-3164 +meilisearch__meilisearch-3175 +meilisearch__meilisearch-3281 +meilisearch__meilisearch-530 +meilisearch__meilisearch-594 +meilisearch__meilisearch-640 +meilisearch__strapi-plugin-meilisearch-1011 +meilisearch__strapi-plugin-meilisearch-539 +meilisearch__strapi-plugin-meilisearch-818 +meilisearch__strapi-plugin-meilisearch-850 +meilisearch__strapi-plugin-meilisearch-916 +meilisearch__strapi-plugin-meilisearch-998 +melt-ui__melt-ui-370 +melt-ui__melt-ui-372 +meltano__sdk-1036 +meltano__sdk-1109 +meltano__sdk-1114 +meltano__sdk-1172 +meltano__sdk-1174 +meltano__sdk-1175 +meltano__sdk-1283 +meltano__sdk-1385 +meltano__sdk-1672 +meltano__sdk-1826 +meltano__sdk-1835 +meltano__sdk-1864 +meltano__sdk-1880 +meltano__sdk-1881 +meltano__sdk-2006 +meltano__sdk-2107 +meltano__sdk-2136 +meltano__sdk-2144 +meltano__sdk-2245 +meltano__sdk-2248 +meltano__sdk-2438 +meltano__sdk-2637 +meltano__sdk-2770 +meltano__sdk-2829 +meltano__sdk-2830 +meltano__sdk-3019 +meltano__sdk-3020 +meltano__sdk-3091 +meltano__sdk-732 +meltano__sdk-768 +mem0ai__mem0-2774 +memorysafety__sudo-rs-101 +mercadona__rele-160 +mercari__tortoise-284 +mercari__tortoise-332 +mercurius-js__mercurius-570 +mercurius-js__mercurius-595 +mercurius-js__mercurius-676 +mercurius-js__mercurius-705 +mercurius-js__mercurius-852 +mercurius-js__mercurius-893 +mercurius-js__mercurius-935 +mercurius-js__mercurius-992 +metal3-io__baremetal-operator-1184 +metal3-io__baremetal-operator-1328 +metal3-io__baremetal-operator-1453 +metal3-io__baremetal-operator-2174 +metal3-io__baremetal-operator-2190 +metal3-io__baremetal-operator-2191 +metal3-io__baremetal-operator-463 +metal3-io__baremetal-operator-579 +metal3-io__baremetal-operator-602 +metal3-io__baremetal-operator-762 +metal3-io__baremetal-operator-916 +metal3-io__baremetal-operator-981 +metal3-io__baremetal-operator-985 +metallb__metallb-2337 +mgechev__revive-1023 +mgechev__revive-1024 +mgechev__revive-1030 +mgechev__revive-1046 +mgechev__revive-1048 +mgechev__revive-1049 +mgechev__revive-1051 +mgechev__revive-1085 +mgechev__revive-1092 +mgechev__revive-1101 +mgechev__revive-1114 +mgechev__revive-1129 +mgechev__revive-1154 +mgechev__revive-1175 +mgechev__revive-1208 +mgechev__revive-1209 +mgechev__revive-1213 +mgechev__revive-1214 +mgechev__revive-1229 +mgechev__revive-1249 +mgechev__revive-1268 +mgechev__revive-1286 +mgechev__revive-1289 +mgechev__revive-1325 +mgechev__revive-1327 +mgechev__revive-1351 +mgechev__revive-1360 +mgechev__revive-1366 +mgechev__revive-1370 +mgechev__revive-406 +mgechev__revive-411 +mgechev__revive-413 +mgechev__revive-415 +mgechev__revive-425 +mgechev__revive-430 +mgechev__revive-443 +mgechev__revive-477 +mgechev__revive-504 +mgechev__revive-511 +mgechev__revive-526 +mgechev__revive-530 +mgechev__revive-536 +mgechev__revive-543 +mgechev__revive-551 +mgechev__revive-557 +mgechev__revive-584 +mgechev__revive-587 +mgechev__revive-611 +mgechev__revive-616 +mgechev__revive-623 +mgechev__revive-628 +mgechev__revive-638 +mgechev__revive-665 +mgechev__revive-692 +mgechev__revive-694 +mgechev__revive-703 +mgechev__revive-706 +mgechev__revive-708 +mgechev__revive-719 +mgechev__revive-742 +mgechev__revive-745 +mgechev__revive-746 +mgechev__revive-756 +mgechev__revive-757 +mgechev__revive-791 +mgechev__revive-793 +mgechev__revive-797 +mgechev__revive-799 +mgechev__revive-802 +mgechev__revive-815 +mgechev__revive-827 +mgechev__revive-829 +mgechev__revive-840 +mgechev__revive-857 +mgechev__revive-866 +mgechev__revive-868 +mgechev__revive-869 +mgechev__revive-870 +mgechev__revive-876 +mgechev__revive-881 +mgechev__revive-889 +mgechev__revive-895 +mgechev__revive-900 +mgechev__revive-921 +mgechev__revive-927 +mgechev__revive-939 +mgechev__revive-943 +mgechev__revive-954 +mgechev__revive-964 +mgechev__revive-966 +mgechev__revive-981 +mgechev__revive-986 +mhanberg__temple-119 +mhanberg__temple-135 +mhanberg__temple-243 +mhanberg__temple-245 +mhanberg__temple-246 +mhanberg__temple-261 +mheap__pin-github-action-113 +mheap__pin-github-action-142 +mheap__pin-github-action-150 +mheap__pin-github-action-158 +mheap__pin-github-action-46 +mheap__pin-github-action-75 +mholt__papaparse-1086 +mholt__papaparse-239 +mholt__papaparse-404 +mholt__papaparse-554 +mholt__papaparse-602 +mholt__papaparse-621 +mholt__papaparse-637 +mholt__papaparse-879 +mholt__papaparse-919 +michalkvasnicak__aws-lambda-graphql-52 +michalkvasnicak__aws-lambda-graphql-63 +michalkvasnicak__aws-lambda-graphql-92 +michallytek__type-graphql-1309 +michallytek__type-graphql-795 +michallytek__type-graphql-806 +michelnivard__gptstudio-102 +michelnivard__gptstudio-201 +michelnivard__gptstudio-223 +microcosm-cc__bluemonday-108 +microcosm-cc__bluemonday-121 +microcosm-cc__bluemonday-123 +microcosm-cc__bluemonday-136 +microcosm-cc__bluemonday-162 +microcosm-cc__bluemonday-172 +microcosm-cc__bluemonday-175 +microcosm-cc__bluemonday-89 +microformats__php-mf2-248 +microformats__php-mf2-250 +microformats__php-mf2-255 +micromdm__micromdm-793 +microsoft__applicationinsights-node.js-1090 +microsoft__applicationinsights-node.js-1337 +microsoft__applicationinsights-node.js-597 +microsoft__applicationinsights-node.js-672 +microsoft__applicationinsights-node.js-692 +microsoft__applicationinsights-node.js-696 +microsoft__applicationinsights-node.js-711 +microsoft__applicationinsights-node.js-720 +microsoft__applicationinsights-node.js-728 +microsoft__botbuilder-python-1957 +microsoft__botbuilder-python-2143 +microsoft__botbuilder-python-2216 +microsoft__fluent-ui-react-2060 +microsoft__fluent-ui-react-2087 +microsoft__fluent-ui-react-2192 +microsoft__fluent-ui-react-2208 +microsoft__fluent-ui-react-2287 +microsoft__go-mssqldb-263 +microsoft__griffel-100 +microsoft__griffel-110 +microsoft__griffel-189 +microsoft__griffel-260 +microsoft__griffel-289 +microsoft__griffel-292 +microsoft__griffel-364 +microsoft__griffel-86 +microsoft__inshellisense-114 +microsoft__inshellisense-118 +microsoft__inshellisense-193 +microsoft__inshellisense-212 +microsoft__inshellisense-222 +microsoft__kiota-3798 +microsoft__kiota-3801 +microsoft__kiota-3904 +microsoft__kiota-4578 +microsoft__kiota-4646 +microsoft__kiota-4924 +microsoft__kiota-5024 +microsoft__kiota-6287 +microsoft__playwright-python-2905 +microsoft__qsharp-1118 +microsoft__qsharp-2137 +microsoft__qsharp-2217 +microsoft__qsharp-2421 +microsoft__react-native-gallery-475 +microsoft__react-native-gallery-506 +microsoft__react-native-test-app-1231 +microsoft__tolerant-php-parser-374 +microsoft__tolerant-php-parser-382 +microsoft__tolerant-php-parser-396 +microsoft__typescript-go-1173 +microsoft__typescript-go-1258 +microsoft__typescript-go-1403 +microsoft__typescript-go-510 +microsoft__typescript-go-841 +microsoft__typescript-go-850 +microsoft__vscode-edge-devtools-1979 +microsoft__vscode-vsce-1040 +microsoft__vscode-vsce-1050 +microsoft__vscode-vsce-1058 +microsoft__vscode-vsce-1062 +microsoft__vscode-vsce-1065 +microsoft__vscode-vsce-1075 +microsoft__vscode-vsce-1078 +microsoft__vscode-vsce-1100 +microsoft__vscode-vsce-598 +microsoft__vscode-vsce-669 +microsoft__vscode-vsce-676 +microsoft__vscode-vsce-693 +microsoft__vscode-vsce-735 +microsoft__vscode-vsce-753 +microsoft__vscode-vsce-809 +microsoft__vscode-vsce-879 +microsoft__vscode-vsce-887 +microsoft__vscode-vsce-912 +microsoft__vscode-vsce-918 +microsoft__vscode-vsce-919 +microsoft__vscode-vsce-921 +microsoftgraph__microsoft-graph-explorer-v4-2342 +microsoftgraph__microsoft-graph-explorer-v4-2478 +mie-lab__trackintel-137 +mie-lab__trackintel-148 +mie-lab__trackintel-252 +mie-lab__trackintel-274 +mie-lab__trackintel-296 +mie-lab__trackintel-298 +mie-lab__trackintel-311 +mie-lab__trackintel-322 +mie-lab__trackintel-331 +mie-lab__trackintel-344 +mie-lab__trackintel-359 +mie-lab__trackintel-360 +mie-lab__trackintel-373 +mie-lab__trackintel-376 +mie-lab__trackintel-384 +mie-lab__trackintel-588 +miekg__dns-1122 +miekg__dns-1174 +miekg__dns-1211 +miekg__dns-1219 +miekg__dns-1322 +miekg__dns-1618 +miekg__dns-1627 +migorithm__duva-618 +migorithm__duva-620 +migorithm__duva-627 +migorithm__duva-683 +mikedh__trimesh-2312 +mikedh__trimesh-2363 +mikefarah__yq-559 +mila-udem__fuel-118 +mila-udem__fuel-186 +mila-udem__fuel-192 +mila-udem__fuel-214 +mila-udem__fuel-217 +mila-udem__fuel-378 +mill1000__midea-msmart-123 +mill1000__midea-msmart-132 +mill1000__midea-msmart-165 +mill1000__midea-msmart-172 +mill1000__midea-msmart-180 +mill1000__midea-msmart-181 +mill1000__midea-msmart-189 +mill1000__midea-msmart-93 +mill1000__midea-msmart-99 +milvus-io__milvus-sdk-go-274 +milvus-io__milvus-sdk-go-295 +milvus-io__milvus-sdk-go-527 +minio__minio-go-1716 +minio__minio-go-2041 +minio__minio-py-580 +minio__minio-py-581 +mirage__awa-ssh-63 +mirage__awa-ssh-66 +mirage__decompress-108 +mirage__decompress-158 +mirage__decompress-98 +mirage__ocaml-rpc-153 +mirumee__ariadne-19 +mirumee__ariadne-23 +mirumee__ariadne-24 +mirumee__ariadne-codegen-110 +mirumee__ariadne-codegen-112 +mirumee__ariadne-codegen-126 +mirumee__ariadne-codegen-159 +mirumee__ariadne-codegen-166 +mirumee__ariadne-codegen-196 +mirumee__ariadne-codegen-203 +mirumee__ariadne-codegen-218 +mirumee__ariadne-codegen-221 +mirumee__ariadne-codegen-222 +mirumee__ariadne-codegen-223 +mirumee__ariadne-codegen-242 +mirumee__ariadne-codegen-281 +mirumee__ariadne-codegen-292 +mirumee__ariadne-codegen-75 +mirumee__ariadne-codegen-96 +mirumee__saleor-dashboard-109 +mirumee__saleor-dashboard-219 +mirumee__saleor-dashboard-277 +mirumee__saleor-dashboard-289 +mirumee__saleor-dashboard-471 +misawa__xq-101 +misawa__xq-104 +misawa__xq-110 +misawa__xq-113 +misawa__xq-121 +misawa__xq-158 +misawa__xq-16 +misawa__xq-26 +misawa__xq-49 +misawa__xq-57 +misawa__xq-62 +misawa__xq-68 +misawa__xq-87 +misskey-dev__mfm.js-77 +mit-ll-responsible-ai__hydra-zen-104 +mit-ll-responsible-ai__hydra-zen-172 +mit-ll-responsible-ai__hydra-zen-366 +mit-ll-responsible-ai__hydra-zen-401 +mitchellh__mapstructure-135 +mitchellh__mapstructure-141 +mitchellh__mapstructure-168 +mitchellh__mapstructure-194 +mitchellh__mapstructure-196 +mitchellh__mapstructure-203 +mitchellh__mapstructure-205 +mitchellh__mapstructure-232 +mitmproxy__pdoc-806 +mitmproxy__pdoc-813 +mitsuhiko__insta-346 +mitsuhiko__insta-726 +mitsuhiko__insta-730 +mitsuhiko__insta-759 +mitsuhiko__insta-762 +mitsuhiko__minijinja-320 +mitsuhiko__minijinja-347 +mitsuhiko__minijinja-519 +mitsuhiko__minijinja-552 +mitsuhiko__minijinja-554 +mitsuhiko__minijinja-565 +mitsuhiko__minijinja-569 +mitsuhiko__minijinja-579 +mitsuhiko__minijinja-580 +mitsuhiko__minijinja-584 +mitsuhiko__minijinja-630 +mitsuhiko__minijinja-657 +mitsuhiko__minijinja-674 +mitsuhiko__minijinja-677 +mitsuhiko__minijinja-69 +mitsuhiko__minijinja-714 +mitsuhiko__minijinja-742 +mitsuhiko__minijinja-759 +mitsuhiko__minijinja-764 +mitsuhiko__minijinja-778 +mitsuhiko__minijinja-794 +mitsuhiko__redis-rs-136 +mitsuhiko__redis-rs-556 +miurahr__aqtinstall-400 +mkdocs__mkdocs-2710 +mkdocs__mkdocs-2927 +mkdocs__mkdocs-3395 +mlange-42__arche-113 +mlange-42__arche-178 +mlange-42__arche-23 +mlange-42__arche-251 +mlange-42__arche-26 +mlange-42__arche-264 +mlange-42__arche-42 +mlange-42__arche-78 +mlange-42__arche-95 +mlaursen__react-md-588 +mlaursen__react-md-790 +mlaursen__react-md-828 +mlaursen__react-md-863 +mlocati__ip-lib-68 +mlocati__ip-lib-76 +mlocati__ip-lib-78 +mlocati__ip-lib-91 +mmcdole__gofeed-240 +mmcdole__gofeed-259 +mmcloughlin__avo-123 +mmcloughlin__avo-127 +mmcloughlin__avo-81 +mne-tools__mne-bids-1258 +mne-tools__mne-bids-1353 +mne-tools__mne-bids-1362 +mne-tools__mne-bids-1364 +mochajs__mocha-4771 +mochajs__mocha-4829 +mochajs__mocha-5231 +modernizr__modernizr-2582 +modernizr__modernizr-2607 +modernizr__modernizr-2610 +modernizr__modernizr-2708 +modflowpy__flopy-2108 +modflowpy__flopy-2318 +modin-project__modin-6615 +modin-project__modin-6769 +modin-project__modin-6788 +modin-project__modin-6919 +modin-project__modin-7330 +modin-project__modin-7394 +modin-project__modin-7395 +modin-project__modin-7430 +modin-project__modin-7469 +modin-project__modin-7491 +modin-project__modin-7496 +modin-project__modin-7502 +modin-project__modin-7522 +modin-project__modin-7529 +modin-project__modin-7535 +modin-project__modin-7554 +modin-project__modin-7561 +modin-project__modin-7577 +modin-project__modin-7579 +modin-project__modin-7597 +moggers87__salmon-113 +moggers87__salmon-127 +moggers87__salmon-129 +moggers87__salmon-140 +moggers87__salmon-63 +moira-alert__moira-1075 +moment__luxon-1071 +moment__luxon-1173 +moment__luxon-1225 +moment__luxon-1308 +moment__luxon-1369 +moment__luxon-1390 +moment__luxon-1391 +moment__luxon-1404 +moment__luxon-1437 +moment__luxon-1467 +moment__luxon-1498 +moment__luxon-1539 +moment__luxon-1685 +moment__luxon-660 +moment__luxon-722 +moment__luxon-737 +moment__luxon-755 +moment__luxon-756 +moment__luxon-758 +moment__luxon-761 +moment__luxon-762 +moment__luxon-794 +moment__luxon-797 +moment__luxon-798 +moment__luxon-811 +moment__luxon-872 +moment__luxon-887 +moment__luxon-889 +moment__luxon-926 +moment__luxon-966 +mondeja__mkdocs-include-markdown-plugin-164 +mondeja__mkdocs-include-markdown-plugin-177 +mondeja__mkdocs-include-markdown-plugin-184 +mondeja__mkdocs-include-markdown-plugin-2 +mondeja__mkdocs-include-markdown-plugin-214 +mondeja__mkdocs-include-markdown-plugin-233 +mondeja__mkdocs-include-markdown-plugin-258 +mondeja__mkdocs-include-markdown-plugin-46 +mondeja__mkdocs-include-markdown-plugin-51 +mondeja__mkdocs-include-markdown-plugin-53 +mondeja__mkdocs-include-markdown-plugin-79 +mondeja__mkdocs-include-markdown-plugin-93 +mondoohq__cnquery-1937 +mondoohq__cnquery-4726 +mondoohq__cnquery-5220 +monetr__monetr-2479 +moov-io__ach-156 +moov-io__customers-177 +moov-io__customers-179 +moov-io__customers-184 +moov-io__customers-204 +moov-io__customers-209 +moov-io__customers-221 +moov-io__customers-236 +moov-io__customers-240 +moov-io__customers-246 +moov-io__customers-250 +moov-io__customers-260 +moov-io__customers-275 +more-itertools__more-itertools-1028 +more-itertools__more-itertools-412 +more-itertools__more-itertools-484 +more-itertools__more-itertools-566 +more-itertools__more-itertools-689 +more-itertools__more-itertools-828 +more-itertools__more-itertools-845 +more-itertools__more-itertools-855 +more-itertools__more-itertools-892 +more-itertools__more-itertools-903 +more-itertools__more-itertools-926 +moscajs__aedes-622 +moscajs__aedes-720 +mosdef-hub__mbuild-1007 +mosdef-hub__mbuild-904 +mosn__layotto-574 +mosn__layotto-605 +mosn__layotto-641 +mosn__layotto-701 +mostjs__core-179 +mostjs__core-181 +mostjs__core-183 +mostjs__core-192 +mostjs__core-196 +motdotla__node-lambda-446 +motdotla__node-lambda-553 +motdotla__node-lambda-701 +motemen__gore-178 +mozilla-services__cliquet-101 +mozilla-services__cliquet-201 +mozilla-services__cliquet-203 +mozilla-services__cliquet-415 +mozilla-services__cliquet-418 +mozilla-services__cliquet-422 +mozilla-services__cliquet-461 +mozilla-services__cliquet-534 +mozilla-services__cliquet-542 +mozilla-services__cliquet-568 +mozilla-services__cliquet-604 +mozilla-services__cliquet-680 +mozilla-services__react-jsonschema-form-1000 +mozilla-services__react-jsonschema-form-1034 +mozilla-services__react-jsonschema-form-1142 +mozilla-services__react-jsonschema-form-1144 +mozilla-services__react-jsonschema-form-1147 +mozilla-services__react-jsonschema-form-1152 +mozilla-services__react-jsonschema-form-1194 +mozilla-services__react-jsonschema-form-1220 +mozilla-services__react-jsonschema-form-1234 +mozilla-services__react-jsonschema-form-1269 +mozilla-services__react-jsonschema-form-1277 +mozilla-services__react-jsonschema-form-1287 +mozilla-services__react-jsonschema-form-1313 +mozilla-services__react-jsonschema-form-18 +mozilla-services__react-jsonschema-form-26 +mozilla-services__react-jsonschema-form-285 +mozilla-services__react-jsonschema-form-348 +mozilla-services__react-jsonschema-form-378 +mozilla-services__react-jsonschema-form-431 +mozilla-services__react-jsonschema-form-451 +mozilla-services__react-jsonschema-form-456 +mozilla-services__react-jsonschema-form-521 +mozilla-services__react-jsonschema-form-525 +mozilla-services__react-jsonschema-form-537 +mozilla-services__react-jsonschema-form-62 +mozilla-services__react-jsonschema-form-65 +mozilla-services__react-jsonschema-form-661 +mozilla-services__react-jsonschema-form-684 +mozilla__bleach-691 +mozilla__cargo-vet-225 +mozilla__cargo-vet-234 +mozilla__cargo-vet-257 +mozilla__cargo-vet-310 +mozilla__cargo-vet-311 +mozilla__cargo-vet-323 +mozilla__cargo-vet-324 +mozilla__cargo-vet-348 +mozilla__cargo-vet-368 +mozilla__cargo-vet-389 +mozilla__cargo-vet-405 +mozilla__cargo-vet-492 +mozilla__cargo-vet-500 +mozilla__cargo-vet-501 +mozilla__cargo-vet-584 +mozilla__cargo-vet-588 +mozilla__cargo-vet-619 +mozilla__cargo-vet-621 +mozilla__cargo-vet-648 +mozilla__mozdownload-678 +mozilla__mozdownload-709 +mozilla__node-convict-138 +mozilla__node-convict-190 +mozilla__node-convict-206 +mozilla__node-convict-215 +mozilla__node-convict-223 +mozilla__node-convict-234 +mozilla__node-convict-246 +mozilla__node-convict-248 +mozilla__node-convict-54 +mozilla__nunjucks-1017 +mozilla__nunjucks-1034 +mozilla__nunjucks-1049 +mozilla__nunjucks-1090 +mozilla__nunjucks-1111 +mozilla__nunjucks-1172 +mozilla__nunjucks-1189 +mozilla__nunjucks-1196 +mozilla__nunjucks-1197 +mozilla__nunjucks-1276 +mozilla__nunjucks-1279 +mozilla__nunjucks-1301 +mozilla__nunjucks-1302 +mozilla__nunjucks-1309 +mozilla__nunjucks-1330 +mozilla__nunjucks-448 +mozilla__nunjucks-634 +mozilla__nunjucks-653 +mozilla__nunjucks-667 +mozilla__nunjucks-836 +mozilla__nunjucks-849 +mozilla__nunjucks-990 +mpmath__mpmath-689 +mpmath__mpmath-690 +mpmath__mpmath-711 +mpmath__mpmath-713 +mpmath__mpmath-777 +mpmath__mpmath-778 +mpmath__mpmath-785 +mpmath__mpmath-802 +mpmath__mpmath-803 +mpmath__mpmath-819 +mpmath__mpmath-821 +mpmath__mpmath-826 +mpmath__mpmath-828 +mpmath__mpmath-831 +mpmath__mpmath-847 +mpmath__mpmath-854 +mpmath__mpmath-857 +mpmath__mpmath-859 +mpmath__mpmath-864 +mpmath__mpmath-867 +mpmath__mpmath-870 +mpmath__mpmath-881 +mpmath__mpmath-889 +mpmath__mpmath-902 +mpmath__mpmath-903 +mpmath__mpmath-904 +mpmath__mpmath-916 +mpmath__mpmath-922 +mpmath__mpmath-925 +mpmath__mpmath-926 +mpmath__mpmath-935 +mpmath__mpmath-944 +mpmath__mpmath-949 +mpmath__mpmath-966 +mr-linch__go-tg-115 +mr-linch__go-tg-89 +mr-linch__go-tg-90 +mr-linch__go-tg-95 +mransan__ocaml-protoc-188 +mransan__ocaml-protoc-198 +mransan__ocaml-protoc-202 +mransan__ocaml-protoc-209 +mrparkers__terraform-provider-keycloak-233 +mrparkers__terraform-provider-keycloak-507 +msgpack__msgpack-python-331 +msgpack__msgpack-python-394 +msz__hammox-115 +msz__hammox-13 +msz__hammox-36 +msz__hammox-42 +mtarld__api-platform-ms-bundle-85 +mtlynch__picoshare-563 +mtlynch__picoshare-66 +mui-org__material-ui-pickers-1208 +mvdan__gofumpt-318 +mvdan__sh-1062 +mvdan__sh-366 +mwouts__jupytext-282 +mwouts__jupytext-360 +mwouts__jupytext-386 +myelin-ai__mockiato-68 +myelin-ai__mockiato-70 +myremylar__pygame_gui-315 +myremylar__pygame_gui-322 +myremylar__pygame_gui-324 +myremylar__pygame_gui-327 +myremylar__pygame_gui-339 +myremylar__pygame_gui-426 +myremylar__pygame_gui-439 +myremylar__pygame_gui-453 +myremylar__pygame_gui-482 +myremylar__pygame_gui-518 +myremylar__pygame_gui-529 +myremylar__pygame_gui-548 +myremylar__pygame_gui-561 +myremylar__pygame_gui-570 +myremylar__pygame_gui-580 +myremylar__pygame_gui-599 +myremylar__pygame_gui-646 +myremylar__pygame_gui-647 +myremylar__pygame_gui-648 +myremylar__pygame_gui-649 +myremylar__pygame_gui-650 +myremylar__pygame_gui-651 +myremylar__pygame_gui-689 +mzgoddard__preact-render-spy-28 +mzgoddard__preact-render-spy-33 +mzgoddard__preact-render-spy-37 +mzgoddard__preact-render-spy-49 +mzgoddard__preact-render-spy-51 +mzgoddard__preact-render-spy-53 +mzgoddard__preact-render-spy-59 +mzgoddard__preact-render-spy-61 +mzgoddard__preact-render-spy-65 +nabeelio__phpvms-1725 +nacos-group__nacos-sdk-go-151 +nacos-group__nacos-sdk-go-170 +nacos-group__nacos-sdk-go-287 +nacos-group__nacos-sdk-go-538 +nacos-group__nacos-sdk-go-624 +nacos-group__nacos-sdk-go-699 +nacos-group__nacos-sdk-go-737 +nadar__quill-delta-parser-17 +nadar__quill-delta-parser-71 +nadar__quill-delta-parser-75 +nadar__quill-delta-parser-81 +nadar__quill-delta-parser-88 +nadar__quill-delta-parser-97 +nand2tetris__web-ide-465 +nand2tetris__web-ide-468 +nangohq__nango-1000 +nangohq__nango-868 +nanovms__ops-1006 +nanovms__ops-1246 +nanovms__ops-936 +napalm-automation__napalm-2152 +narwhals-dev__narwhals-1021 +narwhals-dev__narwhals-1272 +narwhals-dev__narwhals-1342 +narwhals-dev__narwhals-1430 +narwhals-dev__narwhals-1625 +narwhals-dev__narwhals-1715 +narwhals-dev__narwhals-1801 +narwhals-dev__narwhals-1803 +narwhals-dev__narwhals-1810 +narwhals-dev__narwhals-1814 +narwhals-dev__narwhals-1869 +narwhals-dev__narwhals-1909 +narwhals-dev__narwhals-1914 +narwhals-dev__narwhals-1924 +narwhals-dev__narwhals-1934 +narwhals-dev__narwhals-1948 +narwhals-dev__narwhals-2062 +narwhals-dev__narwhals-2103 +narwhals-dev__narwhals-2114 +narwhals-dev__narwhals-2126 +narwhals-dev__narwhals-2128 +narwhals-dev__narwhals-2156 +narwhals-dev__narwhals-2176 +narwhals-dev__narwhals-2178 +narwhals-dev__narwhals-2206 +narwhals-dev__narwhals-2211 +narwhals-dev__narwhals-2224 +narwhals-dev__narwhals-2322 +narwhals-dev__narwhals-2341 +narwhals-dev__narwhals-2363 +narwhals-dev__narwhals-2372 +narwhals-dev__narwhals-2395 +narwhals-dev__narwhals-2421 +narwhals-dev__narwhals-2441 +narwhals-dev__narwhals-2453 +narwhals-dev__narwhals-247 +narwhals-dev__narwhals-2598 +narwhals-dev__narwhals-2733 +narwhals-dev__narwhals-2747 +narwhals-dev__narwhals-2849 +narwhals-dev__narwhals-2864 +nasa-ammos__3dtilesrendererjs-690 +nasa-ammos__3dtilesrendererjs-740 +nasa-ammos__3dtilesrendererjs-762 +nasa-ammos__3dtilesrendererjs-885 +nasa-ammos__3dtilesrendererjs-893 +nasa-ammos__3dtilesrendererjs-900 +natcap__invest-1042 +natcap__invest-1114 +natcap__invest-1121 +natcap__invest-1132 +natcap__invest-1159 +natcap__invest-1192 +natcap__invest-1251 +natcap__invest-1382 +natcap__invest-1477 +natcap__invest-1510 +natcap__invest-1524 +natcap__invest-1530 +natcap__invest-1658 +natcap__invest-1697 +natcap__invest-1791 +natcap__invest-1895 +natcap__invest-1896 +natcap__invest-480 +natcap__invest-488 +natcap__invest-534 +natcap__invest-539 +natcap__invest-542 +natcap__invest-552 +natcap__invest-611 +natcap__invest-636 +natcap__invest-750 +natcap__invest-787 +natcap__invest-813 +natcap__invest-814 +natcap__pygeoprocessing-106 +natcap__pygeoprocessing-110 +natcap__pygeoprocessing-123 +natcap__pygeoprocessing-139 +natcap__pygeoprocessing-147 +natcap__pygeoprocessing-170 +natcap__pygeoprocessing-187 +natcap__pygeoprocessing-188 +natcap__pygeoprocessing-227 +natcap__pygeoprocessing-408 +natcap__pygeoprocessing-434 +natlibfi__annif-721 +natlibfi__annif-793 +natlibfi__annif-801 +natlibfi__annif-832 +natlibfi__annif-839 +natlibfi__skosmos-1546 +natlibfi__skosmos-1580 +natlibfi__skosmos-1588 +natlibfi__skosmos-1725 +nats-io__nats-server-1460 +nats-io__nats-server-1542 +nats-io__nats-server-1611 +nats-io__nats-server-1832 +nats-io__nats-server-2156 +nats-io__nats-server-2162 +nats-io__nats-server-2418 +nats-io__nats-server-2505 +nats-io__nats-server-2533 +nats-io__nats-server-2734 +nats-io__nats-server-2777 +nats-io__nats-server-2791 +nats-io__nats-server-3091 +nats-io__nats-server-3121 +nats-io__nats-server-3243 +nats-io__nats-server-3335 +nats-io__nats-server-3529 +nats-io__nats-server-3552 +nats-io__nats-server-3704 +nats-io__nats-server-3711 +nats-io__nats-server-3717 +nats-io__nats-server-3756 +nats-io__nats-server-3833 +nats-io__nats-server-3923 +nats-io__nats-server-4298 +nats-io__nats-server-4811 +nats-io__nats-server-4938 +nats-io__nats-server-5470 +nats-io__nats-server-6500 +nats-io__nats-server-6922 +nats-io__nats-streaming-server-1101 +nats-io__nats-streaming-server-1136 +nats-io__nats-streaming-server-1140 +nats-io__nats.go-1010 +nats-io__nats.go-1044 +nats-io__nats.go-1062 +nats-io__nats.go-1074 +nats-io__nats.go-1341 +nats-io__nats.go-1487 +nats-io__nats.go-1544 +nats-io__nats.go-1713 +nats-io__nats.go-1888 +nats-io__nats.go-740 +nats-io__nats.go-803 +nats-io__nats.go-838 +nats-io__nats.go-879 +nats-io__nats.go-926 +nats-io__nsc-266 +nats-io__nsc-267 +nats-io__nsc-271 +nats-io__nsc-273 +nats-io__nsc-291 +nats-io__nsc-303 +nats-io__nsc-363 +nats-io__nsc-383 +nats-io__nsc-390 +nats-io__nsc-422 +nats-io__nsc-592 +nats-io__nsc-608 +nats-io__nsc-610 +nats-io__nsc-634 +nats-io__nsc-640 +nats-io__nsc-656 +nats-io__nsc-658 +nats-io__nsc-685 +nats-io__nsc-725 +naturalcrit__homebrewery-1981 +naturalcrit__homebrewery-2681 +naturalcrit__homebrewery-2752 +naturalcrit__homebrewery-3560 +naturalcrit__homebrewery-3624 +naturalcrit__homebrewery-3625 +naturalcrit__homebrewery-3660 +naturalcrit__homebrewery-3992 +naturalcrit__homebrewery-4014 +ncar__geocat-comp-315 +ncar__geocat-comp-571 +ncar__geocat-comp-65 +nchammas__flintrock-180 +nchammas__flintrock-186 +nchammas__flintrock-74 +ncw__rclone-2810 +ncw__rclone-3280 +ncw__rclone-3316 +near__borsh-rs-14 +near__borsh-rs-174 +near__borsh-rs-177 +near__borsh-rs-37 +near__borsh-rs-6 +nearform__fast-jwt-193 +nearform__fast-jwt-195 +nearform__fast-jwt-335 +nearform__fast-jwt-42 +nearform__sql-120 +nearform__sql-14 +nearform__sql-18 +nearform__sql-4 +nearform__sql-41 +nearform__sql-50 +nearform__sql-52 +nearform__sql-96 +neet__masto.js-170 +neet__masto.js-304 +neet__masto.js-55 +neet__masto.js-78 +neet__masto.js-98 +nelmio__alice-168 +nemocas__abstractalgebra.jl-1167 +nemocas__abstractalgebra.jl-1183 +nemocas__abstractalgebra.jl-1190 +nemocas__abstractalgebra.jl-1246 +nemocas__abstractalgebra.jl-1356 +nemocas__abstractalgebra.jl-590 +nemocas__abstractalgebra.jl-601 +nemocas__abstractalgebra.jl-628 +nemocas__abstractalgebra.jl-644 +nemocas__abstractalgebra.jl-654 +nemocas__abstractalgebra.jl-658 +nemocas__abstractalgebra.jl-663 +nemocas__abstractalgebra.jl-666 +nemocas__abstractalgebra.jl-669 +nemocas__abstractalgebra.jl-670 +nemocas__abstractalgebra.jl-757 +nemocas__abstractalgebra.jl-820 +nemocas__abstractalgebra.jl-826 +nemocas__abstractalgebra.jl-851 +nemocas__abstractalgebra.jl-852 +nemocas__abstractalgebra.jl-853 +nemocas__abstractalgebra.jl-865 +nemocas__abstractalgebra.jl-867 +nemocas__abstractalgebra.jl-868 +nemocas__abstractalgebra.jl-871 +nemocas__abstractalgebra.jl-895 +nemocas__abstractalgebra.jl-907 +nemocas__abstractalgebra.jl-938 +nemocas__abstractalgebra.jl-939 +nemocas__nemo.jl-1089 +nemocas__nemo.jl-1134 +nemocas__nemo.jl-1149 +nemocas__nemo.jl-1151 +nemocas__nemo.jl-1154 +nemocas__nemo.jl-1250 +nemocas__nemo.jl-1279 +nemocas__nemo.jl-1298 +nemocas__nemo.jl-1456 +nemocas__nemo.jl-1457 +nemocas__nemo.jl-1458 +nemocas__nemo.jl-1459 +nemocas__nemo.jl-1484 +nemocas__nemo.jl-1511 +nemocas__nemo.jl-1513 +nemocas__nemo.jl-1588 +nemocas__nemo.jl-1598 +nemocas__nemo.jl-1622 +nemocas__nemo.jl-1687 +nemocas__nemo.jl-1701 +nemocas__nemo.jl-1707 +nemocas__nemo.jl-1743 +nemocas__nemo.jl-1796 +nemocas__nemo.jl-1847 +nemocas__nemo.jl-1959 +nemocas__nemo.jl-1963 +nemocas__nemo.jl-1965 +nemocas__nemo.jl-2104 +nemocas__nemo.jl-2120 +nemocas__nemo.jl-875 +nemocas__nemo.jl-939 +nemocas__nemo.jl-957 +nemocas__nemo.jl-985 +nemocas__nemo.jl-986 +nengo__nengo-1550 +nengo__nengo-1628 +nengo__nengo-1646 +neogeny__tatsu-100 +neogeny__tatsu-101 +neogeny__tatsu-102 +neogeny__tatsu-103 +neogeny__tatsu-104 +neogeny__tatsu-121 +neogeny__tatsu-137 +neogeny__tatsu-183 +neogeny__tatsu-206 +neogeny__tatsu-221 +neogeny__tatsu-237 +neogeny__tatsu-265 +neogeny__tatsu-268 +neogeny__tatsu-275 +neogeny__tatsu-276 +neogeny__tatsu-309 +neogeny__tatsu-32 +neogeny__tatsu-320 +neogeny__tatsu-339 +neogeny__tatsu-35 +neogeny__tatsu-67 +neogeny__tatsu-78 +neogeny__tatsu-83 +neogeny__tatsu-97 +neoteroi__blacksheep-366 +neoteroi__blacksheep-457 +neoteroi__blacksheep-467 +neoteroi__blacksheep-475 +neoteroi__blacksheep-553 +nephila__djangocms-installer-202 +nephila__djangocms-installer-322 +nephila__python-taiga-82 +nerdvegas__rez-1061 +nerdvegas__rez-1252 +nerdvegas__rez-868 +nerzal__gocloak-105 +nerzal__gocloak-188 +nerzal__gocloak-194 +nerzal__gocloak-301 +nestjs__nest-10272 +nestjs__nest-9585 +nestjs__swagger-1223 +nestjs__swagger-1262 +nestjs__swagger-1436 +nestjs__swagger-1513 +nestjs__swagger-1634 +nestjs__swagger-1706 +nestjs__swagger-1949 +nestjs__swagger-2112 +nestjs__swagger-2145 +nestjs__swagger-2608 +nestjs__swagger-514 +nestjs__swagger-582 +nestjs__swagger-810 +nestjs__swagger-913 +netapp__harvest-1326 +nethermindeth__cairo-vm-go-662 +nethermindeth__juno-573 +netlify__gocommerce-192 +netlify__zip-it-and-ship-it-107 +netlify__zip-it-and-ship-it-423 +netlify__zip-it-and-ship-it-425 +netlify__zip-it-and-ship-it-447 +netlify__zip-it-and-ship-it-515 +netlify__zip-it-and-ship-it-619 +netlify__zip-it-and-ship-it-671 +netobserv__flowlogs-pipeline-970 +netwo-io__apistos-108 +netwo-io__apistos-110 +netwo-io__apistos-124 +netwo-io__apistos-126 +netwo-io__apistos-128 +netwo-io__apistos-131 +netwo-io__apistos-134 +netwo-io__apistos-140 +netwo-io__apistos-61 +netwo-io__apistos-71 +netwo-io__apistos-91 +networknt__json-schema-validator-1033 +networknt__json-schema-validator-1039 +networknt__json-schema-validator-1051 +networknt__json-schema-validator-1071 +networknt__json-schema-validator-1077 +networknt__json-schema-validator-1115 +networknt__json-schema-validator-1124 +networknt__json-schema-validator-1127 +networknt__json-schema-validator-1134 +networknt__json-schema-validator-1138 +networknt__json-schema-validator-1145 +networknt__json-schema-validator-1147 +networknt__json-schema-validator-115 +networknt__json-schema-validator-1152 +networknt__json-schema-validator-119 +networknt__json-schema-validator-137 +networknt__json-schema-validator-159 +networknt__json-schema-validator-348 +networknt__json-schema-validator-410 +networknt__json-schema-validator-515 +networknt__json-schema-validator-533 +networknt__json-schema-validator-578 +networknt__json-schema-validator-651 +networknt__json-schema-validator-663 +networknt__json-schema-validator-671 +networkx__networkx-2769 +networkx__networkx-2936 +networkx__networkx-2955 +networkx__networkx-3029 +networkx__networkx-3031 +networkx__networkx-3072 +networkx__networkx-3101 +networkx__networkx-3339 +networkx__networkx-3361 +networkx__networkx-3365 +networkx__networkx-3366 +networkx__networkx-3508 +networkx__networkx-3527 +networkx__networkx-3604 +networkx__networkx-3606 +networkx__networkx-3613 +networkx__networkx-3628 +networkx__networkx-3636 +networkx__networkx-3672 +networkx__networkx-4378 +networkx__networkx-4461 +networkx__networkx-4872 +networkx__networkx-5065 +networkx__networkx-5616 +networkx__networkx-6612 +networkx__networkx-6894 +networkx__networkx-8043 +networkx__networkx-8055 +networkx__networkx-8057 +netz98__n98-magerun2-1024 +netz98__n98-magerun2-1032 +netz98__n98-magerun2-1150 +netz98__n98-magerun2-1151 +netz98__n98-magerun2-1255 +netz98__n98-magerun2-1274 +netz98__n98-magerun2-1275 +netz98__n98-magerun2-1605 +netz98__n98-magerun2-1623 +netz98__n98-magerun2-874 +netz98__n98-magerun2-927 +neurodata__graspy-428 +neurodatawithoutborders__pynwb-1004 +neurodatawithoutborders__pynwb-1410 +neurodatawithoutborders__pynwb-1448 +neurodatawithoutborders__pynwb-1491 +neurodatawithoutborders__pynwb-1516 +neurodatawithoutborders__pynwb-1538 +neurodatawithoutborders__pynwb-1590 +neurodatawithoutborders__pynwb-1596 +neurodatawithoutborders__pynwb-1598 +neurodatawithoutborders__pynwb-1612 +neurodatawithoutborders__pynwb-164 +neurodatawithoutborders__pynwb-1651 +neurodatawithoutborders__pynwb-166 +neurodatawithoutborders__pynwb-1669 +neurodatawithoutborders__pynwb-167 +neurodatawithoutborders__pynwb-1766 +neurodatawithoutborders__pynwb-1770 +neurodatawithoutborders__pynwb-1806 +neurodatawithoutborders__pynwb-1813 +neurodatawithoutborders__pynwb-1815 +neurodatawithoutborders__pynwb-1861 +neurodatawithoutborders__pynwb-1865 +neurodatawithoutborders__pynwb-1934 +neurodatawithoutborders__pynwb-1975 +neurodatawithoutborders__pynwb-1986 +neurodatawithoutborders__pynwb-2020 +neurodatawithoutborders__pynwb-2023 +neurodatawithoutborders__pynwb-2051 +neurodatawithoutborders__pynwb-2052 +neurodatawithoutborders__pynwb-2056 +neurodatawithoutborders__pynwb-2060 +neurodatawithoutborders__pynwb-2091 +neurodatawithoutborders__pynwb-2102 +neurodatawithoutborders__pynwb-381 +neurodatawithoutborders__pynwb-428 +neurodatawithoutborders__pynwb-439 +neurodatawithoutborders__pynwb-501 +neurodatawithoutborders__pynwb-516 +neurodatawithoutborders__pynwb-523 +neurodatawithoutborders__pynwb-539 +neurodatawithoutborders__pynwb-545 +neurodatawithoutborders__pynwb-557 +neurodatawithoutborders__pynwb-57 +neurodatawithoutborders__pynwb-582 +neurodatawithoutborders__pynwb-596 +neurodatawithoutborders__pynwb-637 +neurodatawithoutborders__pynwb-644 +neurodatawithoutborders__pynwb-681 +neurodatawithoutborders__pynwb-684 +neurodatawithoutborders__pynwb-690 +neurodatawithoutborders__pynwb-700 +neurodatawithoutborders__pynwb-701 +neurodatawithoutborders__pynwb-773 +neurodatawithoutborders__pynwb-791 +neurodatawithoutborders__pynwb-811 +neurodatawithoutborders__pynwb-814 +neurodatawithoutborders__pynwb-818 +neurodatawithoutborders__pynwb-820 +neurodatawithoutborders__pynwb-843 +neurodatawithoutborders__pynwb-846 +neurodatawithoutborders__pynwb-930 +neurodatawithoutborders__pynwb-937 +neurodatawithoutborders__pynwb-959 +neurodatawithoutborders__pynwb-987 +neurodatawithoutborders__pynwb-994 +neurodatawithoutborders__pynwb-998 +newrelic__newrelic-client-go-61 +newrelic__newrelic-client-go-70 +newrelic__newrelic-node-apollo-server-plugin-180 +nginx__nginx-gateway-fabric-3249 +nginx__nginx-gateway-fabric-3390 +nhn__tui.editor-1679 +nhn__tui.editor-2085 +nhn__tui.editor-2754 +nhooyr__websocket-160 +nhooyr__websocket-198 +nhooyr__websocket-224 +nhooyr__websocket-236 +nicklaw5__helix-100 +nicklaw5__helix-117 +nicklaw5__helix-200 +nicklaw5__helix-211 +nicklaw5__helix-57 +nicoespeon__abracadabra-1017 +nicoespeon__abracadabra-1038 +nicoespeon__abracadabra-1155 +nicoespeon__abracadabra-157 +nicoespeon__abracadabra-174 +nicoespeon__abracadabra-244 +nicoespeon__abracadabra-263 +nicoespeon__abracadabra-267 +nicoespeon__abracadabra-541 +nicoespeon__abracadabra-544 +nicoespeon__abracadabra-729 +nicoespeon__abracadabra-750 +nicoespeon__abracadabra-838 +niconoe__pyinaturalist-120 +niconoe__pyinaturalist-133 +niconoe__pyinaturalist-161 +niconoe__pyinaturalist-22 +niconoe__pyinaturalist-333 +niconoe__pyinaturalist-61 +niconoe__pyinaturalist-71 +niconoe__pyinaturalist-72 +niconoe__pyinaturalist-76 +niconoe__pyinaturalist-78 +niconoe__pyinaturalist-86 +niconoe__pyinaturalist-91 +nightwatchjs__nightwatch-2716 +nightwatchjs__nightwatch-3265 +nightwatchjs__nightwatch-3309 +nightwatchjs__nightwatch-3314 +nightwatchjs__nightwatch-3335 +nightwatchjs__nightwatch-3427 +nightwatchjs__nightwatch-4007 +nightwatchjs__nightwatch-4107 +nightwatchjs__nightwatch-4118 +nightwatchjs__nightwatch-4168 +nightwatchjs__nightwatch-4176 +nightwatchjs__nightwatch-4178 +nightwatchjs__nightwatch-4180 +niklasei__bevy_asset_loader-127 +niklasei__bevy_asset_loader-193 +niklasei__bevy_asset_loader-250 +niklasei__bevy_asset_loader-83 +niklasei__bevy_asset_loader-84 +niklasvh__html2canvas-2591 +nilsjpwerner__autodocstring-223 +nilsjpwerner__autodocstring-282 +nipy__nibabel-1315 +nipy__nibabel-1336 +nipy__nibabel-750 +nipy__nibabel-753 +nipy__nibabel-755 +nipy__nibabel-806 +nipy__nipype-2912 +nipy__nipype-3444 +nipy__nipype-3470 +nipy__nipype-3472 +nipy__nipype-3489 +nipype__pydra-187 +nipype__pydra-225 +nipype__pydra-236 +nipype__pydra-322 +nipype__pydra-629 +nipype__pydra-742 +nix-community__nixpkgs-fmt-108 +nix-community__nixpkgs-fmt-110 +nix-community__nixpkgs-fmt-119 +nix-community__nixpkgs-fmt-167 +nix-community__nixpkgs-fmt-168 +nix-community__nixpkgs-fmt-169 +nix-community__nixpkgs-fmt-173 +nix-community__nixpkgs-fmt-174 +nix-community__nixpkgs-fmt-176 +nix-community__nixpkgs-fmt-177 +nix-community__nixpkgs-fmt-180 +nix-community__nixpkgs-fmt-182 +nix-community__nixpkgs-fmt-204 +nix-community__nixpkgs-fmt-219 +nix-community__nixpkgs-fmt-236 +nix-community__nixpkgs-fmt-245 +nix-community__nixpkgs-fmt-275 +nix-community__nixpkgs-fmt-45 +nix-community__nixpkgs-fmt-63 +nix-community__nixpkgs-fmt-73 +nix-community__nixpkgs-fmt-79 +nix-community__nixpkgs-fmt-95 +nock__nock-2297 +nock__nock-2356 +nock__nock-2357 +nock__nock-2497 +nock__nock-2809 +nock__nock-2810 +nodatime__nodatime-1776 +nodatime__nodatime-1780 +nodatime__nodatime-1808 +nodatime__nodatime-1836 +node-fetch__node-fetch-1449 +node-fetch__node-fetch-1463 +node-fetch__node-fetch-1474 +node-fetch__node-fetch-1482 +node-fetch__node-fetch-1486 +node-fetch__node-fetch-1542 +node-fetch__node-fetch-1670 +node-fetch__node-fetch-834 +node-influx__node-influx-472 +node-influx__node-influx-518 +node-influx__node-influx-545 +node-influx__node-influx-583 +node-influx__node-influx-588 +node-red__node-red-3867 +node-red__node-red-3906 +node-red__node-red-3920 +node-red__node-red-4316 +node-red__node-red-4332 +nodeca__js-yaml-358 +nodeca__js-yaml-369 +nodeca__js-yaml-371 +nodeca__js-yaml-404 +nodejs__llhttp-226 +nodejs__llhttp-243 +nodejs__llhttp-245 +nodejs__nodejs.dev-1298 +nodejs__nodejs.dev-1300 +nodejs__nodejs.dev-1346 +nodejs__nodejs.dev-1353 +nodejs__nodejs.dev-1443 +nolar__kopf-1031 +nomicfoundation__hardhat-ignition-481 +nomicfoundation__hardhat-ignition-505 +nomicfoundation__hardhat-ignition-508 +nomicfoundation__hardhat-ignition-513 +nomicfoundation__hardhat-ignition-537 +nomicfoundation__hardhat-ignition-542 +nomicfoundation__hardhat-ignition-552 +nomicfoundation__hardhat-ignition-555 +nomicfoundation__hardhat-ignition-556 +nomicfoundation__hardhat-ignition-558 +nomicfoundation__hardhat-ignition-575 +not-an-aardvark__eslint-plugin-eslint-plugin-100 +not-an-aardvark__eslint-plugin-eslint-plugin-145 +not-an-aardvark__eslint-plugin-eslint-plugin-15 +not-an-aardvark__eslint-plugin-eslint-plugin-196 +not-an-aardvark__eslint-plugin-eslint-plugin-20 +not-an-aardvark__eslint-plugin-eslint-plugin-251 +not-an-aardvark__eslint-plugin-eslint-plugin-26 +not-an-aardvark__eslint-plugin-eslint-plugin-290 +not-an-aardvark__eslint-plugin-eslint-plugin-38 +not-an-aardvark__eslint-plugin-eslint-plugin-41 +not-an-aardvark__eslint-plugin-eslint-plugin-56 +not-an-aardvark__eslint-plugin-eslint-plugin-80 +not-an-aardvark__eslint-plugin-eslint-plugin-93 +not-fl3__nanoserde-100 +not-fl3__nanoserde-102 +not-fl3__nanoserde-63 +not-fl3__nanoserde-65 +not-fl3__nanoserde-70 +not-fl3__nanoserde-80 +not-fl3__nanoserde-84 +not-fl3__nanoserde-90 +not-fl3__nanoserde-91 +not-fl3__nanoserde-95 +notaryproject__notation-1145 +notaryproject__notation-1182 +notaryproject__notation-1192 +notaryproject__notation-1231 +notaryproject__notation-1243 +notaryproject__notation-311 +notaryproject__notation-746 +notaryproject__notation-998 +novifinancial__opaque-ke-138 +novifinancial__opaque-ke-140 +novifinancial__opaque-ke-168 +novifinancial__opaque-ke-177 +nspcc-dev__neo-go-3959 +ntnu-ihb__pythonfmu-103 +ntnu-ihb__pythonfmu-158 +ntnu-ihb__pythonfmu-20 +ntnu-ihb__pythonfmu-24 +ntnu-ihb__pythonfmu-30 +ntnu-ihb__pythonfmu-40 +ntnu-ihb__pythonfmu-86 +nukesor__comfy-table-114 +nukesor__comfy-table-171 +nukesor__comfy-table-70 +nukosuke__go-zendesk-194 +nukosuke__go-zendesk-260 +nukosuke__go-zendesk-84 +nukosuke__go-zendesk-91 +nukosuke__go-zendesk-93 +numaproj__numaflow-1030 +numaproj__numaflow-1085 +numaproj__numaflow-1132 +numaproj__numaflow-1441 +numaproj__numaflow-1481 +numaproj__numaflow-1816 +numaproj__numaflow-2047 +numaproj__numaflow-254 +numaproj__numaflow-261 +numaproj__numaflow-271 +numaproj__numaflow-364 +numaproj__numaflow-397 +numaproj__numaflow-398 +numaproj__numaflow-555 +numaproj__numaflow-601 +numaproj__numaflow-605 +numaproj__numaflow-654 +numaproj__numaflow-758 +numaproj__numaflow-775 +numaproj__numaflow-783 +numaproj__numaflow-802 +numaproj__numaflow-810 +numaproj__numaflow-850 +numtide__treefmt-303 +numtide__treefmt-377 +numtide__treefmt-389 +numtide__treefmt-438 +numtide__treefmt-447 +numtide__treefmt-476 +numtide__treefmt-488 +numtide__treefmt-504 +numtide__treefmt-560 +numtide__treefmt-571 +numtide__treefmt-579 +nushell__engine-q-940 +nuveo__prest-111 +nuveo__prest-96 +nuxt-community__i18n-module-1022 +nuxt__create-nuxt-app-269 +nuxt__image-1626 +nuxt__image-1656 +nuxt__image-684 +nuxt__image-740 +nuxt__nuxt.js-8780 +nuxt__nuxt.js-8792 +nuxt__nuxt.js-9075 +nuxt__test-utils-1128 +nvim-lua__plenary.nvim-251 +nvim-lua__plenary.nvim-288 +nvim-lua__plenary.nvim-339 +nvim-lua__plenary.nvim-372 +nvim-lualine__lualine.nvim-1376 +nvim-lualine__lualine.nvim-669 +nvim-lualine__lualine.nvim-767 +nvim-lualine__lualine.nvim-810 +nvim-lualine__lualine.nvim-812 +nvim-lualine__lualine.nvim-836 +nvim-lualine__lualine.nvim-964 +nyaruka__floweditor-1018 +nytimes__kyt-347 +nyxx-discord__nyxx-332 +nyxx-discord__nyxx-488 +nyxx-discord__nyxx-490 +nyxx-discord__nyxx-547 +nyxx-discord__nyxx-551 +nzakas__eslint-plugin-typescript-116 +nzakas__eslint-plugin-typescript-132 +nzakas__eslint-plugin-typescript-140 +nzakas__eslint-plugin-typescript-159 +nzakas__eslint-plugin-typescript-20 +nzakas__eslint-plugin-typescript-59 +nzakas__eslint-plugin-typescript-62 +o1-labs__zkapp-cli-360 +o1-labs__zkapp-cli-701 +oam-dev__kubevela-1756 +oam-dev__kubevela-1782 +oasis-open__cti-python-stix2-160 +oasis-open__cti-python-stix2-25 +oasis-open__cti-python-stix2-337 +oasis-open__cti-python-stix2-480 +oasis-open__cti-python-stix2-483 +oasis-open__cti-stix-validator-10 +oasis-open__cti-stix-validator-18 +oasis-open__cti-stix-validator-30 +oasis-open__cti-stix-validator-47 +oasis-open__cti-stix-validator-57 +oasisprotocol__oasis-core-3285 +oasisprotocol__oasis-core-3482 +oauth2-proxy__oauth2-proxy-746 +obolnetwork__charon-3035 +obsidian-tasks-group__obsidian-tasks-1006 +obsidian-tasks-group__obsidian-tasks-1107 +obsidian-tasks-group__obsidian-tasks-1232 +obsidian-tasks-group__obsidian-tasks-1309 +obsidian-tasks-group__obsidian-tasks-1391 +obsidian-tasks-group__obsidian-tasks-1408 +obsidian-tasks-group__obsidian-tasks-1437 +obsidian-tasks-group__obsidian-tasks-1439 +obsidian-tasks-group__obsidian-tasks-1440 +obsidian-tasks-group__obsidian-tasks-1441 +obsidian-tasks-group__obsidian-tasks-1449 +obsidian-tasks-group__obsidian-tasks-1492 +obsidian-tasks-group__obsidian-tasks-1504 +obsidian-tasks-group__obsidian-tasks-1526 +obsidian-tasks-group__obsidian-tasks-1533 +obsidian-tasks-group__obsidian-tasks-1536 +obsidian-tasks-group__obsidian-tasks-1554 +obsidian-tasks-group__obsidian-tasks-1559 +obsidian-tasks-group__obsidian-tasks-1563 +obsidian-tasks-group__obsidian-tasks-1592 +obsidian-tasks-group__obsidian-tasks-1608 +obsidian-tasks-group__obsidian-tasks-1734 +obsidian-tasks-group__obsidian-tasks-1735 +obsidian-tasks-group__obsidian-tasks-1744 +obsidian-tasks-group__obsidian-tasks-1749 +obsidian-tasks-group__obsidian-tasks-1756 +obsidian-tasks-group__obsidian-tasks-1780 +obsidian-tasks-group__obsidian-tasks-1805 +obsidian-tasks-group__obsidian-tasks-1817 +obsidian-tasks-group__obsidian-tasks-1897 +obsidian-tasks-group__obsidian-tasks-1903 +obsidian-tasks-group__obsidian-tasks-1963 +obsidian-tasks-group__obsidian-tasks-2022 +obsidian-tasks-group__obsidian-tasks-2047 +obsidian-tasks-group__obsidian-tasks-2054 +obsidian-tasks-group__obsidian-tasks-2072 +obsidian-tasks-group__obsidian-tasks-2113 +obsidian-tasks-group__obsidian-tasks-2132 +obsidian-tasks-group__obsidian-tasks-2134 +obsidian-tasks-group__obsidian-tasks-2136 +obsidian-tasks-group__obsidian-tasks-2179 +obsidian-tasks-group__obsidian-tasks-2193 +obsidian-tasks-group__obsidian-tasks-2264 +obsidian-tasks-group__obsidian-tasks-2285 +obsidian-tasks-group__obsidian-tasks-2288 +obsidian-tasks-group__obsidian-tasks-2301 +obsidian-tasks-group__obsidian-tasks-2330 +obsidian-tasks-group__obsidian-tasks-772 +obsidian-tasks-group__obsidian-tasks-802 +obsidian-tasks-group__obsidian-tasks-900 +obsidian-tasks-group__obsidian-tasks-953 +ocaml-multicore__picos-118 +ocaml-multicore__picos-119 +ocaml-multicore__picos-23 +ocaml-multicore__picos-235 +ocaml-multicore__picos-58 +ocaml-ppx__ppx_deriving-279 +ocaml-ppx__ppx_deriving-281 +ocamllabs__duniverse-95 +oceanparcels__parcels-1723 +oceanparcels__parcels-1766 +oceanparcels__parcels-1778 +oceanparcels__parcels-1810 +oceanparcels__parcels-2091 +oceanparcels__parcels-438 +oceanparcels__parcels-476 +oceanparcels__parcels-541 +oceanparcels__parcels-563 +oceanparcels__parcels-574 +oceanparcels__parcels-590 +oceanparcels__parcels-617 +oceanprotocol__market-1703 +oceanprotocol__market-1774 +oceanprotocol__market-1779 +oceanprotocol__market-1782 +oceanprotocol__market-1783 +oclif__core-1095 +oclif__core-1208 +oclif__core-1271 +oclif__core-490 +oclif__core-527 +oclif__core-593 +oclif__core-741 +oclif__core-816 +oclif__core-836 +oclif__core-847 +oclif__core-850 +oclif__core-953 +oclif__core-983 +ocr-d__core-1238 +ocr-d__core-1243 +ocr-d__core-1329 +ocsigen__lwt-860 +octokit__auth-app.js-689 +octokit__oauth-app.js-206 +octokit__oauth-app.js-210 +octokit__oauth-app.js-242 +octokit__oauth-app.js-370 +octokit__oauth-app.js-371 +octokit__oauth-app.js-4 +octokit__oauth-app.js-9 +octokit__webhooks.js-322 +octokit__webhooks.js-324 +octokit__webhooks.js-511 +octokit__webhooks.js-586 +octokit__webhooks.js-595 +octokit__webhooks.js-611 +octokit__webhooks.js-790 +octokit__webhooks.js-792 +octokit__webhooks.js-795 +ogen-go__ogen-61 +okonet__lint-staged-1117 +okonet__lint-staged-1119 +okonet__lint-staged-162 +okonet__lint-staged-196 +okonet__lint-staged-265 +okonet__lint-staged-281 +okonet__lint-staged-295 +okonet__lint-staged-297 +okonet__lint-staged-315 +okonet__lint-staged-421 +okonet__lint-staged-456 +okonet__lint-staged-819 +okonet__lint-staged-887 +okteto__okteto-4435 +okteto__okteto-4722 +oli-obk__cargo_metadata-124 +oli-obk__cargo_metadata-203 +oli-obk__cargo_metadata-241 +oli-obk__cargo_metadata-282 +oli-obk__cargo_metadata-71 +oli-obk__cargo_metadata-78 +olivere__elastic-1364 +olivere__elastic-1415 +olivere__elastic-1478 +olivere__elastic-1480 +olivere__elastic-1500 +olivere__elastic-1528 +oliverschwendener__ueli-1159 +oliverschwendener__ueli-1181 +oliverschwendener__ueli-1210 +oliverschwendener__ueli-1216 +oliverschwendener__ueli-1231 +oliverschwendener__ueli-1247 +oliverschwendener__ueli-1290 +oliverschwendener__ueli-1300 +oliverschwendener__ueli-1304 +oliverschwendener__ueli-1307 +oliverschwendener__ueli-1321 +oliverschwendener__ueli-1331 +oliverschwendener__ueli-1364 +oliviertassinari__babel-plugin-transform-react-remove-prop-types-180 +omni-us__jsonargparse-190 +omni-us__jsonargparse-380 +omni-us__jsonargparse-383 +omni-us__jsonargparse-526 +omni-us__jsonargparse-530 +omni-us__jsonargparse-571 +omni-us__jsonargparse-586 +omni-us__jsonargparse-660 +omni-us__jsonargparse-710 +omni-us__jsonargparse-717 +onedr0p__exportarr-110 +onedr0p__exportarr-117 +onedr0p__exportarr-120 +onedr0p__exportarr-149 +onedr0p__exportarr-150 +onedr0p__exportarr-157 +onedr0p__exportarr-160 +onedr0p__exportarr-162 +onedr0p__exportarr-231 +onedr0p__exportarr-275 +onflow__fcl-js-1882 +onflow__flow-cli-202 +onflow__flow-cli-256 +onflow__flow-cli-269 +onflow__flow-cli-319 +onflow__flow-cli-336 +onflow__flow-cli-350 +onflow__flow-cli-352 +onflow__flow-cli-366 +onflow__flow-cli-378 +onflow__flow-cli-509 +onnx__sklearn-onnx-1163 +onnx__sklearn-onnx-1169 +onsi__ginkgo-1101 +ontodev__robot-1000 +ontodev__robot-1106 +ontodev__robot-1135 +ontodev__robot-116 +ontodev__robot-1168 +ontodev__robot-1171 +ontodev__robot-1225 +ontodev__robot-1246 +ontodev__robot-136 +ontodev__robot-138 +ontodev__robot-146 +ontodev__robot-322 +ontodev__robot-560 +ontodev__robot-646 +ontodev__robot-710 +ontodev__robot-715 +ontodev__robot-788 +ontodev__robot-882 +ontodev__robot-979 +ony3000__prettier-plugin-classnames-36 +ony3000__prettier-plugin-classnames-38 +ony3000__prettier-plugin-classnames-49 +ony3000__prettier-plugin-classnames-51 +ony3000__prettier-plugin-classnames-91 +ony3000__prettier-plugin-classnames-94 +ony3000__prettier-plugin-classnames-95 +oom-ai__oomstore-1084 +oom-ai__oomstore-1118 +oom-ai__oomstore-1158 +oom-ai__oomstore-823 +oom-ai__oomstore-829 +open-feature__go-sdk-251 +open-feature__go-sdk-261 +open-feature__go-sdk-263 +open-feature__go-sdk-297 +open-feature__go-sdk-371 +open-feature__js-sdk-444 +open-feature__js-sdk-490 +open-feature__js-sdk-491 +open-feature__js-sdk-537 +open-feature__js-sdk-577 +open-feature__js-sdk-578 +open-feature__js-sdk-617 +open-feature__js-sdk-704 +open-feature__js-sdk-715 +open-feature__js-sdk-740 +open-sauced__app-2373 +open-sauced__insights-851 +open-sauced__insights-889 +open-telemetry__opamp-go-125 +open-telemetry__opamp-go-201 +open-telemetry__opamp-go-251 +open-telemetry__opamp-go-289 +open-telemetry__opamp-go-298 +open-telemetry__opamp-go-301 +open-telemetry__opamp-go-305 +open-telemetry__opamp-go-331 +open-telemetry__opamp-go-81 +open-telemetry__opentelemetry-go-190 +open-telemetry__opentelemetry-go-217 +open-telemetry__opentelemetry-go-234 +open-telemetry__opentelemetry-go-241 +open-telemetry__opentelemetry-go-286 +open-telemetry__opentelemetry-go-7001 +open-telemetry__opentelemetry-go-contrib-5404 +open-telemetry__opentelemetry-operator-3962 +open-telemetry__opentelemetry-php-178 +openaddresses__machine-448 +openaddresses__machine-476 +openaddresses__machine-493 +openaddresses__machine-495 +openaddresses__machine-501 +openaddresses__machine-517 +openaddresses__machine-520 +openaddresses__machine-570 +openaddresses__machine-573 +openaddresses__machine-596 +openaddresses__machine-611 +openaddresses__machine-619 +openaddresses__machine-631 +opencomponents__oc-1024 +opencomponents__oc-1202 +openconfig__goyang-139 +openconfig__goyang-229 +openconfig__goyang-235 +openconfig__ygot-890 +opencontainers__runc-2968 +opencontainers__runc-3182 +opencontainers__runc-3257 +opencontainers__runc-3939 +opencontainers__runc-4124 +opencontainers__runc-4134 +opencontainers__runc-4144 +opencybersecurityalliance__stix-shifter-1191 +opencybersecurityalliance__stix-shifter-1306 +opencybersecurityalliance__stix-shifter-1355 +opendatacube__odc-geo-121 +opendatacube__odc-geo-124 +opendatacube__odc-geo-140 +opendatacube__odc-geo-142 +openebs__node-disk-manager-652 +openebs__node-disk-manager-678 +openfaas__faas-cli-1002 +openfaas__faas-cli-828 +openfga__cli-27 +openfga__cli-58 +opengemini__opengemini-109 +openidc__pyoidc-831 +openimsdk__open-im-server-2140 +openkruise__kruise-899 +openkruise__kruise-929 +openlawlibrary__pygls-117 +openlawlibrary__pygls-383 +openllb__hlb-157 +openllb__hlb-158 +openllb__hlb-160 +openllb__hlb-174 +openmdao__aviary-298 +openmdao__aviary-582 +openmdao__aviary-604 +openmdao__aviary-676 +openmdao__aviary-709 +openmdao__aviary-807 +openmdao__dymos-1018 +openmdao__dymos-1020 +openmdao__dymos-1021 +openmdao__dymos-1121 +openmdao__dymos-1127 +openmdao__dymos-1146 +openmdao__dymos-1165 +openmdao__dymos-1182 +openmdao__dymos-1184 +openmdao__dymos-915 +openmdao__openmdao-2715 +openmdao__openmdao-2718 +openmdao__openmdao-2724 +openmdao__openmdao-2743 +openmdao__openmdao-2744 +openmdao__openmdao-2771 +openmdao__openmdao-2780 +openmdao__openmdao-2782 +openmdao__openmdao-2797 +openmdao__openmdao-2810 +openmdao__openmdao-2812 +openmdao__openmdao-2813 +openmdao__openmdao-2861 +openmdao__openmdao-2885 +openmdao__openmdao-2902 +openmdao__openmdao-2916 +openmdao__openmdao-2925 +openmdao__openmdao-2931 +openmdao__openmdao-2952 +openmdao__openmdao-2965 +openmdao__openmdao-2966 +openmdao__openmdao-3029 +openmdao__openmdao-3039 +openmdao__openmdao-3042 +openmdao__openmdao-3050 +openmdao__openmdao-3057 +openmdao__openmdao-3094 +openmdao__openmdao-3098 +openmdao__openmdao-3117 +openmdao__openmdao-3125 +openmdao__openmdao-3126 +openmdao__openmdao-3132 +openmdao__openmdao-3137 +openmdao__openmdao-3184 +openmdao__openmdao-3187 +openmdao__openmdao-3188 +openmdao__openmdao-3190 +openmdao__openmdao-3191 +openmdao__openmdao-3192 +openmdao__openmdao-3228 +openmdao__openmdao-3239 +openmdao__openmdao-3248 +openmdao__openmdao-3255 +openmdao__openmdao-3256 +openmdao__openmdao-3259 +openmdao__openmdao-3277 +openmdao__openmdao-3295 +openmdao__openmdao-3311 +openmdao__openmdao-3315 +openmdao__openmdao-3318 +openmdao__openmdao-3334 +openmdao__openmdao-3340 +openmdao__openmdao-3348 +openmdao__openmdao-3353 +openmdao__openmdao-3367 +openmdao__openmdao-3370 +openmdao__openmdao-3371 +openmdao__openmdao-3379 +openmdao__openmdao-3387 +openmdao__openmdao-3406 +openmdao__openmdao-3407 +openmdao__openmdao-3419 +openmdao__openmdao-3423 +openmdao__openmdao-3455 +openmdao__openmdao-3461 +openmdao__openmdao-3463 +openmdao__openmdao-3469 +openmdao__openmdao-3488 +openmdao__openmdao-3514 +openmdao__openmdao-3516 +openmdao__openmdao-3519 +openmdao__openmdao-3522 +openmdao__openmdao-3543 +openmdao__openmdao-3566 +openmined__pysyft-113 +openmined__pysyft-122 +openmined__pysyft-188 +openmined__pysyft-216 +openmined__pysyft-232 +openmined__pysyft-233 +openmined__pysyft-237 +openmined__pysyft-240 +openmined__pysyft-250 +openmined__pysyft-2549 +openmined__pysyft-2612 +openmined__pysyft-391 +openmined__pysyft-392 +openmined__pysyft-396 +openmls__openmls-1495 +opennmt__opennmt-tf-515 +opennmt__opennmt-tf-525 +opennmt__opennmt-tf-527 +openownership__data-standard-610 +openownership__data-standard-624 +openownership__data-standard-644 +openpubkey__openpubkey-277 +opensearch-project__opensearch-go-128 +opensearch-project__opensearch-go-338 +opensearch-project__opensearch-go-496 +opensearch-project__opensearch-go-540 +opensearch-project__opensearch-go-543 +opensearch-project__opensearch-go-592 +opensearch-project__opensearch-php-140 +opensearch-project__opensearch-php-160 +opensearch-project__opensearch-php-177 +opensearch-project__opensearch-php-273 +opensearch-project__opensearch-php-292 +opensearch-project__opensearch-php-316 +opensearch-project__opensearch-py-226 +opensearch-project__opensearch-py-268 +opensearch-project__opensearch-py-394 +opensearch-project__opensearch-py-601 +opensearch-project__opensearch-py-780 +opensearch-project__opensearch-py-804 +opensearch-project__opensearch-py-843 +opensearch-project__opensearch-py-863 +openservicemesh__osm-4341 +openservicemesh__osm-5224 +openservicemesh__osm-5245 +openservicemesh__osm-5251 +opensheetmusicdisplay__opensheetmusicdisplay-1427 +openshift-pipelines__pipelines-as-code-104 +openshift-pipelines__pipelines-as-code-116 +openshift-pipelines__pipelines-as-code-137 +openshift-pipelines__pipelines-as-code-628 +openshift-pipelines__pipelines-as-code-93 +openshift__odo-5208 +opensistemas-hub__osbrain-281 +opentable__oc-722 +openvinotoolkit__datumaro-1138 +openwisp__netjsonconfig-315 +openwisp__netjsonconfig-320 +openwisp__netjsonconfig-323 +openwisp__netjsonconfig-325 +openwisp__netjsonconfig-343 +openyurtio__openyurt-950 +openzeppelin__rust-contracts-stylus-116 +openzeppelin__rust-contracts-stylus-126 +openzeppelin__rust-contracts-stylus-130 +openzeppelin__rust-contracts-stylus-132 +openzeppelin__rust-contracts-stylus-147 +openzeppelin__rust-contracts-stylus-150 +openziti__edge-1580 +operator-framework__operator-controller-1885 +operator-framework__operator-lifecycle-manager-2215 +operator-framework__operator-lifecycle-manager-3106 +operator-framework__operator-lifecycle-manager-3166 +operator-framework__operator-sdk-4997 +operator-framework__operator-sdk-5042 +operator-framework__operator-sdk-5585 +operator-framework__operator-sdk-6546 +opossum-tool__opossumui-2378 +opossum-tool__opossumui-2503 +opossum-tool__opossumui-2603 +opossum-tool__opossumui-2617 +oragono__oragono-1006 +oragono__oragono-1087 +oragono__oragono-1400 +oragono__oragono-1474 +oragono__oragono-800 +oras-project__oras-696 +oras-project__oras-745 +oras-project__oras-765 +oras-project__oras-go-360 +oras-project__oras-go-728 +ordinals__ord-3566 +ordinals__ord-3656 +ordinals__ord-3659 +ordinals__ord-4041 +ordinals__ord-4063 +ordinals__ord-4065 +ordo-one__package-benchmark-20 +ordo-one__package-benchmark-274 +ordo-one__package-benchmark-67 +ordo-one__package-benchmark-97 +orhun__git-cliff-114 +orhun__git-cliff-58 +orhun__git-cliff-94 +orhun__git-cliff-97 +ory__fosite-518 +ory__fosite-579 +ory__fosite-638 +ory__fosite-649 +ory__fosite-759 +ory__fosite-793 +ory__kratos-183 +osbuild__osbuild-2038 +osbuild__osbuild-composer-197 +osbuild__osbuild-composer-2351 +osbuild__osbuild-composer-3132 +osbuild__osbuild-composer-374 +osbuild__osbuild-composer-922 +oscal-compass__compliance-trestle-1534 +oscal-compass__compliance-trestle-1536 +oscal-compass__compliance-trestle-1573 +oscal-compass__compliance-trestle-1577 +oscal-compass__compliance-trestle-1578 +oscal-compass__compliance-trestle-1584 +oscal-compass__compliance-trestle-1594 +oscal-compass__compliance-trestle-1695 +oscal-compass__compliance-trestle-1801 +osmlab__maproulette3-1832 +osmosis-labs__mesh-security-125 +osmosis-labs__mesh-security-144 +osmosis-labs__mesh-security-162 +osmosis-labs__mesh-security-164 +osmosis-labs__mesh-security-167 +osmosis-labs__mesh-security-42 +osmosis-labs__mesh-security-78 +osmosis-labs__mesh-security-79 +osmosis-labs__mesh-security-94 +ossf__package-analysis-338 +ossf__package-analysis-525 +ossf__package-analysis-728 +ossf__package-analysis-838 +ossf__package-analysis-839 +ossf__package-feeds-301 +ossf__package-feeds-383 +ota-meshi__eslint-plugin-astro-220 +ota-meshi__eslint-plugin-astro-292 +ota-meshi__eslint-plugin-astro-324 +ota-meshi__eslint-plugin-astro-372 +ota-meshi__eslint-plugin-astro-423 +ota-meshi__eslint-plugin-regexp-235 +ota-meshi__eslint-plugin-regexp-244 +ota-meshi__eslint-plugin-regexp-249 +ota-meshi__eslint-plugin-regexp-257 +ota-meshi__eslint-plugin-regexp-268 +ota-meshi__eslint-plugin-regexp-269 +ota-meshi__eslint-plugin-regexp-276 +ota-meshi__eslint-plugin-regexp-279 +ota-meshi__eslint-plugin-regexp-281 +ota-meshi__eslint-plugin-regexp-285 +ota-meshi__eslint-plugin-regexp-288 +ota-meshi__eslint-plugin-regexp-306 +ota-meshi__eslint-plugin-regexp-319 +ota-meshi__eslint-plugin-regexp-327 +ota-meshi__eslint-plugin-regexp-335 +ota-meshi__eslint-plugin-regexp-338 +ota-meshi__eslint-plugin-regexp-343 +ota-meshi__eslint-plugin-regexp-345 +ota-meshi__eslint-plugin-regexp-350 +ota-meshi__eslint-plugin-regexp-351 +ota-meshi__eslint-plugin-regexp-404 +ota-meshi__eslint-plugin-regexp-406 +ota-meshi__eslint-plugin-regexp-474 +ota-meshi__eslint-plugin-regexp-482 +ota-meshi__eslint-plugin-regexp-616 +ota-meshi__eslint-plugin-regexp-639 +ota-meshi__eslint-plugin-regexp-646 +ota-meshi__eslint-plugin-regexp-663 +ota-meshi__eslint-plugin-regexp-666 +ota-meshi__eslint-plugin-regexp-689 +ota-meshi__eslint-plugin-regexp-715 +ota-meshi__eslint-plugin-regexp-722 +ota-meshi__eslint-plugin-regexp-835 +ota-meshi__eslint-plugin-svelte-240 +ota-meshi__eslint-plugin-svelte-261 +ota-meshi__eslint-plugin-svelte-302 +ota-meshi__eslint-plugin-svelte-308 +ota-meshi__eslint-plugin-svelte-354 +ota-meshi__eslint-plugin-svelte-365 +ota-meshi__eslint-plugin-svelte-387 +ota-meshi__eslint-plugin-svelte-394 +otiai10__copy-108 +otiai10__copy-54 +otiai10__copy-84 +ouch-org__ouch-125 +ouch-org__ouch-150 +ouch-org__ouch-215 +ouch-org__ouch-502 +ouch-org__ouch-519 +ouch-org__ouch-522 +ouch-org__ouch-570 +ouch-org__ouch-64 +ouch-org__ouch-692 +ouch-org__ouch-765 +ouch-org__ouch-782 +ouch-org__ouch-94 +ouranosinc__xclim-339 +ovh__cds-5463 +ovh__cds-5464 +ovn-org__libovsdb-103 +ovn-org__libovsdb-104 +ovn-org__libovsdb-176 +ovn-org__libovsdb-194 +ovn-org__libovsdb-305 +ovn-org__libovsdb-315 +owkin__pydeseq2-127 +owkin__pydeseq2-131 +owkin__pydeseq2-133 +owkin__pydeseq2-139 +owkin__pydeseq2-175 +owkin__pydeseq2-268 +owkin__pydeseq2-349 +owkin__pydeseq2-356 +owncloud__ocis-3201 +owncloud__ocis-3656 +owncloud__ocis-3725 +owncloud__ocis-4331 +owncloud__ocis-5343 +owncloud__ocis-5363 +owncloud__ocis-5388 +owncloud__ocis-5392 +owncloud__ocis-5588 +owncloud__ocis-5836 +oxc-project__oxc-resolver-102 +oxc-project__oxc-resolver-165 +oxc-project__oxc-resolver-450 +oxc-project__oxc-resolver-476 +oxc-project__oxc-resolver-482 +oxc-project__oxc-resolver-572 +oxidecomputer__typify-228 +oxidecomputer__typify-447 +oxidecomputer__typify-448 +oxidecomputer__typify-458 +oxidecomputer__typify-500 +oxidecomputer__typify-540 +oxidecomputer__typify-575 +oxidecomputer__typify-608 +oxidecomputer__typify-637 +oxidecomputer__typify-733 +oxidecomputer__typify-817 +ozontech__file.d-695 +ozontech__file.d-716 +ozontech__file.d-795 +pablosanjose__quantica.jl-101 +pablosanjose__quantica.jl-18 +packit__packit-2556 +packit__packit-2589 +packit__packit-2604 +pactumjs__pactum-110 +pactumjs__pactum-124 +pactumjs__pactum-236 +pactumjs__pactum-288 +pactumjs__pactum-329 +pactumjs__pactum-331 +pactumjs__pactum-341 +pactumjs__pactum-56 +pactus-project__pactus-574 +pactus-project__pactus-669 +pagerduty__go-pagerduty-448 +pagerduty__go-pagerduty-459 +painterqubits__unitful.jl-298 +painterqubits__unitful.jl-335 +painterqubits__unitful.jl-468 +painterqubits__unitful.jl-478 +painterqubits__unitful.jl-491 +painterqubits__unitful.jl-533 +painterqubits__unitful.jl-608 +painterqubits__unitful.jl-626 +painterqubits__unitful.jl-646 +painterqubits__unitful.jl-648 +painterqubits__unitful.jl-711 +painterqubits__unitful.jl-715 +painterqubits__unitful.jl-745 +painterqubits__unitful.jl-752 +painterqubits__unitful.jl-754 +painterqubits__unitful.jl-782 +painterqubits__unitful.jl-783 +painterqubits__unitful.jl-791 +palantir__bulldozer-370 +palantir__policy-bot-220 +palantir__policy-bot-243 +palantir__policy-bot-251 +palantir__policy-bot-257 +palantir__policy-bot-300 +palantir__policy-bot-302 +palantir__policy-bot-447 +palantir__policy-bot-575 +palantir__policy-bot-599 +palantir__policy-bot-823 +palantir__policy-bot-935 +palantir__policy-bot-938 +palantir__policy-bot-942 +palantir__python-language-server-754 +palantir__python-language-server-801 +palantir__python-language-server-829 +palantir__python-language-server-885 +paleolimbot__rbbt-39 +paleolimbot__rbbt-44 +pallets__click-1455 +pallets__click-1481 +pallets__click-1543 +pallets__click-1549 +pallets__click-1566 +pallets__click-1594 +pallets__click-1604 +pallets__click-1606 +pallets__click-1609 +pallets__click-1614 +pallets__click-1615 +pallets__click-1617 +pallets__click-1630 +pallets__click-1679 +pallets__click-1693 +pallets__click-1695 +pallets__click-1698 +pallets__click-1709 +pallets__click-1755 +pallets__click-1803 +pallets__click-1804 +pallets__click-1805 +pallets__click-1807 +pallets__click-1816 +pallets__click-1822 +pallets__click-1830 +pallets__click-1836 +pallets__click-1840 +pallets__click-1848 +pallets__click-1850 +pallets__click-1852 +pallets__click-1896 +pallets__click-1910 +pallets__click-1913 +pallets__click-1915 +pallets__click-1916 +pallets__click-1930 +pallets__click-1934 +pallets__click-1964 +pallets__click-1970 +pallets__click-1990 +pallets__click-1998 +pallets__click-2006 +pallets__click-2041 +pallets__click-2203 +pallets__click-2217 +pallets__click-2219 +pallets__click-2223 +pallets__click-2248 +pallets__click-2271 +pallets__click-2312 +pallets__click-2333 +pallets__click-2365 +pallets__click-2369 +pallets__click-2380 +pallets__click-2397 +pallets__click-2417 +pallets__click-2517 +pallets__click-2555 +pallets__click-2604 +pallets__click-2622 +pallets__click-2696 +pallets__click-2727 +pallets__click-2728 +pallets__click-2730 +pallets__click-2788 +pallets__click-2796 +pallets__click-2800 +pallets__click-2840 +pallets__click-2935 +pallets__jinja-1444 +pallets__jinja-1449 +pallets__jinja-1455 +pallets__jinja-1465 +pallets__jinja-1495 +pallets__jinja-1511 +pallets__jinja-1522 +pallets__jinja-1559 +pallets__jinja-1613 +pallets__jinja-1614 +pallets__jinja-1663 +pallets__jinja-1664 +pallets__jinja-1665 +pallets__jinja-1702 +pallets__jinja-1706 +pallets__jinja-1762 +pallets__jinja-1782 +pallets__jinja-1852 +pallets__jinja-1984 +pallets__jinja-2022 +pallets__jinja-2026 +pallets__jinja-2029 +pallets__jinja-2033 +pallets__werkzeug-2126 +pallets__werkzeug-2133 +pallets__werkzeug-2136 +pallets__werkzeug-2161 +pallets__werkzeug-2193 +pallets__werkzeug-2194 +pallets__werkzeug-2206 +pallets__werkzeug-2248 +pallets__werkzeug-2306 +pallets__werkzeug-2307 +pallets__werkzeug-2338 +pallets__werkzeug-2355 +pallets__werkzeug-2365 +pallets__werkzeug-2402 +pallets__werkzeug-2413 +pallets__werkzeug-2442 +pallets__werkzeug-2472 +pallets__werkzeug-2497 +pallets__werkzeug-2535 +pallets__werkzeug-2551 +pallets__werkzeug-2583 +pallets__werkzeug-2596 +pallets__werkzeug-2612 +pallets__werkzeug-2614 +pallets__werkzeug-2615 +pallets__werkzeug-2639 +pallets__werkzeug-2655 +pallets__werkzeug-2661 +pallets__werkzeug-2663 +pallets__werkzeug-2666 +pallets__werkzeug-2673 +pallets__werkzeug-2686 +pallets__werkzeug-2692 +pallets__werkzeug-2709 +pallets__werkzeug-2718 +pallets__werkzeug-2723 +pallets__werkzeug-2753 +pallets__werkzeug-2763 +pallets__werkzeug-2771 +pallets__werkzeug-2777 +pallets__werkzeug-2843 +pallets__werkzeug-2864 +pallets__werkzeug-2882 +pallets__werkzeug-2894 +pallets__werkzeug-2902 +pallets__werkzeug-2938 +pallets__werkzeug-2949 +pallets__werkzeug-2956 +pallets__werkzeug-2971 +pallets__werkzeug-2975 +pallets__werkzeug-2979 +pallets__werkzeug-2981 +pallets__werkzeug-2986 +pallets__werkzeug-2995 +pallets__werkzeug-2997 +pandas-dev__pandas-50440 +pandas-dev__pandas-50516 +pandas-dev__pandas-50561 +pandas-dev__pandas-51189 +pandas-dev__pandas-51715 +pandas-dev__pandas-53769 +pandas-dev__pandas-54460 +pandas-dev__pandas-54643 +pandas-dev__pandas-55249 +pandas-dev__pandas-55257 +pandas-dev__pandas-55270 +pandas-dev__pandas-55472 +pandas-dev__pandas-55518 +pandas-dev__pandas-55690 +pandas-dev__pandas-55691 +pandas-dev__pandas-55844 +pandas-dev__pandas-56038 +pandas-dev__pandas-56095 +pandas-dev__pandas-56120 +pandas-dev__pandas-56194 +pandas-dev__pandas-56321 +pandas-dev__pandas-56419 +pandas-dev__pandas-56457 +pandas-dev__pandas-56458 +pandas-dev__pandas-56487 +pandas-dev__pandas-56522 +pandas-dev__pandas-56523 +pandas-dev__pandas-56558 +pandas-dev__pandas-56585 +pandas-dev__pandas-56688 +pandas-dev__pandas-56758 +pandas-dev__pandas-56766 +pandas-dev__pandas-56767 +pandas-dev__pandas-56769 +pandas-dev__pandas-56771 +pandas-dev__pandas-56788 +pandas-dev__pandas-56802 +pandas-dev__pandas-56808 +pandas-dev__pandas-56822 +pandas-dev__pandas-56849 +pandas-dev__pandas-56906 +pandas-dev__pandas-56926 +pandas-dev__pandas-56937 +pandas-dev__pandas-56943 +pandas-dev__pandas-57058 +pandas-dev__pandas-57061 +pandas-dev__pandas-57084 +pandas-dev__pandas-57089 +pandas-dev__pandas-57102 +pandas-dev__pandas-57116 +pandas-dev__pandas-57139 +pandas-dev__pandas-57157 +pandas-dev__pandas-57173 +pandas-dev__pandas-57174 +pandas-dev__pandas-57314 +pandas-dev__pandas-57323 +pandas-dev__pandas-57372 +pandas-dev__pandas-57375 +pandas-dev__pandas-57426 +pandas-dev__pandas-57471 +pandas-dev__pandas-57474 +pandas-dev__pandas-57518 +pandas-dev__pandas-57570 +pandas-dev__pandas-57648 +pandas-dev__pandas-57665 +pandas-dev__pandas-57697 +pandas-dev__pandas-57754 +pandas-dev__pandas-57779 +pandas-dev__pandas-57916 +pandas-dev__pandas-57938 +pandas-dev__pandas-57958 +pandas-dev__pandas-57974 +pandas-dev__pandas-58091 +pandas-dev__pandas-58148 +pandas-dev__pandas-58226 +pandas-dev__pandas-58231 +pandas-dev__pandas-58245 +pandas-dev__pandas-58249 +pandas-dev__pandas-58254 +pandas-dev__pandas-58301 +pandas-dev__pandas-58349 +pandas-dev__pandas-58817 +pandas-dev__pandas-58876 +pandas-dev__pandas-58886 +pandas-dev__pandas-58893 +pandas-dev__pandas-58970 +pandas-dev__pandas-58985 +pandas-dev__pandas-59021 +pandas-dev__pandas-59069 +pandas-dev__pandas-59071 +pandas-dev__pandas-59080 +pandas-dev__pandas-59102 +pandas-dev__pandas-59117 +pandas-dev__pandas-59123 +pandas-dev__pandas-59144 +pandas-dev__pandas-59214 +pandas-dev__pandas-59258 +pandas-dev__pandas-59262 +pandas-dev__pandas-59268 +pandas-dev__pandas-59284 +pandas-dev__pandas-59318 +pandas-dev__pandas-59337 +pandas-dev__pandas-59392 +pandas-dev__pandas-59398 +pandas-dev__pandas-59427 +pandas-dev__pandas-59434 +pandas-dev__pandas-59435 +pandas-dev__pandas-59439 +pandas-dev__pandas-59552 +pandas-dev__pandas-59566 +pandas-dev__pandas-59608 +pandas-dev__pandas-59624 +pandas-dev__pandas-59745 +pandas-dev__pandas-59900 +pandas-dev__pandas-59909 +pandas-dev__pandas-59964 +pandas-dev__pandas-59966 +pandas-dev__pandas-59967 +pandas-dev__pandas-59971 +pandas-dev__pandas-59974 +pandas-dev__pandas-59999 +pandas-dev__pandas-60029 +pandas-dev__pandas-60047 +pandas-dev__pandas-60081 +pandas-dev__pandas-60103 +pandas-dev__pandas-60112 +pandas-dev__pandas-60172 +pandas-dev__pandas-60182 +pandas-dev__pandas-60209 +pandas-dev__pandas-60211 +pandas-dev__pandas-60230 +pandas-dev__pandas-60251 +pandas-dev__pandas-60310 +pandas-dev__pandas-60311 +pandas-dev__pandas-60356 +pandas-dev__pandas-60359 +pandas-dev__pandas-60374 +pandas-dev__pandas-60417 +pandas-dev__pandas-60459 +pandas-dev__pandas-60505 +pandas-dev__pandas-60510 +pandas-dev__pandas-60526 +pandas-dev__pandas-60527 +pandas-dev__pandas-60574 +pandas-dev__pandas-60898 +pandas-dev__pandas-60985 +pandas-dev__pandas-61041 +pandas-dev__pandas-61116 +pandas-dev__pandas-61154 +pandas-dev__pandas-61193 +pandas-dev__pandas-61207 +pandas-dev__pandas-61225 +pandas-dev__pandas-61238 +pandas-dev__pandas-61244 +pandas-dev__pandas-61249 +pandas-dev__pandas-61257 +pandas-dev__pandas-61264 +pandas-dev__pandas-61283 +pandas-dev__pandas-61308 +pandas-dev__pandas-61364 +pandas-dev__pandas-61376 +pandas-dev__pandas-61393 +pandas-dev__pandas-61399 +pandas-dev__pandas-61400 +pandas-dev__pandas-61459 +pandas-dev__pandas-61463 +pandas-dev__pandas-61577 +pandas-dev__pandas-61600 +pandas-dev__pandas-61629 +pandas-dev__pandas-61876 +pandas-dev__pandas-61883 +pangeo-forge__pangeo-forge-recipes-595 +paritytech__ink-2100 +paritytech__ink-341 +paritytech__parity-common-554 +paritytech__parity-common-559 +paritytech__parity-common-572 +paritytech__parity-common-667 +paritytech__parity-common-766 +parkmycar__compact_str-15 +parkmycar__compact_str-20 +parmed__parmed-1233 +parmed__parmed-1376 +parquery__icontract-236 +parquery__icontract-292 +parquery__icontract-297 +parquet-go__parquet-go-115 +parquet-go__parquet-go-126 +parquet-go__parquet-go-131 +parquet-go__parquet-go-147 +parquet-go__parquet-go-195 +parquet-go__parquet-go-201 +parquet-go__parquet-go-248 +parquet-go__parquet-go-292 +parquet-go__parquet-go-296 +parquet-go__parquet-go-31 +parquet-go__parquet-go-72 +parroty__excoveralls-141 +parroty__excoveralls-198 +parroty__excoveralls-325 +parse-community__parse-sdk-js-1301 +parse-community__parse-sdk-js-1351 +parse-community__parse-sdk-js-1578 +parse-community__parse-sdk-js-1610 +parse-community__parse-sdk-js-382 +parse-community__parse-sdk-js-868 +parse-community__parse-swift-144 +parse-community__parse-swift-165 +parse-community__parse-swift-238 +parse-community__parse-swift-241 +parse-community__parse-swift-248 +parse-community__parse-swift-250 +parse-community__parse-swift-381 +parsely__pykafka-656 +parsely__pykafka-757 +pashagolub__pgxmock-113 +pashagolub__pgxmock-115 +pashagolub__pgxmock-117 +pashagolub__pgxmock-134 +pashagolub__pgxmock-136 +pashagolub__pgxmock-137 +pashagolub__pgxmock-148 +pashagolub__pgxmock-182 +pashagolub__pgxmock-208 +pashagolub__pgxmock-23 +pashagolub__pgxmock-230 +pashagolub__pgxmock-74 +passsy__kt.dart-140 +passsy__kt.dart-163 +passsy__kt.dart-170 +passsy__kt.dart-173 +passsy__kt.dart-178 +passsy__kt.dart-183 +passsy__kt.dart-190 +passsy__kt.dart-197 +passsy__kt.dart-198 +patchlevel__event-sourcing-42 +patrick-kidger__equinox-1018 +patrick-kidger__equinox-975 +patrick-kidger__equinox-993 +patrickhoefler__dockerfilegraph-290 +paularmstrong__build-tracker-127 +paularmstrong__build-tracker-154 +paularmstrong__build-tracker-155 +paularmstrong__build-tracker-156 +paularmstrong__build-tracker-165 +paularmstrong__build-tracker-181 +paularmstrong__build-tracker-182 +paularmstrong__build-tracker-184 +paularmstrong__build-tracker-189 +paularmstrong__build-tracker-208 +paustint__soql-parser-js-101 +paustint__soql-parser-js-105 +paustint__soql-parser-js-114 +paustint__soql-parser-js-141 +paustint__soql-parser-js-146 +paustint__soql-parser-js-156 +paustint__soql-parser-js-158 +paustint__soql-parser-js-161 +paustint__soql-parser-js-189 +paustint__soql-parser-js-22 +paustint__soql-parser-js-31 +paustint__soql-parser-js-32 +paustint__soql-parser-js-38 +paustint__soql-parser-js-41 +paustint__soql-parser-js-60 +paustint__soql-parser-js-68 +paustint__soql-parser-js-82 +paustint__soql-parser-js-84 +paustint__soql-parser-js-86 +paustint__soql-parser-js-88 +paustint__soql-parser-js-93 +paustint__soql-parser-js-99 +payjoin__rust-payjoin-546 +payjoin__rust-payjoin-586 +payjoin__rust-payjoin-642 +payjoin__rust-payjoin-669 +payjoin__rust-payjoin-700 +pbiswas101__mathball-100 +pbiswas101__mathball-102 +pbiswas101__mathball-103 +pbiswas101__mathball-105 +pbiswas101__mathball-114 +pbiswas101__mathball-125 +pbiswas101__mathball-126 +pbiswas101__mathball-130 +pbiswas101__mathball-131 +pbiswas101__mathball-133 +pbiswas101__mathball-137 +pbiswas101__mathball-145 +pbiswas101__mathball-153 +pbiswas101__mathball-154 +pbiswas101__mathball-16 +pbiswas101__mathball-163 +pbiswas101__mathball-178 +pbiswas101__mathball-201 +pbiswas101__mathball-203 +pbiswas101__mathball-212 +pbiswas101__mathball-48 +pbiswas101__mathball-56 +pbiswas101__mathball-79 +pbiswas101__mathball-83 +pbiswas101__mathball-85 +pbiswas101__mathball-86 +pbiswas101__mathball-88 +pbiswas101__mathball-90 +pbiswas101__mathball-99 +pdfminer__pdfminer.six-321 +pdfminer__pdfminer.six-330 +pdfminer__pdfminer.six-335 +pdm-project__pdm-1628 +pdm-project__pdm-1632 +pdm-project__pdm-1889 +pdm-project__pdm-2123 +pdm-project__pdm-2215 +pdm-project__pdm-2323 +pdm-project__pdm-2781 +pdm-project__pdm-2795 +pdm-project__pdm-3456 +pdm-project__pdm-3463 +pdm-project__pdm-3575 +peak__s5cmd-128 +peak__s5cmd-129 +peak__s5cmd-135 +peak__s5cmd-163 +peak__s5cmd-187 +peak__s5cmd-188 +peak__s5cmd-296 +peak__s5cmd-310 +peak__s5cmd-315 +peak__s5cmd-328 +peak__s5cmd-411 +peak__s5cmd-422 +peak__s5cmd-431 +peak__s5cmd-457 +peak__s5cmd-470 +peak__s5cmd-578 +peak__s5cmd-582 +peak__s5cmd-587 +peak__s5cmd-593 +peak__s5cmd-597 +peak__s5cmd-599 +peak__s5cmd-658 +peak__s5cmd-730 +pebbletemplates__pebble-225 +pebbletemplates__pebble-368 +pebbletemplates__pebble-456 +pebbletemplates__pebble-482 +pebbletemplates__pebble-496 +pebbletemplates__pebble-529 +pebbletemplates__pebble-530 +pebbletemplates__pebble-541 +pebbletemplates__pebble-544 +pebbletemplates__pebble-549 +pebbletemplates__pebble-571 +peggyjs__peggy-624 +pennersr__django-allauth-3447 +pennersr__django-allauth-3785 +pennylaneai__pennylane-1072 +pennylaneai__pennylane-1168 +pennylaneai__pennylane-1260 +pennylaneai__pennylane-1319 +pennylaneai__pennylane-1320 +pennylaneai__pennylane-1325 +pennylaneai__pennylane-1329 +pennylaneai__pennylane-1353 +pennylaneai__pennylane-1357 +pennylaneai__pennylane-1371 +pennylaneai__pennylane-1405 +pennylaneai__pennylane-1411 +pennylaneai__pennylane-1464 +pennylaneai__pennylane-1532 +pennylaneai__pennylane-1568 +pennylaneai__pennylane-1585 +pennylaneai__pennylane-1638 +pennylaneai__pennylane-1830 +pennylaneai__pennylane-1884 +pennylaneai__pennylane-1892 +pennylaneai__pennylane-1929 +pennylaneai__pennylane-1946 +pennylaneai__pennylane-1948 +pennylaneai__pennylane-1980 +pennylaneai__pennylane-2030 +pennylaneai__pennylane-2057 +pennylaneai__pennylane-2060 +pennylaneai__pennylane-2096 +pennylaneai__pennylane-2238 +pennylaneai__pennylane-2266 +pennylaneai__pennylane-2286 +pennylaneai__pennylane-2395 +pennylaneai__pennylane-2478 +pennylaneai__pennylane-2525 +pennylaneai__pennylane-2542 +pennylaneai__pennylane-2543 +pennylaneai__pennylane-2591 +pennylaneai__pennylane-2601 +pennylaneai__pennylane-2603 +pennylaneai__pennylane-2651 +pennylaneai__pennylane-2654 +pennylaneai__pennylane-2834 +pennylaneai__pennylane-2947 +pennylaneai__pennylane-2964 +pennylaneai__pennylane-3024 +pennylaneai__pennylane-3033 +pennylaneai__pennylane-3057 +pennylaneai__pennylane-3104 +pennylaneai__pennylane-3181 +pennylaneai__pennylane-3182 +pennylaneai__pennylane-3206 +pennylaneai__pennylane-3266 +pennylaneai__pennylane-3278 +pennylaneai__pennylane-3369 +pennylaneai__pennylane-3381 +pennylaneai__pennylane-3386 +pennylaneai__pennylane-3477 +pennylaneai__pennylane-3483 +pennylaneai__pennylane-3579 +pennylaneai__pennylane-3624 +pennylaneai__pennylane-3744 +pennylaneai__pennylane-3753 +pennylaneai__pennylane-3876 +pennylaneai__pennylane-3920 +pennylaneai__pennylane-3921 +pennylaneai__pennylane-3983 +pennylaneai__pennylane-4161 +pennylaneai__pennylane-4251 +pennylaneai__pennylane-4295 +pennylaneai__pennylane-4343 +pennylaneai__pennylane-4366 +pennylaneai__pennylane-4421 +pennylaneai__pennylane-4441 +pennylaneai__pennylane-4540 +pennylaneai__pennylane-4663 +pennylaneai__pennylane-4736 +pennylaneai__pennylane-4749 +pennylaneai__pennylane-4781 +pennylaneai__pennylane-4800 +pennylaneai__pennylane-4827 +pennylaneai__pennylane-4831 +pennylaneai__pennylane-4837 +pennylaneai__pennylane-4884 +pennylaneai__pennylane-4899 +pennylaneai__pennylane-4993 +pennylaneai__pennylane-5063 +pennylaneai__pennylane-5277 +pennylaneai__pennylane-5407 +pennylaneai__pennylane-5448 +pennylaneai__pennylane-5455 +pennylaneai__pennylane-5582 +pennylaneai__pennylane-5623 +pennylaneai__pennylane-5725 +pennylaneai__pennylane-5761 +pennylaneai__pennylane-5773 +pennylaneai__pennylane-5781 +pennylaneai__pennylane-5793 +pennylaneai__pennylane-5831 +pennylaneai__pennylane-5835 +pennylaneai__pennylane-5851 +pennylaneai__pennylane-5857 +pennylaneai__pennylane-5860 +pennylaneai__pennylane-5866 +pennylaneai__pennylane-5920 +pennylaneai__pennylane-5926 +pennylaneai__pennylane-5986 +pennylaneai__pennylane-6049 +pennylaneai__pennylane-6062 +pennylaneai__pennylane-6107 +pennylaneai__pennylane-6147 +pennylaneai__pennylane-6358 +pennylaneai__pennylane-6398 +pennylaneai__pennylane-6423 +pennylaneai__pennylane-6622 +pennylaneai__pennylane-6732 +pennylaneai__pennylane-6738 +pennylaneai__pennylane-6779 +pennylaneai__pennylane-6821 +pennylaneai__pennylane-6933 +pennylaneai__pennylane-7025 +pennylaneai__pennylane-7121 +pennylaneai__pennylane-7163 +pennylaneai__pennylane-7164 +pennylaneai__pennylane-7474 +pennylaneai__pennylane-7668 +pennylaneai__pennylane-7671 +pennylaneai__pennylane-7757 +peopledoc__vault-cli-178 +peopledoc__workalendar-242 +peopledoc__workalendar-263 +peopledoc__workalendar-300 +peopledoc__workalendar-316 +peopledoc__workalendar-321 +peopledoc__workalendar-334 +peopledoc__workalendar-341 +peopledoc__workalendar-355 +peopledoc__workalendar-373 +peopledoc__workalendar-384 +peopledoc__workalendar-400 +peopledoc__workalendar-424 +peopledoc__workalendar-455 +peopledoc__workalendar-482 +peopledoc__workalendar-493 +peopledoc__workalendar-518 +peopledoc__workalendar-525 +peopledoc__workalendar-539 +peopledoc__workalendar-541 +peopledoc__workalendar-590 +peopledoc__workalendar-601 +pepakriz__phpstan-exception-rules-138 +perry-mitchell__webdav-client-334 +perry-mitchell__webdav-client-351 +perry-mitchell__webdav-client-364 +perry-mitchell__webdav-client-391 +pest-parser__pest-224 +pest-parser__pest-236 +petermattis__pebble-100 +petermattis__pebble-103 +petermattis__pebble-110 +petermattis__pebble-128 +petermattis__pebble-207 +petermattis__pebble-67 +petermattis__pebble-77 +petermattis__pebble-78 +petermattis__pebble-88 +petermattis__pebble-99 +pgjdbc__pgjdbc-1002 +pgjdbc__pgjdbc-1302 +pgjdbc__pgjdbc-1323 +pgjdbc__pgjdbc-1481 +pgjdbc__pgjdbc-1708 +pgjdbc__pgjdbc-985 +pgjdbc__pgjdbc-999 +pgmpy__pgmpy-717 +pgmpy__pgmpy-878 +pheature-flags__pheature-flags-153 +pheature-flags__pheature-flags-160 +pheature-flags__pheature-flags-167 +pheature-flags__pheature-flags-168 +pheature-flags__pheature-flags-181 +pheature-flags__pheature-flags-182 +pheature-flags__pheature-flags-194 +pheature-flags__pheature-flags-196 +pheature-flags__pheature-flags-207 +pheature-flags__pheature-flags-218 +pheature-flags__pheature-flags-220 +pheature-flags__pheature-flags-276 +pheature-flags__pheature-flags-277 +pheature-flags__pheature-flags-280 +phoenixframework__phoenix-4085 +phoenixframework__phoenix-4117 +phoenixframework__phoenix-4309 +phoenixframework__phoenix-5510 +phoenixframework__phoenix-5908 +phoenixframework__phoenix-5928 +phoenixframework__phoenix-6049 +phoenixframework__phoenix-6098 +phoenixframework__phoenix-6101 +phoenixframework__phoenix-6113 +phoenixframework__phoenix-6135 +phoenixframework__phoenix-6221 +phoenixframework__phoenix_html-263 +phoenixframework__phoenix_html-282 +phoenixframework__phoenix_html-309 +phoenixframework__phoenix_html-360 +php-cs-fixer__php-cs-fixer-5620 +php-cs-fixer__php-cs-fixer-7402 +php-cs-fixer__php-cs-fixer-7429 +php-cs-fixer__php-cs-fixer-7459 +php-cs-fixer__php-cs-fixer-7546 +php-cs-fixer__php-cs-fixer-7593 +php-cs-fixer__php-cs-fixer-7597 +php-cs-fixer__php-cs-fixer-7624 +php-cs-fixer__php-cs-fixer-7628 +php-cs-fixer__php-cs-fixer-7635 +php-cs-fixer__php-cs-fixer-7639 +php-cs-fixer__php-cs-fixer-7653 +php-cs-fixer__php-cs-fixer-7659 +php-cs-fixer__php-cs-fixer-7663 +php-cs-fixer__php-cs-fixer-7687 +php-cs-fixer__php-cs-fixer-7697 +php-cs-fixer__php-cs-fixer-7724 +php-cs-fixer__php-cs-fixer-7728 +php-cs-fixer__php-cs-fixer-7769 +php-cs-fixer__php-cs-fixer-7827 +php-cs-fixer__php-cs-fixer-7875 +php-cs-fixer__php-cs-fixer-7916 +php-cs-fixer__php-cs-fixer-7997 +php-cs-fixer__php-cs-fixer-8026 +php-cs-fixer__php-cs-fixer-8046 +php-cs-fixer__php-cs-fixer-8062 +php-cs-fixer__php-cs-fixer-8068 +php-cs-fixer__php-cs-fixer-8085 +php-cs-fixer__php-cs-fixer-8156 +php-cs-fixer__php-cs-fixer-8203 +php-cs-fixer__php-cs-fixer-8225 +php-cs-fixer__php-cs-fixer-8240 +php-cs-fixer__php-cs-fixer-8246 +php-cs-fixer__php-cs-fixer-8280 +php-cs-fixer__php-cs-fixer-8312 +php-cs-fixer__php-cs-fixer-8317 +php-cs-fixer__php-cs-fixer-8339 +php-cs-fixer__php-cs-fixer-8804 +php-di__php-di-775 +php-di__php-di-856 +php-di__php-di-862 +php__pie-43 +php__pie-46 +php__pie-53 +php__pie-59 +phpactor__phpactor-1379 +phpactor__phpactor-1422 +phpactor__phpactor-1464 +phpactor__phpactor-1668 +phpactor__phpactor-1678 +phpactor__phpactor-1713 +phpactor__phpactor-1783 +phpactor__phpactor-1834 +phpactor__phpactor-1857 +phpactor__phpactor-1863 +phpactor__phpactor-1872 +phpactor__phpactor-1886 +phpactor__phpactor-1917 +phpactor__phpactor-1919 +phpactor__phpactor-1945 +phpactor__phpactor-1964 +phpactor__phpactor-1977 +phpactor__phpactor-1993 +phpactor__phpactor-2039 +phpactor__phpactor-2040 +phpactor__phpactor-2044 +phpactor__phpactor-2065 +phpactor__phpactor-2066 +phpactor__phpactor-2101 +phpactor__phpactor-2170 +phpactor__phpactor-2194 +phpactor__phpactor-2204 +phpactor__phpactor-2205 +phpactor__phpactor-2206 +phpactor__phpactor-2208 +phpactor__phpactor-2222 +phpactor__phpactor-2225 +phpactor__phpactor-2241 +phpactor__phpactor-2249 +phpactor__phpactor-2272 +phpactor__phpactor-2273 +phpactor__phpactor-2275 +phpactor__phpactor-2276 +phpactor__phpactor-2277 +phpactor__phpactor-2290 +phpactor__phpactor-2306 +phpactor__phpactor-2310 +phpactor__phpactor-2372 +phpactor__phpactor-2406 +phpactor__phpactor-2440 +phpactor__phpactor-2471 +phpactor__phpactor-2699 +phpactor__phpactor-2810 +phpactor__phpactor-2824 +phpbench__phpbench-1010 +phpbench__phpbench-1098 +phpbench__phpbench-740 +phpbench__phpbench-814 +phpbench__phpbench-823 +phpbench__phpbench-833 +phpbench__phpbench-846 +phpbench__phpbench-911 +phpbench__phpbench-914 +phpbench__phpbench-932 +phpbench__phpbench-971 +phpcsstandards__php_codesniffer-209 +phpcsstandards__php_codesniffer-771 +phpmd__phpmd-1193 +phpmd__phpmd-1197 +phpoffice__phpspreadsheet-4073 +phpoffice__phpspreadsheet-4076 +phpoffice__phpspreadsheet-4080 +phpoffice__phpspreadsheet-4088 +phpoffice__phpspreadsheet-4114 +phpoffice__phpspreadsheet-4115 +phpoffice__phpspreadsheet-4132 +phpoffice__phpspreadsheet-4151 +phpoffice__phpspreadsheet-4184 +phpoffice__phpspreadsheet-4185 +phpoffice__phpspreadsheet-4187 +phpoffice__phpspreadsheet-4188 +phpoffice__phpspreadsheet-4202 +phpoffice__phpspreadsheet-4203 +phpoffice__phpspreadsheet-4207 +phpoffice__phpspreadsheet-4212 +phpoffice__phpspreadsheet-4214 +phpoffice__phpspreadsheet-4224 +phpoffice__phpspreadsheet-4244 +phpoffice__phpspreadsheet-4247 +phpoffice__phpspreadsheet-4271 +phpoffice__phpspreadsheet-4302 +phpoffice__phpspreadsheet-4313 +phpoffice__phpspreadsheet-4320 +phpoffice__phpspreadsheet-4322 +phpoffice__phpspreadsheet-4326 +phpoffice__phpspreadsheet-4333 +phpoffice__phpspreadsheet-4340 +phpoffice__phpspreadsheet-4351 +phpoffice__phpspreadsheet-4354 +phpoffice__phpspreadsheet-4355 +phpoffice__phpspreadsheet-4361 +phpoffice__phpspreadsheet-4366 +phpoffice__phpspreadsheet-4382 +phpoffice__phpspreadsheet-4389 +phpoffice__phpspreadsheet-4414 +phpoffice__phpspreadsheet-4424 +phpoffice__phpspreadsheet-4449 +phpoffice__phpspreadsheet-4450 +phpoffice__phpspreadsheet-4453 +phpoffice__phpspreadsheet-4465 +phpoffice__phpspreadsheet-4466 +phpoffice__phpspreadsheet-4468 +phpoffice__phpspreadsheet-4478 +phpoffice__phpspreadsheet-4487 +phpoffice__phpspreadsheet-4489 +phpoffice__phpspreadsheet-4535 +phpoffice__phpspreadsheet-4536 +phpoffice__phpspreadsheet-4541 +phpstan__phpstan-doctrine-404 +phpstan__phpstan-doctrine-497 +phpstan__phpstan-doctrine-543 +phpstan__phpstan-doctrine-622 +phpstan__phpstan-doctrine-656 +pilosa__pilosa-2084 +pilosus__pip-license-checker-103 +pilosus__pip-license-checker-110 +pilosus__pip-license-checker-119 +pilosus__pip-license-checker-121 +pilosus__pip-license-checker-133 +pilosus__pip-license-checker-135 +pilosus__pip-license-checker-156 +pilosus__pip-license-checker-24 +pilosus__pip-license-checker-26 +pilosus__pip-license-checker-32 +pilosus__pip-license-checker-34 +pilosus__pip-license-checker-48 +pilosus__pip-license-checker-49 +pilosus__pip-license-checker-53 +pilosus__pip-license-checker-54 +pilosus__pip-license-checker-59 +pilosus__pip-license-checker-62 +pilosus__pip-license-checker-69 +pilosus__pip-license-checker-71 +pilosus__pip-license-checker-76 +pilosus__pip-license-checker-97 +pimutils__khal-1153 +pimutils__todoman-108 +pimutils__todoman-170 +pimutils__todoman-189 +pimutils__todoman-197 +pimutils__todoman-21 +pimutils__todoman-236 +pimutils__todoman-299 +pimutils__todoman-541 +pingcap__dumpling-110 +pingcap__dumpling-111 +pingcap__dumpling-121 +pingcap__dumpling-156 +pingcap__dumpling-166 +pingcap__dumpling-333 +pingcap__pd-1951 +pingcap__pd-795 +pingcap__tidb-48564 +pingcap__tidb-48579 +pingcap__tidb-50304 +pingcap__tidb-57164 +pingcap__tidb-58594 +pingcap__tidb-60293 +pingcap__tidb-60363 +pingcap__tidb-60703 +pingcap__tidb-60705 +pingcap__tidb-61890 +pingcap__tidb-61891 +pingcap__tidb-62028 +pingcap__tidb-62032 +pingcap__tidb-62049 +pingcap__tidb-62341 +pingcap__tidb-binlog-1089 +pingcap__tidb-lightning-283 +pingcap__tidb-lightning-468 +pingcap__tidb-lightning-508 +pingcap__tidb-tools-837 +pingcap__tidb-tools-857 +pingcap__tiflow-11708 +pingcap__tiflow-12236 +pingcap__tiflow-12254 +pingcap__tiflow-4060 +pingcap__tiproxy-820 +pingcap__tiproxy-821 +pingcap__tiproxy-826 +pingcap__tiproxy-827 +pingcap__tiproxy-832 +pinojs__hapi-pino-103 +pinojs__hapi-pino-116 +pinojs__hapi-pino-156 +pinojs__hapi-pino-16 +pinojs__hapi-pino-182 +pinojs__hapi-pino-45 +pinojs__hapi-pino-96 +pinojs__pino-1127 +pinojs__pino-1137 +pinojs__pino-1199 +pinojs__pino-121 +pinojs__pino-141 +pinojs__pino-1503 +pinojs__pino-1565 +pinojs__pino-1566 +pinojs__pino-157 +pinojs__pino-1629 +pinojs__pino-169 +pinojs__pino-181 +pinojs__pino-196 +pinojs__pino-2014 +pinojs__pino-210 +pinojs__pino-244 +pinojs__pino-247 +pinojs__pino-258 +pinojs__pino-374 +pinojs__pino-419 +pinojs__pino-457 +pinojs__pino-482 +pinojs__pino-503 +pinojs__pino-513 +pinojs__pino-585 +pinojs__pino-604 +pinojs__pino-616 +pinojs__pino-635 +pinojs__pino-637 +pinojs__pino-721 +pinojs__pino-740 +pinojs__pino-852 +pinojs__pino-875 +pinojs__pino-876 +pinojs__pino-885 +pinojs__pino-893 +pinojs__pino-904 +pinojs__pino-924 +pinojs__pino-936 +pinojs__pino-http-121 +pinojs__pino-pretty-316 +pinojs__pino-pretty-501 +pints-team__pints-1444 +pion__dtls-90 +pion__ice-119 +pion__ice-17 +pion__ice-18 +pion__ice-256 +pion__ice-263 +pion__ice-34 +pion__ice-353 +pion__ice-42 +pion__ice-441 +pion__ice-497 +pion__ice-53 +pion__ice-695 +pion__interceptor-132 +pion__interceptor-155 +pion__interceptor-184 +pion__interceptor-195 +pion__interceptor-249 +pion__interceptor-254 +pion__interceptor-291 +pion__interceptor-92 +pion__mediadevices-132 +pion__mediadevices-168 +pion__mediadevices-55 +pion__mediadevices-75 +pion__rtp-237 +pion__rtp-305 +pion__rtp-316 +pion__sctp-183 +pion__sctp-238 +pion__sctp-241 +pion__sctp-303 +pion__turn-110 +pion__turn-243 +pion__turn-258 +pion__turn-300 +pion__turn-371 +pion__turn-85 +pion__turn-86 +pion__turn-90 +pion__webrtc-1467 +pion__webrtc-1527 +pion__webrtc-1572 +pion__webrtc-1619 +pion__webrtc-1673 +pion__webrtc-1721 +pion__webrtc-1755 +pion__webrtc-1848 +pion__webrtc-1920 +pion__webrtc-1930 +pion__webrtc-2242 +pion__webrtc-2317 +pion__webrtc-2442 +pion__webrtc-2555 +pion__webrtc-2696 +pion__webrtc-2786 +pion__webrtc-2840 +pion__webrtc-2950 +pion__webrtc-3016 +pion__webrtc-3066 +pion__webrtc-572 +pions__webrtc-407 +pions__webrtc-426 +pions__webrtc-543 +pions__webrtc-567 +pipxproject__pipx-398 +pipxproject__pipx-425 +pipxproject__pipx-448 +pipxproject__pipx-462 +pipxproject__pipx-514 +pipxproject__pipx-516 +pipxproject__pipx-530 +pipxproject__pipx-531 +pipxproject__pipx-674 +pipxproject__pipx-680 +piranhacloud__piranha-482 +pires__go-proxyproto-37 +pires__go-proxyproto-48 +pires__go-proxyproto-51 +pires__go-proxyproto-61 +pires__go-proxyproto-71 +pires__go-proxyproto-76 +pires__go-proxyproto-96 +piskvorky__smart_open-25 +piskvorky__smart_open-50 +pivotal__kpack-1232 +pkg__sftp-310 +pkg__sftp-328 +pkg__sftp-377 +pkg__sftp-516 +plaid__sanctuary-105 +plaid__sanctuary-106 +plaid__sanctuary-107 +plaid__sanctuary-168 +plaid__sanctuary-23 +plaid__sanctuary-35 +plaid__sanctuary-70 +plaid__sanctuary-78 +plaid__sanctuary-79 +plaid__sanctuary-92 +plaid__sanctuary-93 +planetlabs__gpq-35 +planetlabs__gpq-79 +planetlabs__gpq-80 +planetlabs__gpq-89 +planetlabs__gpq-90 +planetlabs__gpq-91 +planetlabs__gpq-98 +planetlabs__planet-client-python-399 +planetlabs__planet-client-python-44 +planetlabs__planet-client-python-553 +planetlabs__planet-client-python-58 +planetlabs__planet-client-python-588 +planetlabs__planet-client-python-81 +planetlabs__planet-client-python-858 +plasmapy__plasmapy-138 +plasmapy__plasmapy-228 +plasmapy__plasmapy-238 +plasmapy__plasmapy-306 +plasmapy__plasmapy-346 +plasmapy__plasmapy-361 +plasmapy__plasmapy-385 +plasmapy__plasmapy-510 +plasmapy__plasmapy-517 +plasmapy__plasmapy-519 +plasmapy__plasmapy-540 +plataformatec__broadway-108 +plataformatec__broadway-31 +plataformatec__broadway-40 +plataformatec__broadway-95 +plataformatec__mox-48 +plataformatec__mox-55 +platers__obsidian-linter-1001 +platers__obsidian-linter-1002 +platers__obsidian-linter-1007 +platers__obsidian-linter-1008 +platers__obsidian-linter-1026 +platers__obsidian-linter-1031 +platers__obsidian-linter-1051 +platers__obsidian-linter-1058 +platers__obsidian-linter-1059 +platers__obsidian-linter-1070 +platers__obsidian-linter-1076 +platers__obsidian-linter-1078 +platers__obsidian-linter-1088 +platers__obsidian-linter-1089 +platers__obsidian-linter-1095 +platers__obsidian-linter-1110 +platers__obsidian-linter-1118 +platers__obsidian-linter-1119 +platers__obsidian-linter-1122 +platers__obsidian-linter-1128 +platers__obsidian-linter-1132 +platers__obsidian-linter-1139 +platers__obsidian-linter-1151 +platers__obsidian-linter-1157 +platers__obsidian-linter-118 +platers__obsidian-linter-1207 +platers__obsidian-linter-1209 +platers__obsidian-linter-1227 +platers__obsidian-linter-1248 +platers__obsidian-linter-1250 +platers__obsidian-linter-1334 +platers__obsidian-linter-147 +platers__obsidian-linter-197 +platers__obsidian-linter-198 +platers__obsidian-linter-202 +platers__obsidian-linter-203 +platers__obsidian-linter-204 +platers__obsidian-linter-208 +platers__obsidian-linter-209 +platers__obsidian-linter-211 +platers__obsidian-linter-225 +platers__obsidian-linter-227 +platers__obsidian-linter-231 +platers__obsidian-linter-238 +platers__obsidian-linter-242 +platers__obsidian-linter-252 +platers__obsidian-linter-256 +platers__obsidian-linter-268 +platers__obsidian-linter-269 +platers__obsidian-linter-293 +platers__obsidian-linter-310 +platers__obsidian-linter-319 +platers__obsidian-linter-323 +platers__obsidian-linter-336 +platers__obsidian-linter-342 +platers__obsidian-linter-348 +platers__obsidian-linter-354 +platers__obsidian-linter-361 +platers__obsidian-linter-381 +platers__obsidian-linter-393 +platers__obsidian-linter-402 +platers__obsidian-linter-406 +platers__obsidian-linter-409 +platers__obsidian-linter-417 +platers__obsidian-linter-431 +platers__obsidian-linter-433 +platers__obsidian-linter-461 +platers__obsidian-linter-462 +platers__obsidian-linter-463 +platers__obsidian-linter-471 +platers__obsidian-linter-478 +platers__obsidian-linter-48 +platers__obsidian-linter-492 +platers__obsidian-linter-504 +platers__obsidian-linter-505 +platers__obsidian-linter-510 +platers__obsidian-linter-511 +platers__obsidian-linter-514 +platers__obsidian-linter-515 +platers__obsidian-linter-520 +platers__obsidian-linter-522 +platers__obsidian-linter-523 +platers__obsidian-linter-528 +platers__obsidian-linter-530 +platers__obsidian-linter-536 +platers__obsidian-linter-540 +platers__obsidian-linter-55 +platers__obsidian-linter-552 +platers__obsidian-linter-586 +platers__obsidian-linter-594 +platers__obsidian-linter-600 +platers__obsidian-linter-602 +platers__obsidian-linter-603 +platers__obsidian-linter-605 +platers__obsidian-linter-606 +platers__obsidian-linter-61 +platers__obsidian-linter-612 +platers__obsidian-linter-613 +platers__obsidian-linter-615 +platers__obsidian-linter-643 +platers__obsidian-linter-644 +platers__obsidian-linter-645 +platers__obsidian-linter-655 +platers__obsidian-linter-663 +platers__obsidian-linter-664 +platers__obsidian-linter-665 +platers__obsidian-linter-672 +platers__obsidian-linter-674 +platers__obsidian-linter-676 +platers__obsidian-linter-677 +platers__obsidian-linter-687 +platers__obsidian-linter-694 +platers__obsidian-linter-705 +platers__obsidian-linter-706 +platers__obsidian-linter-717 +platers__obsidian-linter-720 +platers__obsidian-linter-757 +platers__obsidian-linter-759 +platers__obsidian-linter-760 +platers__obsidian-linter-761 +platers__obsidian-linter-762 +platers__obsidian-linter-778 +platers__obsidian-linter-785 +platers__obsidian-linter-786 +platers__obsidian-linter-830 +platers__obsidian-linter-836 +platers__obsidian-linter-860 +platers__obsidian-linter-863 +platers__obsidian-linter-874 +platers__obsidian-linter-88 +platers__obsidian-linter-893 +platers__obsidian-linter-918 +platers__obsidian-linter-922 +platers__obsidian-linter-931 +platers__obsidian-linter-937 +platers__obsidian-linter-939 +platers__obsidian-linter-942 +platers__obsidian-linter-953 +platers__obsidian-linter-955 +platers__obsidian-linter-962 +platers__obsidian-linter-965 +platers__obsidian-linter-978 +platers__obsidian-linter-979 +playcanvas__engine-3898 +playcanvas__engine-4561 +playcanvas__engine-4785 +playcanvas__engine-5392 +playcanvas__engine-6625 +playcanvas__engine-6648 +playcanvas__engine-7596 +playwright-community__eslint-plugin-playwright-264 +playwright-community__eslint-plugin-playwright-304 +playwright-community__eslint-plugin-playwright-308 +playwright-community__eslint-plugin-playwright-369 +plexis-js__plexis-105 +plexis-js__plexis-106 +plexis-js__plexis-18 +plexis-js__plexis-29 +plexis-js__plexis-30 +plexis-js__plexis-43 +plexis-js__plexis-59 +plexis-js__plexis-60 +plexis-js__plexis-63 +plexis-js__plexis-91 +plexsystems__konstraint-20 +plexsystems__konstraint-251 +plexsystems__konstraint-255 +plexsystems__konstraint-271 +plexsystems__konstraint-272 +plexsystems__konstraint-275 +plexsystems__konstraint-279 +ploomber__jupysql-103 +ploomber__jupysql-112 +ploomber__jupysql-120 +ploomber__jupysql-127 +ploomber__jupysql-135 +ploomber__jupysql-137 +ploomber__jupysql-168 +ploomber__jupysql-190 +ploomber__jupysql-22 +ploomber__jupysql-267 +ploomber__jupysql-290 +ploomber__jupysql-361 +ploomber__jupysql-517 +ploomber__jupysql-655 +ploomber__jupysql-681 +ploomber__jupysql-748 +ploomber__jupysql-770 +ploomber__jupysql-802 +ploomber__jupysql-821 +ploomber__jupysql-823 +ploomber__jupysql-834 +ploomber__jupysql-839 +ploomber__jupysql-861 +ploomber__jupysql-870 +ploomber__jupysql-980 +plotly__dash-351 +plotly__plotly.py-469 +plumatic__plumbing-146 +plumatic__schema-443 +pmcelhaney__counterfact-586 +pmcelhaney__counterfact-594 +pmcelhaney__counterfact-704 +pmeal__openpnm-378 +pmndrs__valtio-157 +pmndrs__valtio-177 +pmndrs__valtio-195 +pmndrs__valtio-201 +pmndrs__valtio-286 +pmndrs__valtio-333 +pmndrs__valtio-335 +pmndrs__valtio-354 +pmndrs__valtio-9 +pmndrs__valtio-94 +pmndrs__valtio-98 +pmndrs__zustand-1460 +pmndrs__zustand-1518 +pmndrs__zustand-603 +pmndrs__zustand-624 +pmndrs__zustand-880 +pnp__pnpjs-2483 +pnp__pnpjs-2834 +pnp__pnpjs-2846 +pnp__pnpjs-2852 +pnp__pnpjs-2854 +pnp__pnpjs-2914 +pointfreeco__swift-case-paths-149 +pointfreeco__swift-case-paths-162 +pointfreeco__swift-case-paths-183 +pointfreeco__swift-case-paths-48 +pointfreeco__swift-case-paths-55 +pointfreeco__swift-case-paths-65 +pointfreeco__swift-case-paths-87 +pointfreeco__swift-case-paths-90 +polarismesh__polaris-673 +polarismesh__polaris-894 +polarity-lang__polarity-412 +polarity-lang__polarity-440 +polarsignals__frostdb-149 +polarsignals__frostdb-231 +polarsignals__frostdb-279 +polarsignals__frostdb-295 +polarsignals__frostdb-297 +polarsignals__frostdb-352 +polarsignals__frostdb-399 +polarsignals__frostdb-400 +polarsignals__frostdb-436 +polarsignals__frostdb-487 +polarsignals__frostdb-489 +polarsignals__frostdb-586 +polarsignals__frostdb-626 +polarsignals__frostdb-724 +polarsignals__frostdb-861 +polkadot-js__extension-471 +polkadot-js__extension-481 +polkadot-js__extension-545 +polkadot-js__extension-596 +polymer__vulcanize-354 +ponder-sh__ponder-725 +posit-dev__air-118 +posit-dev__air-178 +posit-dev__air-228 +posit-dev__air-236 +posit-dev__air-240 +posit-dev__air-244 +posit-dev__air-250 +postcss__autoprefixer-1017 +postcss__autoprefixer-1080 +postcss__autoprefixer-1086 +postcss__autoprefixer-1087 +postcss__autoprefixer-1092 +postcss__autoprefixer-1126 +postcss__autoprefixer-1144 +postcss__autoprefixer-1192 +postcss__autoprefixer-1334 +postcss__autoprefixer-1412 +postcss__postcss-586 +postcss__postcss-728 +postcss__postcss-import-380 +postcss__postcss-import-453 +postcss__postcss-import-561 +postcss__postcss-selector-parser-103 +postcss__postcss-selector-parser-84 +postlund__pyatv-1098 +postlund__pyatv-1099 +postlund__pyatv-1135 +postlund__pyatv-1310 +postlund__pyatv-1975 +postlund__pyatv-2061 +postlund__pyatv-2077 +pragdave__earmark-263 +pragdave__earmark-271 +pragdave__earmark-285 +pragdave__earmark-503 +pravega__zookeeper-operator-201 +pravega__zookeeper-operator-215 +pravega__zookeeper-operator-256 +pravega__zookeeper-operator-260 +pravega__zookeeper-operator-272 +pravega__zookeeper-operator-296 +pravega__zookeeper-operator-308 +pravega__zookeeper-operator-327 +pravega__zookeeper-operator-334 +pravega__zookeeper-operator-359 +pravega__zookeeper-operator-360 +pravega__zookeeper-operator-373 +pravega__zookeeper-operator-391 +pravega__zookeeper-operator-473 +pravega__zookeeper-operator-522 +praw-dev__praw-1994 +pre-commit__pre-commit-1090 +pre-commit__pre-commit-1256 +pre-commit__pre-commit-1319 +pre-commit__pre-commit-460 +pre-commit__pre-commit-600 +pre-commit__pre-commit-616 +pre-commit__pre-commit-617 +pre-commit__pre-commit-630 +pre-commit__pre-commit-715 +pre-commit__pre-commit-893 +pre-commit__pre-commit-898 +pre-commit__pre-commit-904 +pre-commit__pre-commit-906 +pre-commit__pre-commit-908 +pre-commit__pre-commit-hooks-211 +pre-commit__pre-commit-hooks-233 +pre-commit__pre-commit-hooks-271 +pre-commit__pre-commit-hooks-575 +preactjs__preact-devtools-172 +preactjs__preact-devtools-196 +preactjs__preact-devtools-302 +preactjs__preact-devtools-454 +preactjs__preact-render-to-string-209 +preactjs__preact-render-to-string-215 +preactjs__preact-render-to-string-219 +preactjs__preact-render-to-string-246 +preactjs__preact-render-to-string-282 +preactjs__preact-render-to-string-315 +preactjs__preact-render-to-string-331 +preactjs__preact-render-to-string-360 +preactjs__preact-render-to-string-381 +prebid__prebid-server-1414 +prefecthq__prefect-aws-322 +prefecthq__prefect-aws-328 +prefecthq__prefect-aws-398 +prefecthq__prefect-aws-407 +prefix-dev__rattler-build-1618 +prefix-dev__rattler-build-1675 +prequel-dev__cre-87 +prequel-dev__cre-88 +prequel-dev__cre-89 +pressly__goose-950 +prest__prest-830 +prestashop__prestashop-25914 +prestashop__prestashop-25984 +prestashop__prestashop-26716 +prestashop__prestashop-27425 +prestashop__prestashop-27575 +prestashop__prestashop-27657 +prestashop__prestashop-27720 +prestashop__prestashop-28001 +prestashop__prestashop-28226 +prestashop__prestashop-28266 +prestashop__prestashop-28799 +prestashop__prestashop-28820 +prestashop__prestashop-29722 +prestashop__prestashop-30035 +prestashop__prestashop-30567 +prestashop__prestashop-31006 +prestashop__prestashop-31137 +prestashop__prestashop-33113 +prestashop__prestashop-33458 +prestashop__prestashop-33758 +prestashop__prestashop-34078 +prestashop__prestashop-35360 +prestashop__prestashop-36381 +prestashop__prestashop-36433 +prestashop__prestashop-37037 +prestashop__prestashop-37692 +prestashop__prestashop-38903 +pretix__pretix-3992 +pretix__pretix-4512 +pretix__pretix-5080 +prettier__plugin-php-2303 +prettier__plugin-pug-448 +prettier__plugin-pug-502 +prettier__plugin-pug-509 +prettier__plugin-xml-157 +prettier__plugin-xml-168 +prettier__plugin-xml-231 +prettier__plugin-xml-300 +prettier__plugin-xml-43 +prettier__plugin-xml-449 +prettier__plugin-xml-654 +prettier__plugin-xml-719 +prettier__plugin-xml-733 +prettier__prettier-atom-223 +prettier__prettier-atom-225 +prettier__prettier-atom-230 +prettier__prettier-atom-240 +prettier__prettier-atom-348 +prettier__prettier-atom-374 +prettier__prettier-atom-380 +prettier__prettier-atom-394 +prettier__prettier-atom-447 +prettier__prettier-atom-474 +prettier__prettier-atom-509 +prettier__prettier-atom-511 +prettier__prettier-atom-566 +prettier__prettier-eslint-211 +prettier__prettier-eslint-696 +prettier__prettier-eslint-73 +prettier__prettier-eslint-74 +prettier__prettier-eslint-87 +prinsfrank__pdfparser-11 +prinsfrank__pdfparser-25 +prinsfrank__pdfparser-56 +prinsfrank__pdfparser-58 +prinsfrank__pdfparser-67 +prinsfrank__pdfparser-94 +prismatic__plumbing-142 +prismatic__plumbing-146 +prismatic__schema-443 +prismjs__prism-3438 +prismjs__prism-3442 +prismjs__prism-3448 +privacy-scaling-explorations__zkevm-specs-475 +privacy-scaling-explorations__zkevm-specs-476 +privacy-scaling-explorations__zkevm-specs-477 +privacy-scaling-explorations__zkevm-specs-478 +privacy-scaling-explorations__zkevm-specs-481 +privacy-scaling-explorations__zkevm-specs-503 +prkumar__uplink-229 +prkumar__uplink-258 +probmods__webppl-170 +probmods__webppl-562 +probmods__webppl-644 +probmods__webppl-688 +probmods__webppl-690 +probmods__webppl-745 +probmods__webppl-766 +probmods__webppl-794 +probmods__webppl-831 +probmods__webppl-834 +probmods__webppl-851 +probmods__webppl-871 +probmods__webppl-872 +probmods__webppl-913 +probot__settings-199 +probot__settings-286 +processmaker__modeler-1091 +processmaker__modeler-1116 +processmaker__modeler-1215 +processmaker__modeler-719 +processmaker__modeler-748 +processmaker__modeler-751 +processmaker__modeler-768 +processmaker__modeler-785 +processmaker__modeler-810 +processmaker__modeler-814 +processmaker__modeler-903 +processmaker__modeler-905 +processmaker__modeler-906 +processmaker__nayra-101 +processmaker__nayra-103 +processmaker__nayra-116 +processmaker__nayra-121 +processmaker__nayra-126 +processmaker__nayra-137 +processmaker__nayra-147 +processmaker__nayra-164 +processmaker__nayra-175 +processmaker__nayra-178 +processmaker__nayra-82 +processmaker__nayra-91 +project-copacetic__copacetic-1037 +project-copacetic__copacetic-1121 +project-copacetic__copacetic-1123 +project-copacetic__copacetic-1141 +project-copacetic__copacetic-961 +project-oak__oak-1617 +projectdiscovery__goflags-112 +projectdiscovery__goflags-123 +projectdiscovery__goflags-128 +projectdiscovery__goflags-151 +projectdiscovery__httpx-1009 +projectdiscovery__httpx-1951 +projectevergreen__greenwood-1107 +projectevergreen__greenwood-1243 +projectevergreen__greenwood-296 +projectevergreen__greenwood-315 +projectevergreen__greenwood-375 +projectevergreen__greenwood-383 +projectevergreen__greenwood-388 +projectevergreen__greenwood-832 +projectevergreen__wcc-120 +projectevergreen__wcc-125 +projectevergreen__wcc-127 +projectevergreen__wcc-155 +projectevergreen__wcc-156 +projectevergreen__wcc-50 +projectevergreen__wcc-78 +projectevergreen__wcc-82 +projectevergreen__wcc-85 +projectevergreen__wcc-86 +projectevergreen__wcc-98 +projectfluent__fluent-rs-143 +projectfluent__fluent-rs-262 +projectfluent__fluent-rs-267 +projectfluent__fluent-rs-302 +projectfluent__fluent-rs-63 +projectfluent__fluent-rs-86 +projectlombok__lombok-3075 +projectlombok__lombok-3101 +projectlombok__lombok-3473 +projectlombok__lombok-3494 +projectlombok__lombok-3669 +projectmesa__mesa-1343 +projectmesa__mesa-1346 +projectmesa__mesa-2187 +projectmesa__mesa-2454 +projectmesa__mesa-979 +projectwallace__css-analyzer-124 +projectwallace__css-analyzer-80 +projectwallace__css-analyzer-84 +projectwallace__css-analyzer-93 +prometheus__alertmanager-4218 +prometheus__blackbox_exporter-990 +prometheus__client_python-1003 +prometheus__client_python-1012 +prometheus__client_python-547 +prometheus__client_python-644 +prometheus__client_python-666 +prometheus__client_python-675 +prometheus__common-331 +prometheus__common-358 +prometheus__common-472 +prometheus__common-475 +prometheus__common-546 +prometheus__common-547 +prometheus__common-608 +prometheus__procfs-127 +prometheus__procfs-158 +prometheus__procfs-237 +prometheus__procfs-251 +prometheus__procfs-260 +prometheus__procfs-276 +prometheus__procfs-488 +prometheus__procfs-532 +prometheus__prometheus-12391 +prometheus__snmp_exporter-465 +prometheus__snmp_exporter-559 +prometheus__snmp_exporter-757 +prometheus__snmp_exporter-868 +prometheus__snmp_exporter-914 +prometheus__statsd_exporter-579 +prometheus__tsdb-519 +prometheus__tsdb-613 +prometheus__tsdb-649 +promptfoo__promptfoo-39 +promptfoo__promptfoo-88 +protofire__solhint-115 +protofire__solhint-117 +protofire__solhint-119 +protofire__solhint-124 +protofire__solhint-126 +protofire__solhint-132 +protofire__solhint-134 +protofire__solhint-153 +protofire__solhint-172 +protofire__solhint-185 +protofire__solhint-217 +protofire__solhint-224 +protofire__solhint-246 +protofire__solhint-267 +protofire__solhint-291 +protofire__solhint-416 +protofire__solhint-493 +proullon__ramsql-102 +proullon__ramsql-45 +proullon__ramsql-47 +proullon__ramsql-49 +proullon__ramsql-50 +proullon__ramsql-66 +proullon__ramsql-69 +proullon__ramsql-85 +proullon__ramsql-88 +proullon__ramsql-90 +proullon__ramsql-91 +proullon__ramsql-94 +prql__prql-1314 +prql__prql-453 +prql__prql-479 +prql__prql-564 +psalm__psalm-plugin-laravel-388 +psd-tools__psd-tools-334 +psd-tools__psd-tools-336 +psd-tools__psd-tools-452 +pterm__pterm-104 +pterm__pterm-111 +pterm__pterm-134 +pterm__pterm-230 +pterm__pterm-337 +pterm__pterm-429 +pterm__pterm-44 +pterm__pterm-492 +pterm__pterm-96 +pterm__pterm-97 +ptt-official-app__ptt-backend-122 +ptt-official-app__ptt-backend-268 +ptt-official-app__ptt-backend-291 +public-awesome__launchpad-307 +public-awesome__launchpad-371 +public-awesome__launchpad-405 +pulldown-cmark__pulldown-cmark-1015 +pulldown-cmark__pulldown-cmark-1017 +pulldown-cmark__pulldown-cmark-1018 +pulldown-cmark__pulldown-cmark-1023 +pulldown-cmark__pulldown-cmark-849 +pulldown-cmark__pulldown-cmark-851 +pulldown-cmark__pulldown-cmark-858 +pulldown-cmark__pulldown-cmark-862 +pulldown-cmark__pulldown-cmark-877 +pulldown-cmark__pulldown-cmark-908 +pulldown-cmark__pulldown-cmark-915 +pulldown-cmark__pulldown-cmark-917 +pulldown-cmark__pulldown-cmark-928 +pulldown-cmark__pulldown-cmark-930 +pulldown-cmark__pulldown-cmark-954 +pulldown-cmark__pulldown-cmark-974 +pulldown-cmark__pulldown-cmark-978 +pulumi__actions-1116 +pulumi__actions-117 +pulumi__actions-300 +pulumi__actions-658 +pulumi__actions-925 +pulumi__actions-994 +pulumi__esc-546 +pulumi__pulumi-17188 +pulumi__pulumi-18642 +pulumi__pulumi-19952 +pulumi__pulumi-cdk-217 +pulumi__pulumi-terraform-bridge-332 +pumasai__quartonotebookrunner.jl-32 +pumasai__quartonotebookrunner.jl-43 +pumasai__quartonotebookrunner.jl-45 +puppetlabs__wash-220 +puppetlabs__wash-229 +pusher__oauth2_proxy-201 +pusher__oauth2_proxy-234 +pusher__oauth2_proxy-285 +puzpuzpuz__xsync-40 +pvlib__pvanalytics-214 +pvlib__pvlib-python-213 +pvlib__pvlib-python-220 +pvlib__pvlib-python-222 +pvlib__pvlib-python-2292 +pvlib__pvlib-python-230 +pvlib__pvlib-python-2341 +pvlib__pvlib-python-2393 +pvlib__pvlib-python-2395 +pvlib__pvlib-python-2435 +pvlib__pvlib-python-2451 +pvlib__pvlib-python-253 +pvlib__pvlib-python-278 +pvlib__pvlib-python-304 +pvlib__pvlib-python-466 +pvlib__pvlib-python-486 +pvlib__pvlib-python-491 +pvlib__pvlib-python-509 +pvlib__pvlib-python-542 +pvlib__pvlib-python-573 +pvlib__pvlib-python-626 +pvlib__pvlib-python-683 +pvlib__pvlib-python-755 +pvlib__pvlib-python-757 +pvlib__pvlib-python-773 +pvlib__pvlib-python-830 +pvlib__pvlib-python-834 +pwntester__octo.nvim-1011 +pwntester__octo.nvim-1175 +pwntester__octo.nvim-448 +pwntester__octo.nvim-772 +pwntester__octo.nvim-837 +pwntester__octo.nvim-888 +pwntester__octo.nvim-950 +py-cov-action__python-coverage-comment-action-105 +py-cov-action__python-coverage-comment-action-184 +py-cov-action__python-coverage-comment-action-213 +py-cov-action__python-coverage-comment-action-277 +py-cov-action__python-coverage-comment-action-286 +py-cov-action__python-coverage-comment-action-323 +py-cov-action__python-coverage-comment-action-435 +py-cov-action__python-coverage-comment-action-573 +py-cov-action__python-coverage-comment-action-84 +py-cov-action__python-coverage-comment-action-95 +py-pdf__pypdf2-1038 +py-pdf__pypdf2-1083 +py-pdf__pypdf2-1170 +py-pdf__pypdf2-1189 +py-pdf__pypdf2-1193 +py-pdf__pypdf2-1223 +py-pdf__pypdf2-1300 +py-pdf__pypdf2-1309 +py-pdf__pypdf2-1315 +py-pdf__pypdf2-1316 +py-pdf__pypdf2-1317 +py-pdf__pypdf2-1318 +py-pdf__pypdf2-1331 +py-pdf__pypdf2-1345 +py-pdf__pypdf2-1407 +py-pdf__pypdf2-1431 +py-pdf__pypdf2-1433 +py-pdf__pypdf2-1477 +py-pdf__pypdf2-618 +py-pdf__pypdf2-787 +py-pdf__pypdf2-813 +py-pdf__pypdf2-814 +py-pdf__pypdf2-913 +pybamm-team__pybamm-1008 +pybamm-team__pybamm-1020 +pybamm-team__pybamm-1025 +pybamm-team__pybamm-1026 +pybamm-team__pybamm-1055 +pybamm-team__pybamm-1081 +pybamm-team__pybamm-2837 +pybamm-team__pybamm-2862 +pybamm-team__pybamm-2961 +pybamm-team__pybamm-3573 +pybamm-team__pybamm-3627 +pybamm-team__pybamm-3795 +pybamm-team__pybamm-3857 +pybamm-team__pybamm-3921 +pybamm-team__pybamm-3979 +pybamm-team__pybamm-4001 +pybamm-team__pybamm-4020 +pybamm-team__pybamm-4072 +pybamm-team__pybamm-4208 +pybamm-team__pybamm-4221 +pybamm-team__pybamm-4239 +pybamm-team__pybamm-4267 +pybamm-team__pybamm-4383 +pybamm-team__pybamm-4421 +pybamm-team__pybamm-4456 +pybamm-team__pybamm-4465 +pybamm-team__pybamm-4501 +pybamm-team__pybamm-4534 +pybamm-team__pybamm-4562 +pybamm-team__pybamm-4621 +pybamm-team__pybamm-4641 +pybamm-team__pybamm-4644 +pybamm-team__pybamm-4650 +pybamm-team__pybamm-4700 +pybamm-team__pybamm-4726 +pybamm-team__pybamm-4753 +pybamm-team__pybamm-4816 +pybamm-team__pybamm-4824 +pybamm-team__pybamm-4825 +pybamm-team__pybamm-4826 +pybamm-team__pybamm-4871 +pybamm-team__pybamm-4968 +pybamm-team__pybamm-4969 +pybamm-team__pybamm-4989 +pybamm-team__pybamm-5008 +pybamm-team__pybamm-5044 +pybamm-team__pybamm-5076 +pybamm-team__pybamm-529 +pybamm-team__pybamm-544 +pybamm-team__pybamm-587 +pybamm-team__pybamm-594 +pybamm-team__pybamm-595 +pybamm-team__pybamm-602 +pybamm-team__pybamm-612 +pybamm-team__pybamm-622 +pybamm-team__pybamm-637 +pybamm-team__pybamm-645 +pybamm-team__pybamm-661 +pybamm-team__pybamm-669 +pybamm-team__pybamm-681 +pybamm-team__pybamm-706 +pybamm-team__pybamm-713 +pybamm-team__pybamm-739 +pybamm-team__pybamm-769 +pybamm-team__pybamm-780 +pybamm-team__pybamm-783 +pybamm-team__pybamm-794 +pybamm-team__pybamm-797 +pybamm-team__pybamm-809 +pybamm-team__pybamm-818 +pybamm-team__pybamm-819 +pybamm-team__pybamm-842 +pybamm-team__pybamm-844 +pybamm-team__pybamm-852 +pybamm-team__pybamm-856 +pybamm-team__pybamm-868 +pybamm-team__pybamm-875 +pybamm-team__pybamm-925 +pybamm-team__pybamm-947 +pybamm-team__pybamm-951 +pybamm-team__pybamm-962 +pybamm-team__pybamm-971 +pybel__pybel-472 +pyca__cryptography-11201 +pyca__cryptography-11418 +pyca__cryptography-12286 +pyca__cryptography-12342 +pyca__cryptography-12673 +pyca__cryptography-12693 +pyca__pyopenssl-1218 +pyca__pyopenssl-646 +pyca__pyopenssl-708 +pyccel__pyccel-1606 +pyccel__pyccel-1649 +pyccel__pyccel-1679 +pyccel__pyccel-1709 +pyccel__pyccel-1710 +pyccel__pyccel-1724 +pyccel__pyccel-1731 +pyccel__pyccel-1764 +pyccel__pyccel-1780 +pyccel__pyccel-1789 +pyccel__pyccel-1790 +pyccel__pyccel-1797 +pyccel__pyccel-1798 +pyccel__pyccel-1810 +pyccel__pyccel-1829 +pyccel__pyccel-1837 +pyccel__pyccel-1843 +pyccel__pyccel-1847 +pyccel__pyccel-1891 +pyccel__pyccel-1897 +pyccel__pyccel-1901 +pyccel__pyccel-1902 +pyccel__pyccel-1908 +pyccel__pyccel-1922 +pyccel__pyccel-1971 +pyccel__pyccel-2003 +pyccel__pyccel-2004 +pyccel__pyccel-2014 +pyccel__pyccel-2015 +pyccel__pyccel-2019 +pyccel__pyccel-2029 +pyccel__pyccel-2030 +pyccel__pyccel-2031 +pyccel__pyccel-2038 +pyccel__pyccel-2044 +pyccel__pyccel-2063 +pyccel__pyccel-2064 +pyccel__pyccel-2065 +pyccel__pyccel-2072 +pyccel__pyccel-2082 +pyccel__pyccel-2089 +pyccel__pyccel-2095 +pyccel__pyccel-2107 +pyccel__pyccel-2114 +pyccel__pyccel-2118 +pyccel__pyccel-2143 +pyccel__pyccel-2151 +pyccel__pyccel-2158 +pyccel__pyccel-2160 +pyccel__pyccel-2184 +pyccel__pyccel-2186 +pyccel__pyccel-2196 +pyccel__pyccel-2200 +pyccel__pyccel-2208 +pyccel__pyccel-2230 +pyccel__pyccel-2231 +pyccel__pyccel-2238 +pyccel__pyccel-2250 +pyccel__pyccel-2275 +pyccel__pyccel-2277 +pyccel__pyccel-2287 +pyccel__pyccel-2289 +pyccel__pyccel-2297 +pyccel__pyccel-2313 +pyccel__pyccel-2366 +pyccel__pyccel-2392 +pyccel__pyccel-264 +pyccel__pyccel-270 +pyccel__pyccel-629 +pyccel__pyccel-780 +pyccel__pyccel-805 +pycqa__bandit-1078 +pycqa__bandit-1094 +pycqa__bandit-1217 +pycqa__bandit-1235 +pycqa__bandit-570 +pycqa__bandit-633 +pycqa__bandit-765 +pycqa__bandit-766 +pycqa__bandit-798 +pycqa__bandit-803 +pycqa__bandit-829 +pycqa__bandit-914 +pycqa__bandit-929 +pycqa__bandit-999 +pycqa__docformatter-104 +pycqa__docformatter-115 +pycqa__docformatter-128 +pycqa__docformatter-138 +pycqa__docformatter-141 +pycqa__docformatter-142 +pycqa__docformatter-143 +pycqa__docformatter-148 +pycqa__docformatter-177 +pycqa__docformatter-179 +pycqa__docformatter-182 +pycqa__docformatter-188 +pycqa__docformatter-190 +pycqa__docformatter-195 +pycqa__docformatter-213 +pycqa__docformatter-254 +pycqa__docformatter-284 +pycqa__docformatter-313 +pycqa__docformatter-53 +pycqa__docformatter-77 +pycqa__docformatter-87 +pycqa__docformatter-93 +pycqa__flake8-1374 +pycqa__flake8-1498 +pycqa__flake8-1535 +pycqa__flake8-1536 +pycqa__flake8-1543 +pycqa__flake8-1576 +pycqa__flake8-1624 +pycqa__flake8-1631 +pycqa__flake8-1642 +pycqa__flake8-1648 +pycqa__flake8-1713 +pycqa__pycodestyle-499 +pycqa__pyflakes-273 +pycqa__pyflakes-275 +pycqa__pyflakes-313 +pycqa__pyflakes-322 +pycqa__pyflakes-325 +pycqa__pyflakes-335 +pycqa__pyflakes-371 +pycqa__pyflakes-374 +pycqa__pyflakes-396 +pycqa__pyflakes-400 +pycqa__pyflakes-410 +pycqa__pyflakes-420 +pycqa__pyflakes-435 +pycqa__pyflakes-443 +pycqa__pyflakes-448 +pycqa__pyflakes-451 +pycqa__pyflakes-452 +pycqa__pyflakes-472 +pycqa__pyflakes-479 +pycqa__pyflakes-484 +pycqa__pyflakes-508 +pycqa__pyflakes-516 +pycqa__pyflakes-535 +pycqa__pyflakes-544 +pycqa__pyflakes-580 +pycqa__pyflakes-604 +pycqa__pyflakes-606 +pycqa__pyflakes-609 +pycqa__pyflakes-619 +pycqa__pyflakes-632 +pycqa__pyflakes-668 +pycqa__pyflakes-675 +pycqa__pyflakes-698 +pycqa__pyflakes-729 +pycqa__pyflakes-745 +pycqa__pyflakes-754 +pycqa__pyflakes-761 +pycqa__pyflakes-765 +pycqa__pyflakes-772 +pycqa__pyflakes-801 +pycqa__pyflakes-836 +pydap__pydap-243 +pydap__pydap-479 +pydap__pydap-481 +pydap__pydap-495 +pydap__pydap-502 +pydap__pydap-505 +pydap__pydap-519 +pydata__sparse-861 +pydata__sparse-870 +pydata__sparse-887 +pydata__sparse-888 +pydicom__pydicom-1048 +pydicom__pydicom-1241 +pydicom__pydicom-1720 +pydicom__pydicom-690 +pydicom__pynetdicom-883 +pydicom__pynetdicom-996 +pydicom__pynetdicom-998 +pyfar__pyfar-114 +pyfar__pyfar-123 +pyfar__pyfar-54 +pyfar__pyfar-58 +pyfar__pyfar-649 +pyfar__pyfar-658 +pyfar__pyfar-67 +pyfar__pyfar-680 +pyfar__pyfar-707 +pyfar__pyfar-716 +pyfar__pyfar-722 +pyfar__pyfar-725 +pyfar__pyfar-755 +pyfar__pyfar-765 +pyfar__pyfar-770 +pyfar__pyfar-773 +pyfar__pyfar-776 +pyfilesystem__pyfilesystem2-396 +pyfilesystem__pyfilesystem2-439 +pyfilesystem__pyfilesystem2-457 +pyfilesystem__pyfilesystem2-462 +pyfilesystem__pyfilesystem2-470 +pyfilesystem__pyfilesystem2-473 +pyfilesystem__pyfilesystem2-474 +pyfisch__cbor-18 +pyfisch__cbor-54 +pyfisch__cbor-59 +pyfisch__cbor-71 +pyfisch__cbor-72 +pyg-team__pytorch_geometric-6928 +pyg-team__pytorch_geometric-7654 +pyg-team__pytorch_geometric-7772 +pyg-team__pytorch_geometric-7902 +pyg-team__pytorch_geometric-8143 +pyg-team__pytorch_geometric-8248 +pyg-team__pytorch_geometric-8566 +pyg-team__pytorch_geometric-9099 +pyg-team__pytorch_geometric-9446 +pyg-team__pytorch_geometric-9494 +pygfx__pygfx-1026 +pygfx__pygfx-1031 +pygfx__pygfx-1044 +pygfx__pygfx-121 +pygfx__pygfx-561 +pygfx__pygfx-563 +pygfx__pygfx-581 +pygfx__pygfx-672 +pyjanitor-devs__pyjanitor-1014 +pyjanitor-devs__pyjanitor-1027 +pyjanitor-devs__pyjanitor-1029 +pyjanitor-devs__pyjanitor-1030 +pyjanitor-devs__pyjanitor-1064 +pyjanitor-devs__pyjanitor-1066 +pyjanitor-devs__pyjanitor-1079 +pyjanitor-devs__pyjanitor-1099 +pyjanitor-devs__pyjanitor-1101 +pyjanitor-devs__pyjanitor-1111 +pyjanitor-devs__pyjanitor-1112 +pyjanitor-devs__pyjanitor-1120 +pyjanitor-devs__pyjanitor-1126 +pyjanitor-devs__pyjanitor-1136 +pyjanitor-devs__pyjanitor-1287 +pyjanitor-devs__pyjanitor-1315 +pyjanitor-devs__pyjanitor-1317 +pyjanitor-devs__pyjanitor-1444 +pyjanitor-devs__pyjanitor-1446 +pyjanitor-devs__pyjanitor-1450 +pyjanitor-devs__pyjanitor-1451 +pyjanitor-devs__pyjanitor-1460 +pyjanitor-devs__pyjanitor-833 +pyjanitor-devs__pyjanitor-837 +pyjanitor-devs__pyjanitor-970 +pyjanitor-devs__pyjanitor-991 +pylons__pyramid-3576 +pylons__pyramid-3598 +pylons__waitress-124 +pylons__waitress-140 +pylons__waitress-166 +pylons__waitress-171 +pylons__waitress-215 +pylons__waitress-232 +pylons__waitress-238 +pylons__waitress-249 +pylons__waitress-252 +pylons__waitress-322 +pylons__waitress-363 +pylons__waitress-376 +pylons__waitress-377 +pylons__waitress-434 +pylons__waitress-457 +pylons__waitress-90 +pymc-devs__pymc-5634 +pymc-devs__pymc-5759 +pymc-devs__pymc-7381 +pymc-devs__pymc-7637 +pymc-devs__pymc-7746 +pymc-devs__pymc-7763 +pymc-devs__pymc-7801 +pymc-devs__pymc-7809 +pymc-devs__pymc-7858 +pymc-devs__pytensor-1028 +pymc-devs__pytensor-1041 +pymc-devs__pytensor-1056 +pymc-devs__pytensor-1059 +pymc-devs__pytensor-1119 +pymc-devs__pytensor-1139 +pymc-devs__pytensor-1141 +pymc-devs__pytensor-1165 +pymc-devs__pytensor-1179 +pymc-devs__pytensor-1185 +pymc-devs__pytensor-1202 +pymc-devs__pytensor-1231 +pymc-devs__pytensor-1250 +pymc-devs__pytensor-1273 +pymc-devs__pytensor-1313 +pymc-devs__pytensor-1314 +pymc-devs__pytensor-1394 +pymc-devs__pytensor-1396 +pymc-devs__pytensor-1414 +pymc-devs__pytensor-1435 +pymodbus-dev__pymodbus-1533 +pymodbus-dev__pymodbus-1547 +pymodbus-dev__pymodbus-1638 +pymodbus-dev__pymodbus-1659 +pymodbus-dev__pymodbus-1671 +pymodbus-dev__pymodbus-1743 +pymodbus-dev__pymodbus-1923 +pymodbus-dev__pymodbus-1965 +pymodbus-dev__pymodbus-1987 +pymodbus-dev__pymodbus-2337 +pymodbus-dev__pymodbus-2426 +pymodbus-dev__pymodbus-2502 +pymodbus-dev__pymodbus-2593 +pymodbus-dev__pymodbus-2665 +pymodbus-dev__pymodbus-2678 +pymor__pymor-577 +pymor__pymor-810 +pyomo__pyomo-1994 +pyomo__pyomo-2038 +pyomo__pyomo-2048 +pyomo__pyomo-2072 +pyomo__pyomo-2074 +pyomo__pyomo-2172 +pyomo__pyomo-2177 +pyomo__pyomo-2209 +pyomo__pyomo-2231 +pyomo__pyomo-2263 +pyomo__pyomo-2305 +pyomo__pyomo-2324 +pyomo__pyomo-2421 +pyomo__pyomo-2444 +pyomo__pyomo-2458 +pyomo__pyomo-2504 +pyomo__pyomo-2549 +pyomo__pyomo-2567 +pyomo__pyomo-2597 +pyomo__pyomo-2619 +pyomo__pyomo-2633 +pyomo__pyomo-2643 +pyomo__pyomo-2685 +pyomo__pyomo-2740 +pyomo__pyomo-2765 +pyomo__pyomo-2833 +pyomo__pyomo-2848 +pyomo__pyomo-2849 +pyomo__pyomo-2852 +pyomo__pyomo-2863 +pyomo__pyomo-2879 +pyomo__pyomo-2997 +pyomo__pyomo-3009 +pyomo__pyomo-3017 +pyomo__pyomo-3041 +pyomo__pyomo-3056 +pyomo__pyomo-3069 +pyomo__pyomo-3099 +pyomo__pyomo-3129 +pyomo__pyomo-3193 +pyomo__pyomo-3238 +pyomo__pyomo-3288 +pyomo__pyomo-3337 +pyomo__pyomo-3387 +pyomo__pyomo-3392 +pyomo__pyomo-3394 +pyomo__pyomo-3472 +pyomo__pyomo-3538 +pyomo__pyomo-3541 +pyomo__pyomo-3588 +pypa__bandersnatch-1442 +pypa__bandersnatch-1557 +pypa__bandersnatch-1765 +pypa__bandersnatch-1861 +pypa__bandersnatch-48 +pypa__build-218 +pypa__build-229 +pypa__build-232 +pypa__build-274 +pypa__build-284 +pypa__build-290 +pypa__build-318 +pypa__build-339 +pypa__build-365 +pypa__build-631 +pypa__build-649 +pypa__packaging-165 +pypa__packaging-185 +pypa__packaging-199 +pypa__packaging-213 +pypa__packaging-218 +pypa__packaging-248 +pypa__packaging-29 +pypa__packaging-390 +pypa__packaging-47 +pypa__packaging-499 +pypa__packaging-607 +pypa__packaging-620 +pypa__packaging-634 +pypa__packaging-650 +pypa__packaging-662 +pypa__packaging-674 +pypa__packaging-684 +pypa__packaging-690 +pypa__packaging-71 +pypa__packaging-711 +pypa__packaging-712 +pypa__packaging-728 +pypa__packaging-73 +pypa__packaging-734 +pypa__packaging-802 +pypa__packaging-825 +pypa__packaging-888 +pypa__pip-10288 +pypa__pip-11124 +pypa__pip-11466 +pypa__pip-11663 +pypa__pip-12078 +pypa__pip-12991 +pypa__pip-13065 +pypa__pip-13303 +pypa__pipx-1002 +pypa__pipx-1102 +pypa__pipx-1159 +pypa__pipx-1163 +pypa__pipx-1171 +pypa__pipx-1186 +pypa__pipx-1196 +pypa__pipx-1208 +pypa__pipx-1237 +pypa__pipx-1241 +pypa__pipx-1252 +pypa__pipx-1256 +pypa__pipx-1261 +pypa__pipx-1267 +pypa__pipx-1284 +pypa__pipx-1306 +pypa__pipx-1329 +pypa__pipx-1339 +pypa__pipx-1343 +pypa__pipx-1350 +pypa__pipx-1390 +pypa__pipx-1414 +pypa__pipx-1446 +pypa__pipx-1493 +pypa__pipx-1510 +pypa__pipx-1597 +pypa__pipx-1625 +pypa__pipx-770 +pypa__pipx-852 +pypa__pipx-881 +pypa__pipx-916 +pypa__setuptools-1100 +pypa__setuptools-1103 +pypa__setuptools-1108 +pypa__setuptools-1116 +pypa__setuptools-1129 +pypa__setuptools-1150 +pypa__setuptools-1312 +pypa__setuptools-1364 +pypa__setuptools-1365 +pypa__setuptools-1389 +pypa__setuptools-1418 +pypa__setuptools-1423 +pypa__setuptools-1465 +pypa__setuptools-1520 +pypa__setuptools-1541 +pypa__setuptools-1547 +pypa__setuptools-1554 +pypa__setuptools-1576 +pypa__setuptools-1625 +pypa__setuptools-1650 +pypa__setuptools-1791 +pypa__setuptools-1847 +pypa__setuptools-1921 +pypa__setuptools-4485 +pypa__setuptools-4611 +pypa__setuptools-4647 +pypa__setuptools-4676 +pypa__setuptools-4856 +pypa__setuptools-4870 +pypa__setuptools-4911 +pypa__setuptools-809 +pypa__setuptools-840 +pypa__setuptools-853 +pypa__setuptools_scm-247 +pypa__setuptools_scm-681 +pypa__twine-1066 +pypa__twine-1106 +pypa__twine-1123 +pypa__virtualenv-2907 +pypsa__linopy-432 +pyqtgraph__pyqtgraph-1275 +pyqtgraph__pyqtgraph-1392 +pyqtgraph__pyqtgraph-1540 +pyqtgraph__pyqtgraph-1546 +pyqtgraph__pyqtgraph-1653 +pyqtgraph__pyqtgraph-1725 +pyqtgraph__pyqtgraph-1764 +pyqtgraph__pyqtgraph-1765 +pyqtgraph__pyqtgraph-1845 +pyqtgraph__pyqtgraph-2305 +pyqtgraph__pyqtgraph-2481 +pyqtgraph__pyqtgraph-2522 +pyqtgraph__pyqtgraph-2648 +pyqtgraph__pyqtgraph-3134 +pyqtgraph__pyqtgraph-3264 +pyqtgraph__pyqtgraph-3278 +pyro-ppl__numpyro-1918 +pyro-ppl__numpyro-1960 +pyro-ppl__numpyro-2024 +pysal__libpysal-591 +pysal__libpysal-777 +pysmt__pysmt-812 +pytask-dev__pytask-102 +pytask-dev__pytask-106 +pytask-dev__pytask-121 +pytask-dev__pytask-138 +pytask-dev__pytask-142 +pytask-dev__pytask-156 +pytask-dev__pytask-198 +pytask-dev__pytask-200 +pytask-dev__pytask-210 +pytask-dev__pytask-218 +pytask-dev__pytask-226 +pytask-dev__pytask-252 +pytask-dev__pytask-263 +pytask-dev__pytask-276 +pytask-dev__pytask-277 +pytask-dev__pytask-285 +pytask-dev__pytask-287 +pytask-dev__pytask-289 +pytask-dev__pytask-290 +pytask-dev__pytask-325 +pytask-dev__pytask-337 +pytask-dev__pytask-354 +pytask-dev__pytask-357 +pytask-dev__pytask-373 +pytask-dev__pytask-381 +pytask-dev__pytask-493 +pytask-dev__pytask-517 +pytask-dev__pytask-519 +pytask-dev__pytask-521 +pytask-dev__pytask-626 +pytask-dev__pytask-628 +pytask-dev__pytask-646 +pytask-dev__pytask-673 +pytask-dev__pytask-76 +pytest-dev__pyfakefs-1000 +pytest-dev__pyfakefs-1011 +pytest-dev__pyfakefs-1015 +pytest-dev__pyfakefs-1039 +pytest-dev__pyfakefs-1052 +pytest-dev__pyfakefs-1075 +pytest-dev__pyfakefs-1123 +pytest-dev__pyfakefs-1163 +pytest-dev__pyfakefs-1170 +pytest-dev__pyfakefs-1181 +pytest-dev__pyfakefs-801 +pytest-dev__pyfakefs-903 +pytest-dev__pyfakefs-916 +pytest-dev__pyfakefs-958 +pytest-dev__pyfakefs-969 +pytest-dev__pyfakefs-975 +pytest-dev__pyfakefs-978 +pytest-dev__pyfakefs-983 +pytest-dev__pyfakefs-985 +pytest-dev__pyfakefs-991 +pytest-dev__pytest-xdist-1026 +pytest-dev__pytest-xdist-505 +pytest-dev__pytest-xdist-851 +pytest-dev__pytest-xdist-862 +pytest-dev__pytest-xdist-901 +pythainlp__pythainlp-1046 +pythainlp__pythainlp-1056 +pythainlp__pythainlp-1058 +pythainlp__pythainlp-1059 +pythainlp__pythainlp-1062 +pythainlp__pythainlp-1066 +pythainlp__pythainlp-1114 +pythainlp__pythainlp-371 +pythainlp__pythainlp-382 +pythainlp__pythainlp-399 +pythainlp__pythainlp-802 +pythainlp__pythainlp-998 +python-attrs__attrs-1009 +python-attrs__attrs-1107 +python-attrs__attrs-1117 +python-attrs__attrs-1165 +python-attrs__attrs-1172 +python-attrs__attrs-1187 +python-attrs__attrs-1267 +python-attrs__attrs-1303 +python-attrs__attrs-1319 +python-attrs__attrs-1320 +python-attrs__attrs-1321 +python-attrs__attrs-1372 +python-attrs__attrs-1410 +python-attrs__attrs-1417 +python-attrs__attrs-173 +python-attrs__attrs-286 +python-attrs__attrs-292 +python-attrs__attrs-302 +python-attrs__attrs-367 +python-attrs__attrs-383 +python-attrs__attrs-394 +python-attrs__attrs-430 +python-attrs__attrs-431 +python-attrs__attrs-500 +python-attrs__attrs-556 +python-attrs__attrs-560 +python-attrs__attrs-563 +python-attrs__attrs-574 +python-attrs__attrs-586 +python-attrs__attrs-663 +python-attrs__attrs-671 +python-attrs__attrs-681 +python-attrs__attrs-684 +python-attrs__attrs-704 +python-attrs__attrs-732 +python-attrs__attrs-760 +python-attrs__attrs-763 +python-attrs__attrs-770 +python-attrs__attrs-782 +python-attrs__attrs-806 +python-attrs__attrs-817 +python-attrs__attrs-830 +python-attrs__attrs-843 +python-attrs__attrs-877 +python-attrs__attrs-888 +python-babel__babel-1041 +python-babel__babel-1042 +python-babel__babel-1074 +python-babel__babel-1104 +python-babel__babel-1141 +python-babel__babel-1196 +python-babel__babel-295 +python-babel__babel-301 +python-babel__babel-338 +python-babel__babel-340 +python-babel__babel-410 +python-babel__babel-420 +python-babel__babel-427 +python-babel__babel-433 +python-babel__babel-435 +python-babel__babel-482 +python-babel__babel-488 +python-babel__babel-490 +python-babel__babel-505 +python-babel__babel-585 +python-babel__babel-590 +python-babel__babel-599 +python-babel__babel-621 +python-babel__babel-644 +python-babel__babel-645 +python-babel__babel-649 +python-babel__babel-681 +python-babel__babel-827 +python-babel__babel-955 +python-cmd2__cmd2-534 +python-cmd2__cmd2-635 +python-cmd2__cmd2-636 +python-cmd2__cmd2-681 +python-cmd2__cmd2-781 +python-cmd2__cmd2-831 +python-control__python-control-1145 +python-lsp__python-lsp-server-471 +python-markdown__markdown-1006 +python-markdown__markdown-1007 +python-markdown__markdown-1033 +python-markdown__markdown-1038 +python-markdown__markdown-1044 +python-markdown__markdown-1050 +python-markdown__markdown-1071 +python-markdown__markdown-1072 +python-markdown__markdown-1121 +python-markdown__markdown-1210 +python-markdown__markdown-1225 +python-markdown__markdown-1248 +python-markdown__markdown-1294 +python-markdown__markdown-1303 +python-markdown__markdown-1348 +python-markdown__markdown-1359 +python-markdown__markdown-1361 +python-markdown__markdown-1380 +python-markdown__markdown-1414 +python-markdown__markdown-1426 +python-markdown__markdown-1440 +python-markdown__markdown-1448 +python-markdown__markdown-1461 +python-markdown__markdown-1494 +python-markdown__markdown-1513 +python-markdown__markdown-1529 +python-markdown__markdown-681 +python-markdown__markdown-713 +python-markdown__markdown-740 +python-markdown__markdown-743 +python-markdown__markdown-785 +python-markdown__markdown-881 +python-markdown__markdown-886 +python-markdown__markdown-901 +python-markdown__markdown-934 +python-markdown__markdown-984 +python-markdown__markdown-989 +python-markdown__markdown-990 +python-markdown__markdown-991 +python-markdown__markdown-994 +python-markdown__markdown-995 +python-semver__python-semver-239 +python-semver__python-semver-245 +python-semver__python-semver-253 +python-semver__python-semver-254 +python-semver__python-semver-261 +python-semver__python-semver-264 +python-semver__python-semver-275 +python-semver__python-semver-292 +python-semver__python-semver-365 +python-semver__python-semver-368 +python-semver__python-semver-427 +python-semver__python-semver-462 +python-social-auth__social-core-1112 +python-social-auth__social-core-663 +python-trio__trio-2392 +python-trio__trio-2826 +python-trio__trio-2845 +python-trio__trio-3042 +python-trio__trio-3051 +python-trio__trio-3197 +python-trio__trio-3256 +python-trio__trio-3280 +python-zk__kazoo-755 +python__bedevere-606 +python__bedevere-617 +python__bedevere-641 +python__bedevere-657 +python__typing_extensions-157 +python__typing_extensions-160 +python__typing_extensions-208 +python__typing_extensions-237 +python__typing_extensions-275 +python__typing_extensions-294 +python__typing_extensions-296 +python__typing_extensions-382 +python__typing_extensions-390 +python__typing_extensions-417 +python__typing_extensions-423 +python__typing_extensions-430 +python__typing_extensions-480 +python__typing_extensions-497 +python__typing_extensions-611 +python__typing_extensions-614 +pytorch__ignite-267 +pytorch__ignite-524 +pytorch__ignite-569 +pyvrp__pyvrp-205 +pyvrp__pyvrp-214 +pyvrp__pyvrp-236 +pyvrp__pyvrp-254 +pyvrp__pyvrp-280 +pyvrp__pyvrp-287 +pyvrp__pyvrp-436 +pyvrp__pyvrp-460 +pyvrp__pyvrp-682 +pyvrp__pyvrp-803 +pyvrp__pyvrp-841 +qchackers__tqec-245 +qchackers__tqec-309 +qchackers__tqec-319 +qchackers__tqec-371 +qchackers__tqec-372 +qchackers__tqec-376 +qcodes__qcodes-5612 +qiime2__qiime2-484 +qiime2__qiime2-485 +qiniu__goc-95 +qiskit-community__ecosystem-135 +qiskit-community__ecosystem-159 +qiskit-community__ecosystem-22 +qiskit-community__ecosystem-276 +qiskit-community__ecosystem-75 +qiskit-community__ffsim-119 +qiskit-community__ffsim-122 +qiskit-community__ffsim-157 +qiskit-community__ffsim-193 +qiskit-community__ffsim-200 +qiskit-community__ffsim-248 +qiskit-community__ffsim-279 +qiskit-community__ffsim-295 +qiskit-community__ffsim-318 +qiskit-community__ffsim-88 +qiskit-extensions__circuit-knitting-toolbox-507 +qiskit__qiskit-10528 +qiskit__qiskit-10791 +qiskit__qiskit-10825 +qiskit__qiskit-10834 +qiskit__qiskit-11041 +qiskit__qiskit-11063 +qiskit__qiskit-11073 +qiskit__qiskit-11181 +qiskit__qiskit-11197 +qiskit__qiskit-11206 +qiskit__qiskit-11249 +qiskit__qiskit-11272 +qiskit__qiskit-11367 +qiskit__qiskit-11432 +qiskit__qiskit-11466 +qiskit__qiskit-11719 +qiskit__qiskit-11877 +qiskit__qiskit-11959 +qiskit__qiskit-12045 +qiskit__qiskit-12055 +qiskit__qiskit-12131 +qiskit__qiskit-12369 +qiskit__qiskit-12370 +qiskit__qiskit-12379 +qiskit__qiskit-12400 +qiskit__qiskit-12479 +qiskit__qiskit-12523 +qiskit__qiskit-12527 +qiskit__qiskit-12620 +qiskit__qiskit-12621 +qiskit__qiskit-12665 +qiskit__qiskit-12813 +qiskit__qiskit-ibm-runtime-2187 +qiskit__qiskit-ibm-runtime-361 +qiskit__qiskit-ibm-runtime-367 +qiskit__qiskit-ibm-runtime-370 +qiskit__qiskit-ibm-runtime-380 +qiskit__qiskit-ibm-runtime-452 +qiskit__qiskit-ibm-runtime-514 +qiskit__qiskit-ibm-runtime-707 +qiskit__qiskit-terra-5490 +qiskit__qiskit-terra-5619 +qiskit__qiskit-terra-5648 +qiskit__qiskit-terra-5662 +qiskit__qiskit-terra-5705 +qiskit__qiskit-terra-5778 +qiskit__qiskit-terra-5808 +qiskit__qiskit-terra-5818 +qiskit__qiskit-terra-5833 +qiskit__qiskit-terra-6658 +qiskit__qiskit-terra-7408 +qiskit__qiskit-terra-7423 +qiskit__qiskit-terra-7711 +qiskit__qiskit-terra-7744 +qiskit__qiskit-terra-7765 +qiskit__qiskit-terra-7789 +qiskit__qiskit-terra-7799 +qiskit__qiskit-terra-7823 +qiskit__qiskit-terra-7919 +qiskit__qiskit-terra-7942 +qiskit__qiskit-terra-7952 +qiskit__qiskit-terra-7970 +qiskit__qiskit-terra-7972 +qiskit__qiskit-terra-8041 +qiskit__qiskit-terra-8055 +qiskit__qiskit-terra-8091 +qiskit__qiskit-terra-8098 +qiskit__qiskit-terra-8099 +qiskit__qiskit-terra-8134 +qiskit__qiskit-terra-8160 +qiskit__qiskit-terra-8166 +qiskit__qiskit-terra-8216 +qiskit__qiskit-terra-8234 +qiskit__qiskit-terra-8250 +qiskit__qiskit-terra-8278 +qiskit__qiskit-terra-8288 +qiskit__qiskit-terra-8335 +qiskit__qiskit-terra-8381 +qiskit__qiskit-terra-8463 +qiskit__qiskit-terra-8570 +qiskit__qiskit-terra-8571 +qiskit__qiskit-terra-8614 +qiskit__qiskit-terra-8625 +qiskit__qiskit-terra-8638 +qiskit__qiskit-terra-8701 +qiskit__qiskit-terra-8731 +qiskit__qiskit-terra-8741 +qiskit__qiskit-terra-8764 +qiskit__qiskit-terra-8767 +qiskit__qiskit-terra-8790 +qiskit__qiskit-terra-8837 +qiskit__qiskit-terra-8852 +qiskit__qiskit-terra-8877 +qiskit__qiskit-terra-8906 +qiskit__qiskit-terra-8924 +qiskit__qiskit-terra-8927 +qiskit__qiskit-terra-8977 +qiskit__qiskit-terra-8983 +qiskit__qiskit-terra-8995 +qiskit__qiskit-terra-8998 +qiskit__qiskit-terra-9000 +qiskit__qiskit-terra-9006 +qiskit__qiskit-terra-9067 +qiskit__qiskit-terra-9089 +qiskit__qiskit-terra-9100 +qiskit__qiskit-terra-9103 +qiskit__qiskit-terra-9211 +qiskit__qiskit-terra-9222 +qiskit__qiskit-terra-9310 +qiskit__qiskit-terra-9312 +qiskit__qiskit-terra-9391 +qiskit__qiskit-terra-9404 +qiskit__qiskit-terra-9441 +qiskit__qiskit-terra-9494 +qiskit__qiskit-terra-9536 +qiskit__retworkx-241 +qmuntal__gltf-92 +qmuntal__gltf-94 +qossmic__deptrac-1227 +qossmic__deptrac-899 +qossmic__deptrac-902 +qossmic__deptrac-903 +qossmic__deptrac-904 +qossmic__deptrac-935 +qossmic__deptrac-987 +qpdf__qpdf-289 +quansight__ragna-249 +quansight__ragna-281 +quansight__ragna-333 +quansight__ragna-357 +quansight__ragna-426 +quansight__ragna-456 +quansight__ragna-482 +quantconnect__lean-cli-403 +quantconnect__lean-cli-456 +quantconnect__lean-cli-486 +quantecon__quantecon.py-736 +quantecon__quantecon.py-769 +quantecon__quantecon.py-770 +quantum-accelerators__quacc-1649 +quantum-accelerators__quacc-1689 +quantum-accelerators__quacc-1861 +quantum-accelerators__quacc-2151 +quantum-accelerators__quacc-2587 +quantum-elixir__quantum-core-454 +quantum-elixir__quantum-core-523 +quantum-elixir__quantum-core-601 +quantum-tii__qibo-328 +quantum-tii__qibo-345 +quantum-tii__qibo-349 +quantum-tii__qibo-358 +quantum-tii__qibo-410 +quantumbfs__yao.jl-506 +quantumlib__openfermion-501 +quantumlib__openfermion-95 +quartiq__minimq-129 +quartiq__minimq-142 +quartiq__minimq-164 +quartiq__minimq-20 +quartiq__minimq-52 +quartiq__minimq-54 +quick__nimble-1017 +quick__nimble-1020 +quick__nimble-1151 +quick__nimble-1163 +quick__nimble-1183 +quick__nimble-706 +quick__quick-1146 +quick__quick-1183 +quick__quick-1220 +quick__quick-1230 +quickfixgo__quickfix-711 +quinn-rs__quinn-1983 +quinn-rs__quinn-1987 +quora__pyanalyze-315 +quora__pyanalyze-344 +quora__pyanalyze-357 +quora__pyanalyze-427 +quora__pyanalyze-441 +quora__pyanalyze-465 +quora__pyanalyze-564 +quora__pyanalyze-653 +quora__pyanalyze-658 +quora__pyanalyze-688 +quora__pyanalyze-738 +quora__pyanalyze-746 +quora__pyanalyze-747 +quora__pyanalyze-749 +quora__pyanalyze-752 +quramy__prisma-fabbrica-103 +quramy__prisma-fabbrica-169 +quramy__prisma-fabbrica-257 +quramy__prisma-fabbrica-283 +quramy__prisma-fabbrica-296 +quramy__prisma-fabbrica-350 +quramy__prisma-fabbrica-37 +quramy__prisma-fabbrica-56 +quramy__prisma-fabbrica-58 +quramy__prisma-fabbrica-77 +qutech__qupulse-797 +qutip__qutip-2342 +qutip__qutip-2545 +qutip__qutip-2548 +qutip__qutip-2561 +qutip__qutip-2672 +qutip__qutip-2694 +r-lib__bench-149 +r-lib__bench-150 +r-lib__bench-90 +r-lib__covr-499 +r-lib__covr-526 +r-lib__debugme-45 +r-lib__downlit-147 +r-lib__downlit-58 +r-lib__gmailr-165 +r-lib__usethis-1377 +r-lib__usethis-1830 +r-lib__usethis-1831 +rackt__react-router-2855 +rackt__react-router-3054 +radicle-dev__heartwood-395 +radicle-dev__heartwood-424 +radicle-dev__heartwood-49 +radicle-dev__heartwood-54 +radioastronomysoftwaregroup__pyuvdata-642 +radioastronomysoftwaregroup__pyuvdata-658 +radioastronomysoftwaregroup__pyuvdata-701 +radioastronomysoftwaregroup__pyuvdata-724 +radix-ui__primitives-3510 +radondb__radondb-mysql-kubernetes-811 +radzenhq__radzen-blazor-1627 +radzenhq__radzen-blazor-1933 +railwayapp__nixpacks-1234 +railwayapp__nixpacks-1242 +railwayapp__nixpacks-150 +railwayapp__nixpacks-402 +railwayapp__nixpacks-41 +railwayapp__nixpacks-415 +railwayapp__nixpacks-560 +railwayapp__nixpacks-605 +railwayapp__nixpacks-622 +railwayapp__nixpacks-712 +railwayapp__nixpacks-725 +railwayapp__nixpacks-766 +railwayapp__nixpacks-782 +raineorshine__npm-check-updates-1134 +raineorshine__npm-check-updates-1156 +raineorshine__npm-check-updates-1383 +raineorshine__npm-check-updates-1385 +raineorshine__npm-check-updates-768 +raml-org__raml-java-parser-155 +raml-org__raml-java-parser-182 +raml-org__raml-java-parser-197 +raml-org__raml-java-parser-252 +raml-org__raml-java-parser-283 +raml-org__raml-java-parser-285 +raml-org__raml-java-parser-286 +raml-org__raml-java-parser-292 +raml-org__raml-java-parser-387 +raml-org__raml-java-parser-434 +raml-org__raml-java-parser-455 +raml-org__raml-java-parser-465 +raml-org__raml-java-parser-469 +raml-org__raml-java-parser-504 +raml-org__raml-java-parser-506 +raml-org__raml-java-parser-510 +raml-org__raml-java-parser-514 +raml-org__raml-java-parser-570 +raml-org__raml-java-parser-612 +raml-org__raml-java-parser-614 +ranaroussi__yfinance-2389 +rancher-sandbox__cluster-api-provider-rke2-115 +rancher-sandbox__cluster-api-provider-rke2-190 +rancher__cluster-api-provider-rke2-436 +rancher__cluster-api-provider-rke2-551 +randombit__botan-2425 +randyzwitch__streamlit-folium-165 +raphlinus__pulldown-cmark-621 +raphlinus__pulldown-cmark-643 +raphlinus__pulldown-cmark-665 +raphlinus__pulldown-cmark-668 +raphlinus__pulldown-cmark-672 +raphlinus__pulldown-cmark-675 +raphlinus__pulldown-cmark-676 +raphlinus__pulldown-cmark-681 +raphlinus__pulldown-cmark-688 +raphlinus__pulldown-cmark-699 +raphlinus__pulldown-cmark-738 +raphlinus__pulldown-cmark-740 +raphlinus__pulldown-cmark-742 +raphlinus__pulldown-cmark-752 +raphlinus__pulldown-cmark-754 +raphlinus__pulldown-cmark-756 +raphlinus__pulldown-cmark-759 +raphlinus__pulldown-cmark-761 +raphlinus__pulldown-cmark-767 +raphlinus__pulldown-cmark-771 +raphlinus__pulldown-cmark-780 +raphlinus__pulldown-cmark-785 +raphlinus__pulldown-cmark-786 +raphlinus__pulldown-cmark-790 +raphlinus__pulldown-cmark-792 +raphlinus__pulldown-cmark-794 +raphlinus__pulldown-cmark-796 +raphlinus__pulldown-cmark-798 +raphlinus__pulldown-cmark-809 +raphlinus__pulldown-cmark-811 +raphlinus__pulldown-cmark-814 +raphlinus__pulldown-cmark-818 +raphlinus__pulldown-cmark-820 +raphlinus__pulldown-cmark-827 +raphlinus__pulldown-cmark-829 +raphlinus__pulldown-cmark-841 +rare-technologies__smart_open-702 +rare-technologies__smart_open-735 +rare-technologies__smart_open-737 +rare-technologies__smart_open-744 +rare-technologies__smart_open-771 +rasbt__mlxtend-1087 +rasbt__mlxtend-744 +rasbt__mlxtend-765 +rasbt__mlxtend-990 +rascarlito__axios-cache-adapter-232 +rascarlito__axios-cache-adapter-237 +raszi__node-tmp-130 +ratify-project__ratify-1538 +ratify-project__ratify-1650 +ratify-project__ratify-1779 +ratify-project__ratify-1829 +ratify-project__ratify-1890 +ratify-project__ratify-2010 +raviqqe__muffet-103 +raviqqe__muffet-106 +raviqqe__muffet-120 +raviqqe__muffet-154 +raviqqe__muffet-204 +raviqqe__muffet-269 +raviqqe__muffet-275 +raviqqe__muffet-309 +raviqqe__muffet-317 +raviqqe__muffet-392 +raviqqe__muffet-93 +rayon-rs__rayon-986 +rcardin__raise4s-103 +rcardin__raise4s-104 +rcardin__raise4s-106 +rcardin__raise4s-108 +rcardin__raise4s-109 +rcardin__raise4s-16 +rcardin__raise4s-28 +rcardin__raise4s-29 +rcardin__raise4s-34 +rcardin__raise4s-62 +rcardin__raise4s-7 +rcardin__raise4s-77 +rcardin__raise4s-78 +rclone__rclone-8433 +rcoh__angle-grinder-149 +rcoh__angle-grinder-204 +rcoh__angle-grinder-37 +react-hook-form__resolvers-728 +react-hook-form__resolvers-737 +react-hook-form__resolvers-752 +react-materialize__react-materialize-1086 +react-materialize__react-materialize-530 +react-materialize__react-materialize-613 +react-materialize__react-materialize-760 +react-materialize__react-materialize-789 +react-materialize__react-materialize-824 +react-materialize__react-materialize-840 +react-materialize__react-materialize-857 +react-materialize__react-materialize-877 +react-materialize__react-materialize-926 +reactiflux__discord-irc-260 +reactiflux__discord-irc-267 +reactiflux__discord-irc-301 +reactiflux__discord-irc-31 +reactiflux__discord-irc-32 +reactiflux__discord-irc-476 +reactiflux__discord-irc-497 +reactiflux__discord-irc-61 +reactioncommerce__reaction-component-library-101 +reactioncommerce__reaction-component-library-102 +reactioncommerce__reaction-component-library-130 +reactioncommerce__reaction-next-starterkit-450 +reactivecircus__android-emulator-runner-14 +reactivecircus__android-emulator-runner-180 +reactivecircus__android-emulator-runner-185 +reactivecircus__android-emulator-runner-209 +reactivecircus__android-emulator-runner-317 +reactivecircus__android-emulator-runner-428 +reactphp__http-365 +reactphp__http-395 +reactphp__http-405 +reactphp__http-442 +reactphp__http-516 +reactphp__promise-195 +reactphp__promise-225 +reactphp__promise-236 +reactphp__promise-237 +reactphp__promise-248 +reagento__dishka-291 +reagento__dishka-436 +reakit__reakit-725 +reata__sqllineage-223 +reata__sqllineage-224 +reata__sqllineage-230 +reata__sqllineage-234 +reata__sqllineage-235 +reata__sqllineage-239 +reata__sqllineage-366 +reata__sqllineage-582 +reata__sqllineage-619 +reata__sqllineage-694 +rectorphp__rector-symfony-797 +redhat-certification__chart-verifier-133 +redhat-certification__chart-verifier-137 +redhat-certification__chart-verifier-141 +redhat-certification__chart-verifier-24 +redhat-developer__service-binding-operator-1005 +redhat-developer__service-binding-operator-1039 +redhat-developer__service-binding-operator-67 +redhat-openshift-ecosystem__openshift-preflight-232 +redhat-openshift-ecosystem__openshift-preflight-244 +redis__redis-py-1756 +redis__redis-py-1817 +redis__redis-py-1870 +redis__redis-py-1992 +redis__redis-py-2259 +redis__redis-py-2278 +redis__redis-py-2760 +redocly__openapi-cli-315 +redocly__openapi-cli-448 +redocly__openapi-cli-502 +redocly__openapi-cli-523 +redocly__openapi-cli-603 +redocly__redoc-1596 +redocly__redocly-cli-1014 +redocly__redocly-cli-1191 +redocly__redocly-cli-1208 +redocly__redocly-cli-1270 +redocly__redocly-cli-1600 +redocly__redocly-cli-1890 +redocly__redocly-cli-713 +redocly__redocly-cli-722 +redocly__redocly-cli-813 +redocly__redocly-cli-886 +redocly__redocly-cli-887 +redocly__redocly-cli-902 +redocly__redocly-cli-906 +redocly__redocly-cli-990 +redpen-cc__redpen-611 +redpen-cc__redpen-770 +redpen-cc__redpen-774 +reduxjs__react-redux-1263 +reduxjs__react-redux-1377 +reduxjs__react-redux-1447 +reduxjs__react-redux-1701 +reduxjs__redux-toolkit-320 +reduxjs__redux-toolkit-440 +reduxjs__redux-toolkit-457 +reduxjs__redux-toolkit-492 +reduxjs__redux-toolkit-544 +reduxjs__redux-toolkit-546 +reduxjs__redux-toolkit-570 +reduxjs__redux-toolkit-573 +reduxjs__redux-toolkit-574 +reduxjs__redux-toolkit-621 +reduxjs__redux-toolkit-940 +reduxjs__redux-toolkit-943 +reduxjs__redux-toolkit-976 +reef-pi__reef-pi-1218 +reef-pi__reef-pi-856 +reef-pi__reef-pi-864 +reef-pi__reef-pi-871 +refined-github__refined-github-7422 +refined-github__refined-github-7665 +refined-github__refined-github-7796 +refined-github__refined-github-8194 +regclient__regclient-381 +regclient__regclient-477 +regclient__regclient-554 +regclient__regclient-646 +regclient__regclient-734 +regclient__regclient-738 +regclient__regclient-751 +regclient__regclient-765 +regclient__regclient-795 +regclient__regclient-821 +regclient__regclient-866 +regclient__regclient-930 +relayrides__pushy-170 +relayrides__pushy-278 +relayrides__pushy-307 +relayrides__pushy-391 +relayrides__pushy-393 +relayrides__pushy-394 +relayrides__pushy-442 +relayrides__pushy-516 +relayrides__pushy-671 +relayrides__pushy-702 +relayrides__pushy-724 +release-drafter__release-drafter-1017 +release-drafter__release-drafter-1049 +release-drafter__release-drafter-1050 +release-drafter__release-drafter-1065 +release-drafter__release-drafter-324 +release-drafter__release-drafter-500 +release-drafter__release-drafter-541 +release-drafter__release-drafter-611 +release-drafter__release-drafter-865 +relekang__python-semantic-release-21 +relekang__python-semantic-release-220 +relekang__python-semantic-release-232 +relekang__python-semantic-release-242 +relekang__python-semantic-release-259 +relekang__python-semantic-release-276 +relekang__python-semantic-release-319 +relekang__python-semantic-release-359 +relekang__python-semantic-release-366 +relekang__python-semantic-release-373 +relekang__python-semantic-release-397 +relekang__python-semantic-release-502 +remarkablemark__html-dom-parser-923 +remarkablemark__html-react-parser-116 +remeda__remeda-1002 +remeda__remeda-421 +remeda__remeda-443 +remeda__remeda-518 +remeda__remeda-785 +remeda__remeda-854 +remind101__stacker-589 +remix-run__remix-2562 +remix-run__remix-6279 +remix-run__remix-6783 +remix-run__remix-7109 +remotemobprogramming__mob-121 +remotemobprogramming__mob-138 +remotemobprogramming__mob-152 +remotemobprogramming__mob-413 +remotemobprogramming__mob-421 +remotemobprogramming__mob-459 +remy__nodemon-1168 +remy__nodemon-2059 +renehernandez__obsidian-readwise-51 +renehernandez__obsidian-readwise-57 +renehernandez__obsidian-readwise-68 +replicatedhq__ship-1065 +replicatedhq__troubleshoot-180 +replicatedhq__troubleshoot-270 +replicatedhq__troubleshoot-271 +repobee__repobee-166 +repobee__repobee-190 +repobee__repobee-209 +researchobject__ro-crate-py-100 +researchobject__ro-crate-py-102 +researchobject__ro-crate-py-109 +researchobject__ro-crate-py-116 +researchobject__ro-crate-py-119 +researchobject__ro-crate-py-126 +researchobject__ro-crate-py-136 +researchobject__ro-crate-py-149 +researchobject__ro-crate-py-152 +researchobject__ro-crate-py-155 +researchobject__ro-crate-py-161 +researchobject__ro-crate-py-162 +researchobject__ro-crate-py-163 +researchobject__ro-crate-py-168 +researchobject__ro-crate-py-169 +researchobject__ro-crate-py-170 +researchobject__ro-crate-py-171 +researchobject__ro-crate-py-172 +researchobject__ro-crate-py-183 +researchobject__ro-crate-py-191 +researchobject__ro-crate-py-192 +researchobject__ro-crate-py-193 +researchobject__ro-crate-py-52 +researchobject__ro-crate-py-69 +researchobject__ro-crate-py-75 +researchobject__ro-crate-py-76 +researchobject__ro-crate-py-93 +researchobject__ro-crate-py-95 +restic__restic-4351 +restic__restic-4361 +restic__restic-4378 +restic__restic-4419 +restic__restic-4446 +restic__restic-4685 +restic__restic-4811 +restic__restic-4911 +restic__restic-5144 +restic__restic-5321 +retroachievements__raintegration-917 +retroachievements__raintegration-974 +reubeno__brush-290 +reviewdog__reviewdog-1264 +reviewdog__reviewdog-1576 +reviewdog__reviewdog-1653 +reviewdog__reviewdog-1804 +reviewdog__reviewdog-529 +rezact__rezact-15 +rezact__rezact-21 +rezact__rezact-23 +rezact__rezact-41 +rezact__rezact-42 +rezact__rezact-67 +rezact__rezact-70 +rezact__rezact-71 +rezact__rezact-74 +rezact__rezact-76 +rezact__rezact-77 +rhayes777__pyautofit-1012 +rhayes777__pyautofit-1053 +rhayes777__pyautofit-1061 +rhayes777__pyautofit-1063 +rhayes777__pyautofit-1080 +rhayes777__pyautofit-1096 +rhayes777__pyautofit-1097 +rhayes777__pyautofit-1115 +rhayes777__pyautofit-1119 +rhayes777__pyautofit-1127 +rhayes777__pyautofit-1133 +rhayes777__pyautofit-820 +rhayes777__pyautofit-829 +rhayes777__pyautofit-841 +rhayes777__pyautofit-856 +rhayes777__pyautofit-857 +rhayes777__pyautofit-864 +rhayes777__pyautofit-875 +rhayes777__pyautofit-876 +rhayes777__pyautofit-888 +rhayes777__pyautofit-934 +rhayes777__pyautofit-943 +rhayes777__pyautofit-947 +rhayes777__pyautofit-953 +rhayes777__pyautofit-973 +rhayes777__pyautofit-975 +rhayes777__pyautofit-991 +rhys-vdw__ts-auto-guard-242 +rich-harris__buble-121 +rich-harris__buble-128 +rich-harris__buble-157 +rich-harris__buble-178 +rich-harris__buble-47 +rich-harris__buble-48 +rich-harris__buble-52 +rich-harris__buble-54 +rich-harris__buble-65 +rich-harris__buble-82 +rich-harris__buble-83 +rickbergfalk__sqlpad-747 +rickbergfalk__sqlpad-750 +rickbergfalk__sqlpad-755 +rickbergfalk__sqlpad-758 +rigetticomputing__pyquil-115 +rigetticomputing__pyquil-119 +rigetticomputing__pyquil-122 +rigetticomputing__pyquil-156 +rigetticomputing__pyquil-166 +rigetticomputing__pyquil-177 +rigetticomputing__pyquil-203 +rigetticomputing__pyquil-264 +rigetticomputing__pyquil-312 +rigetticomputing__pyquil-383 +rigetticomputing__pyquil-399 +rigetticomputing__pyquil-440 +rigetticomputing__pyquil-498 +ripple__explorer-605 +ripple__explorer-627 +ripple__explorer-705 +ripple__explorer-740 +ripple__explorer-746 +ripple__explorer-832 +rmagatti__auto-session-413 +rmagatti__auto-session-421 +rmagatti__auto-session-427 +rmagatti__auto-session-457 +rmarkello__abagen-140 +roave__betterreflection-1138 +roave__betterreflection-1269 +roave__betterreflection-1285 +roave__betterreflection-1286 +roave__betterreflection-570 +roave__betterreflection-581 +roave__betterreflection-583 +roave__betterreflection-597 +roave__betterreflection-601 +roave__betterreflection-604 +roave__betterreflection-618 +roave__betterreflection-629 +roave__betterreflection-649 +roave__betterreflection-650 +roave__betterreflection-651 +roave__betterreflection-652 +roave__betterreflection-653 +roave__betterreflection-656 +roave__betterreflection-660 +roave__betterreflection-716 +roave__betterreflection-721 +roave__betterreflection-962 +roave__betterreflection-965 +robertkrimen__otto-267 +robertkrimen__otto-387 +robertkrimen__otto-437 +robintail__express-zod-api-203 +robintail__express-zod-api-234 +robintail__express-zod-api-270 +robintail__express-zod-api-518 +robintail__express-zod-api-655 +robintail__express-zod-api-664 +robintail__express-zod-api-674 +robintail__express-zod-api-676 +robintail__express-zod-api-713 +robintail__express-zod-api-714 +robintail__express-zod-api-815 +robintail__express-zod-api-821 +robintail__express-zod-api-852 +robintail__express-zod-api-908 +robintail__express-zod-api-909 +robintail__express-zod-api-910 +robintail__express-zod-api-930 +roboll__helmfile-2064 +roboll__helmfile-2121 +robotframework__pythonlibcore-147 +robotframework__seleniumlibrary-1039 +robotframework__seleniumlibrary-1248 +robotframework__seleniumlibrary-1258 +robotframework__seleniumlibrary-1269 +robotframework__seleniumlibrary-1309 +robotframework__seleniumlibrary-1310 +robotframework__seleniumlibrary-1312 +robotframework__seleniumlibrary-1366 +robotframework__seleniumlibrary-1376 +robotframework__seleniumlibrary-1401 +robotframework__seleniumlibrary-1428 +robotframework__seleniumlibrary-1431 +robotpy__cxxheaderparser-100 +robotpy__cxxheaderparser-106 +robotpy__cxxheaderparser-108 +robotpy__cxxheaderparser-124 +robotpy__cxxheaderparser-125 +robotpy__cxxheaderparser-2 +robotpy__cxxheaderparser-27 +robotpy__cxxheaderparser-28 +robotpy__cxxheaderparser-29 +robotpy__cxxheaderparser-30 +robotpy__cxxheaderparser-44 +robotpy__cxxheaderparser-50 +robotpy__cxxheaderparser-56 +robotpy__cxxheaderparser-59 +robotpy__cxxheaderparser-73 +robotpy__cxxheaderparser-8 +robotpy__cxxheaderparser-82 +robotpy__cxxheaderparser-85 +robotpy__cxxheaderparser-97 +robotpy__cxxheaderparser-98 +robsontenorio__vue-api-query-141 +robsontenorio__vue-api-query-173 +robsontenorio__vue-api-query-254 +rochacbruno__dynaconf-104 +rochacbruno__dynaconf-109 +rochacbruno__dynaconf-130 +rochacbruno__dynaconf-164 +rochacbruno__dynaconf-188 +rochacbruno__dynaconf-191 +rochacbruno__dynaconf-209 +rochacbruno__dynaconf-215 +rochacbruno__dynaconf-243 +rochacbruno__dynaconf-275 +rochacbruno__dynaconf-290 +rochacbruno__dynaconf-292 +rochacbruno__dynaconf-300 +rochacbruno__dynaconf-338 +rochacbruno__dynaconf-375 +rochacbruno__dynaconf-385 +rochacbruno__dynaconf-413 +rochacbruno__dynaconf-415 +rochacbruno__dynaconf-474 +rochacbruno__dynaconf-533 +rochacbruno__dynaconf-549 +rock-learning__pytransform3d-112 +rock-learning__pytransform3d-129 +rock-learning__pytransform3d-48 +rock-learning__pytransform3d-72 +rock-learning__pytransform3d-74 +roger-luo__configurations.jl-29 +roger-luo__configurations.jl-31 +roger-luo__configurations.jl-40 +roger-luo__configurations.jl-51 +rojo-rbx__rbx-dom-470 +rokucommunity__brighterscript-1050 +rokucommunity__brighterscript-1216 +rokucommunity__brighterscript-1357 +rokucommunity__brighterscript-1491 +rokucommunity__brighterscript-519 +rokucommunity__brighterscript-622 +rokucommunity__brighterscript-703 +rokucommunity__brighterscript-711 +rokucommunity__brighterscript-788 +rollbar__rollbar-go-102 +rollbar__rollbar-go-113 +rollbar__rollbar-go-115 +rollbar__rollbar-go-8 +rollbar__rollbar-go-99 +rollbar__rollbar-java-38 +rollbar__rollbar-java-51 +rollbar__rollbar-php-632 +rollbar__rollbar-php-649 +rollbar__rollbar-php-652 +rollerderby__scoreboard-496 +rollerderby__scoreboard-571 +rollerderby__scoreboard-631 +rollerderby__scoreboard-632 +ron-rs__ron-103 +ron-rs__ron-108 +ron-rs__ron-112 +ron-rs__ron-124 +ron-rs__ron-135 +ron-rs__ron-150 +ron-rs__ron-163 +ron-rs__ron-172 +ron-rs__ron-206 +ron-rs__ron-223 +ron-rs__ron-258 +ron-rs__ron-363 +ron-rs__ron-371 +ron-rs__ron-402 +ron-rs__ron-426 +ron-rs__ron-72 +ron-rs__ron-75 +ron-rs__ron-78 +ron-rs__ron-84 +ron-rs__ron-93 +ronasit__laravel-swagger-105 +ronasit__laravel-swagger-114 +ronasit__laravel-swagger-115 +ronasit__laravel-swagger-88 +rook__rook-15793 +rook__rook-15806 +rook__rook-16157 +rook__rook-16165 +rooseveltframework__roosevelt-382 +rooseveltframework__roosevelt-472 +rooseveltframework__roosevelt-601 +rooseveltframework__roosevelt-737 +rooseveltframework__roosevelt-745 +rooseveltframework__roosevelt-782 +rooseveltframework__roosevelt-824 +roots__acorn-234 +roots__acorn-237 +ropdebee__mb-userscripts-197 +ropdebee__mb-userscripts-237 +ropdebee__mb-userscripts-247 +ropdebee__mb-userscripts-327 +ropdebee__mb-userscripts-336 +ropdebee__mb-userscripts-337 +ropdebee__mb-userscripts-393 +ropdebee__mb-userscripts-445 +ropdebee__mb-userscripts-472 +ropdebee__mb-userscripts-669 +ropdebee__mb-userscripts-785 +roskakori__pygount-147 +roskakori__pygount-203 +roskakori__pygount-43 +roskakori__pygount-55 +roskakori__pygount-57 +ross-rotordynamics__ross-102 +ross-rotordynamics__ross-177 +ross-rotordynamics__ross-208 +ross-rotordynamics__ross-267 +ross-rotordynamics__ross-277 +ross-rotordynamics__ross-371 +ross-rotordynamics__ross-788 +ross-rotordynamics__ross-822 +rpi-distro__python-gpiozero-203 +rpi-distro__python-gpiozero-331 +rpi-distro__python-gpiozero-455 +rpi-distro__python-gpiozero-504 +rpi-distro__python-gpiozero-698 +rq__rq-1366 +rq__rq-1394 +rq__rq-1472 +rq__rq-1629 +rq__rq-1785 +rq__rq-1787 +rq__rq-1837 +rq__rq-1850 +rq__rq-1852 +rq__rq-1917 +rq__rq-1947 +rq__rq-2131 +rq__rq-2138 +rq__rq-2221 +rrd108__vue-mess-detector-129 +rrd108__vue-mess-detector-159 +rrd108__vue-mess-detector-347 +rrrene__credo-1094 +rrrene__credo-1095 +rrrene__credo-1152 +rrrene__credo-1206 +rrrene__credo-485 +rrrene__credo-508 +rrrene__credo-538 +rrrene__credo-659 +rrrene__credo-706 +rrrene__credo-711 +rrrene__credo-713 +rrrene__credo-721 +rsteube__carapace-161 +rsteube__carapace-165 +rsteube__carapace-200 +rsteube__carapace-201 +rsteube__carapace-227 +rsteube__carapace-257 +rsteube__carapace-273 +rsteube__carapace-299 +rsteube__carapace-320 +rsteube__carapace-322 +rsteube__carapace-345 +rsteube__carapace-346 +rsteube__carapace-367 +rsteube__carapace-368 +rsteube__carapace-370 +rsteube__carapace-372 +rsteube__carapace-445 +rsteube__carapace-534 +rsteube__carapace-555 +rsteube__carapace-601 +rsteube__carapace-605 +rsteube__carapace-634 +rsteube__carapace-683 +rsteube__carapace-711 +rsteube__carapace-715 +rsteube__carapace-834 +rsteube__carapace-889 +rsteube__carapace-938 +rsteube__carapace-963 +rsteube__carapace-982 +rstudio-education__gradethis-124 +rstudio-education__gradethis-156 +rstudio-education__gradethis-160 +rstudio-education__gradethis-161 +rstudio-education__gradethis-162 +rstudio-education__gradethis-178 +rstudio-education__gradethis-187 +rstudio-education__gradethis-192 +rstudio-education__gradethis-214 +rstudio-education__gradethis-244 +rstudio-education__gradethis-296 +rstudio-education__gradethis-309 +rstudio-education__gradethis-325 +rstudio-education__gradethis-329 +rstudio-education__gradethis-344 +rstudio-education__gradethis-359 +rstudio__gt-1116 +rstudio__gt-203 +rstudio__gt-283 +rstudio__gt-436 +rstudio__gt-450 +rstudio__gt-468 +rstudio__gt-481 +rstudio__gt-483 +rstudio__gt-495 +rstudio__gt-546 +rstudio__gt-55 +rstudio__gt-556 +rstudio__gt-561 +rstudio__gt-66 +rstudio__gt-689 +rstudio__gt-724 +rstudio__gt-755 +rstudio__gt-78 +rstudio__gt-783 +rstudio__gt-795 +rstudio__gt-814 +rstudio__gt-870 +rstudio__gt-871 +rstudio__gt-888 +rstudio__gt-907 +rstudio__gt-94 +rstudio__gt-992 +rstudio__pins-r-165 +rstudio__pins-r-507 +rstudio__pins-r-558 +rstudio__pins-r-586 +rstudio__pins-r-690 +rstudio__pins-r-727 +rstudio__pins-r-741 +rstudio__pins-r-811 +rstudio__shinymeta-70 +rstudio__vetiver-python-136 +rstudio__vetiver-python-185 +rstudio__vetiver-python-201 +rtfeldman__seamless-immutable-132 +rtfeldman__seamless-immutable-194 +rtfeldman__seamless-immutable-20 +rtfeldman__seamless-immutable-28 +rubenverborgh__sparql.js-58 +ruby__bigdecimal-203 +ruby__bigdecimal-221 +ruby__bigdecimal-243 +ruby__bigdecimal-302 +ruby__bigdecimal-329 +ruby__bigdecimal-353 +ruby__openssl-493 +ruby__prism-1726 +ruby__prism-1809 +ruby__prism-1910 +ruby__prism-2043 +ruby__prism-2081 +ruby__prism-2118 +ruby__prism-2576 +ruby__yarp-1370 +ruby__yarp-1463 +ruby__yarp-1517 +ruflin__elastica-1950 +ruflin__elastica-2032 +ruma__ruma-1030 +ruma__ruma-135 +ruma__ruma-573 +ruma__ruma-891 +ruma__ruma-985 +ruma__ruma-990 +russross__blackfriday-570 +rust-analyzer__rust-analyzer-1414 +rust-analyzer__rust-analyzer-1945 +rust-analyzer__rust-analyzer-2616 +rust-analyzer__rust-analyzer-2959 +rust-analyzer__rust-analyzer-3047 +rust-analyzer__rust-analyzer-3064 +rust-analyzer__rust-analyzer-3672 +rust-analyzer__rust-analyzer-4562 +rust-analyzer__rust-analyzer-4959 +rust-analyzer__rust-analyzer-5004 +rust-analyzer__rust-analyzer-5202 +rust-analyzer__rust-analyzer-5314 +rust-analyzer__rust-analyzer-5324 +rust-analyzer__rust-analyzer-5331 +rust-analyzer__rust-analyzer-5940 +rust-analyzer__rust-analyzer-5971 +rust-analyzer__rust-analyzer-6198 +rust-analyzer__rust-analyzer-6199 +rust-analyzer__rust-analyzer-6262 +rust-analyzer__rust-analyzer-6266 +rust-analyzer__rust-analyzer-7677 +rust-analyzer__rust-analyzer-7719 +rust-analyzer__rust-analyzer-7739 +rust-analyzer__rust-analyzer-7802 +rust-analyzer__rust-analyzer-8137 +rust-analyzer__rust-analyzer-8156 +rust-analyzer__rust-analyzer-8283 +rust-analyzer__rust-analyzer-8457 +rust-analyzer__rust-analyzer-8546 +rust-analyzer__rust-analyzer-8550 +rust-analyzer__rust-analyzer-8660 +rust-analyzer__rust-analyzer-8687 +rust-analyzer__rust-analyzer-8731 +rust-analyzer__rust-analyzer-8802 +rust-analyzer__rust-analyzer-8814 +rust-analyzer__rust-analyzer-8848 +rust-analyzer__rust-analyzer-8858 +rust-analyzer__rust-analyzer-8902 +rust-analyzer__rust-analyzer-8938 +rust-analyzer__rust-analyzer-8988 +rust-analyzer__rust-analyzer-8991 +rust-analyzer__rust-analyzer-9024 +rust-analyzer__rust-analyzer-9033 +rust-analyzer__rust-analyzer-9050 +rust-analyzer__rust-analyzer-9051 +rust-bitcoin__rust-bitcoin-4689 +rust-itertools__itertools-292 +rust-itertools__itertools-383 +rust-itertools__itertools-423 +rust-itertools__itertools-527 +rust-itertools__itertools-565 +rust-itertools__itertools-654 +rust-itertools__itertools-686 +rust-itertools__itertools-734 +rust-itertools__itertools-736 +rust-itertools__itertools-752 +rust-itertools__itertools-835 +rust-itertools__itertools-855 +rust-itertools__itertools-866 +rust-lang-nursery__futures-rs-1241 +rust-lang-nursery__futures-rs-1976 +rust-lang-nursery__futures-rs-726 +rust-lang-nursery__futures-rs-728 +rust-lang-nursery__futures-rs-732 +rust-lang-nursery__futures-rs-733 +rust-lang__annotate-snippets-rs-3 +rust-lang__annotate-snippets-rs-34 +rust-lang__annotate-snippets-rs-42 +rust-lang__annotate-snippets-rs-54 +rust-lang__annotate-snippets-rs-55 +rust-lang__annotate-snippets-rs-98 +rust-lang__cc-rs-1181 +rust-lang__cc-rs-1212 +rust-lang__cc-rs-1295 +rust-lang__cc-rs-914 +rust-lang__cc-rs-991 +rust-lang__chalk-222 +rust-lang__chalk-237 +rust-lang__chalk-282 +rust-lang__chalk-441 +rust-lang__chalk-442 +rust-lang__chalk-443 +rust-lang__chalk-444 +rust-lang__chalk-445 +rust-lang__chalk-447 +rust-lang__chalk-523 +rust-lang__chalk-534 +rust-lang__chalk-538 +rust-lang__chalk-545 +rust-lang__chalk-551 +rust-lang__chalk-573 +rust-lang__chalk-588 +rust-lang__chalk-598 +rust-lang__chalk-599 +rust-lang__chalk-630 +rust-lang__chalk-659 +rust-lang__chalk-671 +rust-lang__chalk-673 +rust-lang__chalk-755 +rust-lang__chalk-780 +rust-lang__chalk-827 +rust-lang__futures-rs-2884 +rust-lang__futures-rs-2947 +rust-lang__regex-1111 +rust-lang__regex-984 +rust-lang__rust-analyzer-12821 +rust-lang__rust-analyzer-13005 +rust-lang__rust-analyzer-13120 +rust-lang__rust-analyzer-13147 +rust-lang__rust-analyzer-13149 +rust-lang__rust-analyzer-13303 +rust-lang__rust-analyzer-13463 +rust-lang__rust-analyzer-13592 +rust-lang__rust-analyzer-13681 +rust-lang__rust-analyzer-13684 +rust-lang__rust-analyzer-13707 +rust-lang__rust-analyzer-13730 +rust-lang__rust-analyzer-13750 +rust-lang__rust-analyzer-13854 +rust-lang__rust-analyzer-14225 +rust-lang__rust-analyzer-14433 +rust-lang__rust-analyzer-14455 +rust-lang__rust-analyzer-14549 +rust-lang__rust-analyzer-14580 +rust-lang__rust-analyzer-14851 +rust-lang__rust-analyzer-14855 +rust-lang__rust-analyzer-14863 +rust-lang__rust-analyzer-14878 +rust-lang__rust-analyzer-15405 +rust-lang__rust-analyzer-15847 +rust-lang__rust-analyzer-15854 +rust-lang__rust-analyzer-15970 +rust-lang__rust-analyzer-17832 +rust-lang__rust-analyzer-17882 +rust-lang__rust-analyzer-17893 +rust-lang__rust-analyzer-17916 +rust-lang__rust-analyzer-17928 +rust-lang__rust-analyzer-17942 +rust-lang__rust-analyzer-18385 +rust-lang__rust-analyzer-18390 +rust-lang__rust-bindgen-2328 +rust-lang__rust-bindgen-2448 +rust-lang__rust-bindgen-2499 +rust-lang__rust-bindgen-2567 +rust-lang__rust-bindgen-2587 +rust-lang__rust-bindgen-2633 +rust-lang__rust-bindgen-2667 +rust-lang__rust-bindgen-2696 +rust-lang__rust-bindgen-2827 +rust-lang__rust-bindgen-2880 +rust-lang__rust-bindgen-2921 +rust-lang__rust-bindgen-2967 +rust-lang__rust-bindgen-2996 +rust-lang__rust-bindgen-3028 +rust-lang__rust-bindgen-3182 +rust-lang__rustfmt-4880 +rust-lang__rustfmt-4944 +rust-lang__rustfmt-4961 +rust-lang__rustfmt-4978 +rust-lang__rustfmt-4994 +rust-lang__rustfmt-5008 +rust-lang__rustfmt-5091 +rust-lang__rustfmt-5129 +rust-lang__rustfmt-5142 +rust-lang__rustfmt-5150 +rust-lang__rustfmt-5152 +rust-lang__rustfmt-5158 +rust-lang__rustfmt-5201 +rust-lang__rustfmt-5216 +rust-lang__rustfmt-5282 +rust-lang__rustfmt-5384 +rust-lang__rustfmt-5387 +rust-lang__rustfmt-5446 +rust-lang__rustfmt-5536 +rust-lang__rustfmt-5582 +rust-lang__rustfmt-5669 +rust-lang__rustfmt-5692 +rust-lang__rustfmt-5731 +rust-lang__rustfmt-5780 +rust-lang__rustfmt-5817 +rust-lang__rustfmt-5834 +rust-lang__rustfmt-5839 +rust-lang__rustfmt-5842 +rust-lang__rustfmt-5845 +rust-lang__rustfmt-5848 +rust-lang__rustfmt-5853 +rust-lang__rustfmt-5879 +rust-lang__rustfmt-5883 +rust-lang__rustfmt-5902 +rust-lang__rustfmt-5913 +rust-lang__rustfmt-5923 +rust-lang__rustfmt-5954 +rust-lang__rustfmt-5989 +rust-lang__rustfmt-6112 +rust-lang__rustfmt-6173 +rust-lang__rustfmt-6425 +rust-lang__socket2-194 +rust-lang__socket2-364 +rust-ndarray__ndarray-1019 +rust-ndarray__ndarray-1040 +rust-ndarray__ndarray-1068 +rust-ndarray__ndarray-1095 +rust-ndarray__ndarray-1362 +rust-ndarray__ndarray-1413 +rust-ndarray__ndarray-1417 +rust-ndarray__ndarray-1477 +rust-ndarray__ndarray-1480 +rust-ndarray__ndarray-1483 +rust-ndarray__ndarray-717 +rust-ndarray__ndarray-797 +rust-ndarray__ndarray-803 +rust-ndarray__ndarray-872 +rust-ndarray__ndarray-877 +rust-ndarray__ndarray-900 +rust-ndarray__ndarray-945 +rust-ndarray__ndarray-957 +rust-ndarray__ndarray-967 +rust-ndarray__ndarray-986 +rust-random__getrandom-133 +rust-random__getrandom-291 +rust-random__getrandom-385 +rustcrypto__formats-1126 +rustcrypto__formats-1503 +rustcrypto__formats-1505 +rustcrypto__formats-1522 +rustcrypto__formats-1739 +rustcrypto__formats-1744 +rustcrypto__formats-349 +rustcrypto__utils-577 +rustls__rustls-1924 +rustls__rustls-2022 +rustls__rustls-2265 +rustls__rustls-2285 +rustls__rustls-2338 +rustls__rustls-2361 +rustls__rustls-2488 +rustls__rustls-ffi-161 +rustls__rustls-ffi-227 +rustwasm__wasm-bindgen-3763 +rustwasm__wasm-bindgen-4150 +rustwasm__wasm-bindgen-4327 +rustwasm__wasm-pack-1061 +rwjblue__ember-template-lint-113 +rwjblue__ember-template-lint-149 +rwjblue__ember-template-lint-241 +rwjblue__ember-template-lint-281 +rwjblue__ember-template-lint-286 +rwjblue__ember-template-lint-358 +rwjblue__ember-template-lint-368 +ryanfitz__vogels-103 +ryanfitz__vogels-110 +ryanfitz__vogels-94 +ryanfitz__vogels-95 +ryanfitz__vogels-98 +ryangjchandler__orbit-22 +ryangjchandler__orbit-39 +ryangjchandler__orbit-44 +ryangjchandler__orbit-68 +ryangjchandler__orbit-85 +s-knibbs__dataclasses-jsonschema-10 +s-knibbs__dataclasses-jsonschema-101 +s-knibbs__dataclasses-jsonschema-104 +s-knibbs__dataclasses-jsonschema-105 +s-knibbs__dataclasses-jsonschema-11 +s-knibbs__dataclasses-jsonschema-110 +s-knibbs__dataclasses-jsonschema-112 +s-knibbs__dataclasses-jsonschema-116 +s-knibbs__dataclasses-jsonschema-135 +s-knibbs__dataclasses-jsonschema-157 +s-knibbs__dataclasses-jsonschema-168 +s-knibbs__dataclasses-jsonschema-171 +s-knibbs__dataclasses-jsonschema-183 +s-knibbs__dataclasses-jsonschema-191 +s-knibbs__dataclasses-jsonschema-22 +s-knibbs__dataclasses-jsonschema-32 +s-knibbs__dataclasses-jsonschema-48 +s-knibbs__dataclasses-jsonschema-53 +s-knibbs__dataclasses-jsonschema-64 +s-knibbs__dataclasses-jsonschema-75 +s-knibbs__dataclasses-jsonschema-77 +s-knibbs__dataclasses-jsonschema-78 +s-knibbs__dataclasses-jsonschema-82 +s-knibbs__dataclasses-jsonschema-85 +s-knibbs__dataclasses-jsonschema-86 +s-knibbs__dataclasses-jsonschema-88 +s-knibbs__dataclasses-jsonschema-92 +s-knibbs__dataclasses-jsonschema-93 +s-knibbs__dataclasses-jsonschema-96 +sabbelasichon__typo3-rector-3914 +sabbelasichon__typo3-rector-3927 +sabbelasichon__typo3-rector-3934 +sabbelasichon__typo3-rector-4495 +sabnzbd__sabnzbd-1794 +sabnzbd__sabnzbd-2584 +sabre-io__dav-1362 +sacloud__terraform-provider-sakuracloud-737 +sacloud__terraform-provider-sakuracloud-855 +sacloud__usacloud-1114 +sacloud__usacloud-598 +sacloud__usacloud-623 +sacloud__usacloud-635 +safedep__vet-539 +sage__carbon-5432 +sage__carbon-5474 +sage__carbon-5512 +sage__carbon-5729 +sage__carbon-5750 +sage__carbon-5808 +sage__carbon-5835 +sage__carbon-5836 +sage__carbon-5849 +sage__carbon-5893 +sage__carbon-5901 +sage__carbon-5934 +sage__carbon-5952 +sage__carbon-5971 +sage__carbon-6701 +sage__carbon-7074 +sagebind__isahc-240 +sagebind__isahc-251 +sagebind__isahc-255 +sagebind__isahc-284 +sagebind__isahc-337 +salesforce__lwc-4553 +salesforce__lwc-4592 +salesforce__policy_sentry-143 +salesforce__policy_sentry-157 +salesforce__policy_sentry-184 +salesforce__policy_sentry-212 +salesforce__policy_sentry-227 +salesforce__policy_sentry-315 +salesforce__policy_sentry-484 +salesforce__policy_sentry-526 +salesforce__tough-cookie-345 +salesforce__tough-cookie-429 +salesforce__tough-cookie-457 +salesforce__tough-cookie-500 +salsa-rs__salsa-105 +salsa-rs__salsa-352 +salsa-rs__salsa-362 +salsa-rs__salsa-378 +salsa-rs__salsa-392 +salsa-rs__salsa-57 +salsa-rs__salsa-589 +salsa-rs__salsa-591 +salsa-rs__salsa-593 +salsa-rs__salsa-82 +salsa-rs__salsa-859 +salsa-rs__salsa-879 +salsita__node-pg-migrate-537 +salsita__node-pg-migrate-581 +salsita__node-pg-migrate-622 +salsita__node-pg-migrate-671 +salsita__node-pg-migrate-678 +salsita__node-pg-migrate-695 +salsita__node-pg-migrate-698 +samchungy__zod-openapi-330 +samchungy__zod-openapi-393 +samchungy__zod-openapi-398 +samtools__htslib-1330 +samtools__htslib-1354 +samtools__htslib-1441 +samtools__htslib-1599 +samtools__htslib-1645 +samtools__htslib-1702 +samtools__htslib-1755 +samtools__htslib-1800 +samtools__htslib-1868 +samuelcolvin__pydantic-1663 +samuelcolvin__pydantic-1737 +samuelcolvin__pydantic-1752 +samuelcolvin__pydantic-1814 +samuelcolvin__pydantic-1911 +samuelcolvin__pydantic-1935 +samuelcolvin__pydantic-2053 +samuelcolvin__pydantic-2055 +samuelcolvin__pydantic-2056 +samuelcolvin__pydantic-2057 +samuelcolvin__pydantic-2064 +samuelcolvin__pydantic-2066 +samuelcolvin__pydantic-2075 +samuelcolvin__pydantic-2091 +samuelcolvin__pydantic-2114 +samuelcolvin__pydantic-2119 +samuelcolvin__pydantic-2128 +samuelcolvin__pydantic-2133 +samuelcolvin__pydantic-2139 +samuelcolvin__pydantic-2143 +samuelcolvin__pydantic-2183 +samuelcolvin__pydantic-2196 +samuelcolvin__pydantic-2221 +samuelcolvin__pydantic-2265 +samuelcolvin__pydantic-2366 +samuelcolvin__pydantic-2434 +samuelcolvin__pydantic-2519 +samuelcolvin__pydantic-2549 +samuelcolvin__pydantic-2567 +samuelcolvin__pydantic-2720 +samuelcolvin__pydantic-2767 +samuelcolvin__pydantic-2806 +samuelcolvin__pydantic-2989 +samuelcolvin__pydantic-3138 +samuelcolvin__pydantic-3176 +samuelcolvin__pydantic-3177 +samuelcolvin__pydantic-3304 +samuelcolvin__pydantic-3403 +samuelcolvin__pydantic-3452 +samuelcolvin__pydantic-3543 +samuelcolvin__pydantic-3551 +samuelcolvin__pydantic-3595 +samuelcolvin__pydantic-3707 +samuelcolvin__pydantic-4064 +samuelcolvin__pydantic-4329 +samuong__alpaca-108 +sanctuary-js__sanctuary-191 +sanctuary-js__sanctuary-205 +sanctuary-js__sanctuary-206 +sanctuary-js__sanctuary-215 +sanctuary-js__sanctuary-220 +sanctuary-js__sanctuary-249 +sanctuary-js__sanctuary-289 +sanctuary-js__sanctuary-310 +sanctuary-js__sanctuary-316 +sanctuary-js__sanctuary-344 +sanctuary-js__sanctuary-348 +sanctuary-js__sanctuary-356 +sanctuary-js__sanctuary-357 +sanctuary-js__sanctuary-375 +sanctuary-js__sanctuary-379 +sanctuary-js__sanctuary-382 +sanctuary-js__sanctuary-397 +sanctuary-js__sanctuary-432 +sanctuary-js__sanctuary-472 +sanctuary-js__sanctuary-491 +sanctuary-js__sanctuary-511 +sanctuary-js__sanctuary-513 +sanctuary-js__sanctuary-592 +sanctuary-js__sanctuary-593 +sanctuary-js__sanctuary-610 +sanctuary-js__sanctuary-612 +sanctuary-js__sanctuary-662 +sandersn__downlevel-dts-10 +sandersn__downlevel-dts-13 +sandersn__downlevel-dts-17 +sandersn__downlevel-dts-42 +sandersn__downlevel-dts-82 +sanic-org__sanic-2302 +sanic-org__sanic-2827 +sanic-org__sanic-2837 +sanic-org__sanic-2858 +sanic-org__sanic-ext-100 +sanic-org__sanic-ext-102 +sanic-org__sanic-ext-119 +sanic-org__sanic-ext-130 +sanic-org__sanic-ext-154 +sanic-org__sanic-ext-161 +sanic-org__sanic-ext-163 +sanic-org__sanic-ext-164 +sanic-org__sanic-ext-168 +sanic-org__sanic-ext-169 +sanic-org__sanic-ext-171 +sanic-org__sanic-ext-174 +sanic-org__sanic-ext-189 +sanic-org__sanic-ext-191 +sanic-org__sanic-ext-97 +sanic-org__sanic-ext-98 +sap__cloud-security-xsuaa-integration-626 +sap__cloud-security-xsuaa-integration-645 +sap__luigi-3650 +sap__luigi-3742 +sap__luigi-3744 +sap__luigi-3775 +sap__luigi-3785 +sap__luigi-3797 +sap__luigi-3831 +sap__luigi-3946 +sap__luigi-4028 +sap__luigi-4210 +sap__luigi-4231 +sap__luigi-4232 +sap__luigi-4266 +sappelhoff__pyprep-156 +sappelhoff__pyprep-34 +sappelhoff__pyprep-62 +sappelhoff__pyprep-71 +sappelhoff__pyprep-92 +sarbbottam__eslint-find-rules-343 +sarugaku__requirementslib-310 +sarugaku__requirementslib-331 +sashabaranov__go-openai-153 +sashabaranov__go-openai-184 +sashabaranov__go-openai-259 +sashabaranov__go-openai-325 +sashabaranov__go-openai-329 +sashabaranov__go-openai-345 +sashabaranov__go-openai-384 +sashabaranov__go-openai-584 +sashabaranov__go-openai-609 +sashabaranov__go-openai-896 +sasstools__sass-lint-102 +sasstools__sass-lint-1060 +sasstools__sass-lint-205 +sasstools__sass-lint-401 +sasstools__sass-lint-45 +sasstools__sass-lint-637 +sasstools__sass-lint-681 +sasstools__sass-lint-691 +sasstools__sass-lint-709 +sasstools__sass-lint-81 +saucelabs__node-saucelabs-101 +saucelabs__node-saucelabs-120 +saucelabs__node-saucelabs-243 +saucelabs__node-saucelabs-247 +saucelabs__node-saucelabs-248 +saucelabs__node-saucelabs-57 +saucelabs__node-saucelabs-92 +scalameta__scalameta-2700 +scalameta__scalameta-2713 +scalameta__scalameta-2726 +scalameta__scalameta-2728 +scalameta__scalameta-2736 +scalameta__scalameta-2740 +scalameta__scalameta-2854 +scalameta__scalameta-2901 +scalameta__scalameta-2965 +scalameta__scalameta-3009 +scalameta__scalameta-3200 +scalameta__scalameta-3232 +scalameta__scalameta-3262 +scalameta__scalameta-3391 +scalameta__scalameta-3536 +scalameta__scalameta-3575 +scalameta__scalameta-3582 +scalameta__scalameta-3584 +scalameta__scalameta-3606 +scalameta__scalameta-3614 +scalameta__scalameta-3675 +scalameta__scalameta-3707 +scalameta__scalameta-3714 +scalameta__scalameta-3716 +scalameta__scalameta-3743 +scalameta__scalameta-3755 +scalameta__scalameta-3814 +scalameta__scalameta-3871 +scalameta__scalameta-3953 +scalameta__scalameta-3978 +scalameta__scalameta-3986 +scalameta__scalameta-4014 +scalameta__scalameta-4016 +scalameta__scalameta-4031 +scalameta__scalameta-4112 +scalameta__scalameta-4115 +scalameta__scalameta-4144 +scalameta__scalameta-4148 +scalameta__scalameta-4150 +scalameta__scalameta-4192 +scalameta__scalameta-4271 +scalameta__scalameta-4306 +scalameta__scalameta-4345 +scaleway__scaleway-cli-1146 +scaleway__scaleway-cli-3201 +schemahero__schemahero-275 +schemahero__schemahero-865 +schemahero__schemahero-875 +schemahero__schemahero-910 +scikit-activeml__scikit-activeml-504 +scikit-build__scikit-build-core-1052 +scikit-build__scikit-build-core-254 +scikit-build__scikit-build-core-329 +scikit-build__scikit-build-core-391 +scikit-build__scikit-build-core-514 +scikit-build__scikit-build-core-602 +scikit-build__scikit-build-core-612 +scikit-build__scikit-build-core-640 +scikit-build__scikit-build-core-703 +scikit-build__scikit-build-core-711 +scikit-build__scikit-build-core-712 +scikit-build__scikit-build-core-733 +scikit-build__scikit-build-core-764 +scikit-build__scikit-build-core-793 +scikit-build__scikit-build-core-804 +scikit-build__scikit-build-core-812 +scikit-build__scikit-build-core-828 +scikit-build__scikit-build-core-921 +scikit-hep__hist-521 +scikit-optimize__scikit-optimize-1063 +scikit-rf__scikit-rf-1282 +scille__umongo-170 +scille__umongo-190 +scille__umongo-191 +scille__umongo-231 +scille__umongo-245 +scille__umongo-330 +sciml__recursivearraytools.jl-325 +sciml__recursivearraytools.jl-355 +sciml__recursivearraytools.jl-386 +sciml__recursivearraytools.jl-393 +sciml__recursivearraytools.jl-402 +sciml__recursivearraytools.jl-406 +sciml__recursivearraytools.jl-412 +sciml__recursivearraytools.jl-420 +sciml__recursivearraytools.jl-431 +sciml__recursivearraytools.jl-490 +sciml__recursivearraytools.jl-493 +sciml__recursivearraytools.jl-494 +scimmyjs__scimmy-35 +scimmyjs__scimmy-36 +scimmyjs__scimmy-38 +scimmyjs__scimmy-40 +scimmyjs__scimmy-48 +scimmyjs__scimmy-49 +scimmyjs__scimmy-54 +scimmyjs__scimmy-56 +scimmyjs__scimmy-62 +scimmyjs__scimmy-65 +scimmyjs__scimmy-71 +scionproto__scion-4578 +scionproto__scion-4605 +scitools__cartopy-2225 +scitools__cartopy-2307 +scitools__cartopy-2378 +scitools__cartopy-2407 +scitools__iris-6416 +scitools__iris-6529 +scitools__iris-6557 +sciunto-org__python-bibtexparser-101 +sciunto-org__python-bibtexparser-158 +sciunto-org__python-bibtexparser-473 +scolladon__sfdx-git-delta-631 +scolladon__sfdx-git-delta-680 +scolladon__sfdx-git-delta-706 +scolladon__sfdx-git-delta-707 +scolladon__sfdx-git-delta-745 +scolladon__sfdx-git-delta-815 +scolladon__sfdx-git-delta-831 +scolladon__sfdx-git-delta-835 +scolladon__sfdx-git-delta-844 +scolladon__sfdx-git-delta-896 +score-spec__score-compose-136 +score-spec__score-compose-169 +score-spec__score-compose-241 +score-spec__score-compose-252 +score-spec__score-compose-267 +score-spec__score-compose-273 +score-spec__score-compose-51 +score-spec__score-compose-99 +scoutapp__scout_apm_python-438 +scoutapp__scout_apm_python-460 +scoutapp__scout_apm_python-462 +scoutapp__scout_apm_python-474 +scoutapp__scout_apm_python-491 +scoutapp__scout_apm_python-494 +scoutapp__scout_apm_python-499 +scoutapp__scout_apm_python-500 +scoutapp__scout_apm_python-523 +scoutapp__scout_apm_python-526 +scoutapp__scout_apm_python-575 +scoutapp__scout_apm_python-597 +scoutapp__scout_apm_python-639 +scoutapp__scout_apm_python-656 +scoutapp__scout_apm_python-657 +scoutapp__scout_apm_python-663 +scoutapp__scout_apm_python-668 +scoutapp__scout_apm_python-674 +scoutapp__scout_apm_python-676 +scoutapp__scout_apm_python-685 +scoutapp__scout_apm_python-692 +scoutapp__scout_apm_python-709 +scoutapp__scout_apm_python-711 +scrapy__scrapy-1267 +scrapy__scrapy-1728 +scrapy__scrapy-1767 +scrapy__scrapy-2395 +scrapy__scrapy-3840 +scrapy__scrapy-5068 +scrapy__scrapy-6050 +scrapy__scrapy-6239 +scrapy__scrapy-6374 +scrapy__scrapy-6469 +scrapy__scrapy-6606 +scrapy__scrapy-6608 +scrapy__scrapy-6628 +scrapy__scrapy-6801 +scrapy__scrapy-6863 +scrapy__scrapy-6867 +scrapy__scrapy-6897 +scylladb__scylla-operator-2708 +scylladb__scylla-operator-305 +scylladb__scylla-operator-306 +scylladb__scylla-rust-driver-174 +sdispater__pendulum-775 +sdispater__pendulum-776 +sdispater__pendulum-99 +sdispater__tomlkit-103 +sdispater__tomlkit-177 +sdispater__tomlkit-187 +sdispater__tomlkit-68 +sdispater__tomlkit-71 +sdispater__tomlkit-76 +sdispater__tomlkit-82 +sdv-dev__copulas-365 +sdv-dev__copulas-371 +sdv-dev__copulas-379 +sdv-dev__copulas-403 +sdv-dev__copulas-436 +sdv-dev__copulas-473 +sdv-dev__rdt-1020 +sdv-dev__rdt-609 +sdv-dev__rdt-610 +sdv-dev__rdt-622 +sdv-dev__rdt-634 +sdv-dev__rdt-640 +sdv-dev__rdt-645 +sdv-dev__rdt-654 +sdv-dev__rdt-659 +sdv-dev__rdt-661 +sdv-dev__rdt-669 +sdv-dev__rdt-670 +sdv-dev__rdt-704 +sdv-dev__rdt-706 +sdv-dev__rdt-708 +sdv-dev__rdt-712 +sdv-dev__rdt-715 +sdv-dev__rdt-717 +sdv-dev__rdt-718 +sdv-dev__rdt-721 +sdv-dev__rdt-722 +sdv-dev__rdt-725 +sdv-dev__rdt-741 +sdv-dev__rdt-746 +sdv-dev__rdt-753 +sdv-dev__rdt-754 +sdv-dev__rdt-755 +sdv-dev__rdt-758 +sdv-dev__rdt-759 +sdv-dev__rdt-760 +sdv-dev__rdt-762 +sdv-dev__rdt-775 +sdv-dev__rdt-776 +sdv-dev__rdt-805 +sdv-dev__rdt-806 +sdv-dev__rdt-832 +sdv-dev__rdt-838 +sdv-dev__rdt-846 +sdv-dev__rdt-856 +sdv-dev__rdt-857 +sdv-dev__rdt-862 +sdv-dev__rdt-867 +sdv-dev__rdt-872 +sdv-dev__rdt-875 +sdv-dev__rdt-887 +sdv-dev__rdt-905 +sdv-dev__rdt-917 +sdv-dev__rdt-933 +sdv-dev__rdt-942 +sdv-dev__rdt-960 +sdv-dev__rdt-963 +sdv-dev__rdt-970 +sdv-dev__rdt-977 +sdv-dev__rdt-985 +sdv-dev__rdt-986 +sdv-dev__rdt-989 +sdv-dev__rdt-992 +seachicken__gh-poi-128 +seachicken__gh-poi-16 +seachicken__gh-poi-24 +seachicken__gh-poi-26 +seachicken__gh-poi-31 +seachicken__gh-poi-35 +seachicken__gh-poi-41 +seachicken__gh-poi-46 +seachicken__gh-poi-48 +seachicken__gh-poi-58 +seachicken__gh-poi-68 +seachicken__gh-poi-78 +seachicken__gh-poi-93 +seanmonstar__reqwest-2741 +seanmonstar__warp-697 +seaofvoices__darklua-114 +seaofvoices__darklua-117 +seaofvoices__darklua-123 +seaofvoices__darklua-130 +seaofvoices__darklua-142 +seaofvoices__darklua-156 +seaofvoices__darklua-162 +seaofvoices__darklua-164 +seaofvoices__darklua-176 +seaofvoices__darklua-193 +seaofvoices__darklua-222 +seaofvoices__darklua-229 +seaofvoices__darklua-230 +seaofvoices__darklua-233 +seaofvoices__darklua-251 +seaofvoices__darklua-254 +seaofvoices__darklua-274 +seaofvoices__darklua-275 +seaofvoices__darklua-276 +seaofvoices__darklua-280 +seaofvoices__darklua-83 +seaofvoices__darklua-84 +seaofvoices__darklua-88 +seaql__sea-orm-104 +seaql__sea-orm-117 +seaql__sea-orm-140 +seaql__sea-orm-1403 +seaql__sea-orm-166 +seaql__sea-orm-182 +seaql__sea-orm-1953 +seaql__sea-orm-207 +seaql__sea-orm-208 +seaql__sea-orm-209 +seaql__sea-orm-2545 +seaql__sea-orm-287 +seaql__sea-orm-303 +seaql__sea-orm-376 +searchbox-io__jest-316 +searchbox-io__jest-350 +searchbox-io__jest-376 +searchbox-io__jest-386 +searchbox-io__jest-414 +searchbox-io__jest-437 +searchbox-io__jest-520 +searchbox-io__jest-652 +searchbox-io__jest-679 +sebastianbergmann__phpunit-4951 +sebastianbergmann__phpunit-5346 +sebrut__pygrocy-113 +sebrut__pygrocy-120 +sebrut__pygrocy-153 +sebrut__pygrocy-181 +sebrut__pygrocy-193 +sebrut__pygrocy-208 +sebrut__pygrocy-255 +sebrut__pygrocy-64 +sebrut__pygrocy-72 +sebrut__pygrocy-78 +sebrut__pygrocy-96 +sebrut__pygrocy-98 +sec-edgar__sec-edgar-249 +securecodebox__securecodebox-514 +segmentio__analytics-swift-201 +segmentio__analytics-swift-302 +segmentio__analytics-swift-52 +segmentio__encoding-108 +segmentio__encoding-119 +segmentio__encoding-12 +segmentio__encoding-14 +segmentio__encoding-17 +segmentio__encoding-19 +segmentio__encoding-27 +segmentio__encoding-29 +segmentio__encoding-45 +segmentio__encoding-85 +segmentio__encoding-87 +segmentio__parquet-go-204 +segmentio__parquet-go-265 +segmentio__parquet-go-277 +segmentio__parquet-go-278 +segmentio__parquet-go-285 +segmentio__parquet-go-293 +segmentio__parquet-go-313 +segmentio__parquet-go-321 +segmentio__parquet-go-322 +segmentio__parquet-go-352 +segmentio__parquet-go-353 +segmentio__parquet-go-361 +segmentio__parquet-go-378 +segmentio__parquet-go-414 +segmentio__parquet-go-492 +segmentio__parquet-go-503 +segmentio__terraform-docs-235 +seldaek__monolog-1722 +seldaek__monolog-1759 +seldaek__monolog-1791 +seldaek__monolog-1801 +seldaek__monolog-1882 +seldaek__monolog-1896 +seldaek__monolog-1928 +semantic-release__github-829 +semantic-release__github-857 +semantic-release__github-863 +semantic-release__github-876 +semantic-release__github-878 +semantic-release__github-887 +semantic-release__github-903 +semantic-release__gitlab-184 +semantic-release__gitlab-342 +semantic-release__gitlab-353 +semantic-release__gitlab-365 +semantic-release__gitlab-409 +semantic-release__gitlab-452 +semantic-release__gitlab-491 +semantic-release__gitlab-498 +semantic-release__gitlab-580 +semantic-release__gitlab-755 +semantic-release__gitlab-800 +semantic-release__gitlab-850 +semantic-release__npm-22 +semantic-release__npm-28 +semantic-release__npm-362 +semantic-release__semantic-release-1000 +semantic-release__semantic-release-1562 +semantic-release__semantic-release-1697 +semantic-release__semantic-release-1732 +semantic-release__semantic-release-553 +semantic-release__semantic-release-586 +semantic-release__semantic-release-617 +semantic-release__semantic-release-678 +semantic-release__semantic-release-812 +semantic-release__semantic-release-847 +semantic-release__semantic-release-865 +semantic-release__semantic-release-889 +semantic-release__semantic-release-926 +senth__minecraft-mod-manager-166 +senth__minecraft-mod-manager-171 +senth__minecraft-mod-manager-180 +senth__minecraft-mod-manager-182 +senth__minecraft-mod-manager-183 +senth__minecraft-mod-manager-23 +senth__minecraft-mod-manager-36 +senth__minecraft-mod-manager-71 +senth__minecraft-mod-manager-80 +senth__minecraft-mod-manager-82 +senth__minecraft-mod-manager-86 +seqsense__aws-iot-device-sdk-go-125 +seqsense__aws-iot-device-sdk-go-207 +seqsense__aws-iot-device-sdk-go-236 +serverless-heaven__serverless-webpack-1002 +serverless-heaven__serverless-webpack-248 +serverless-heaven__serverless-webpack-270 +serverless-heaven__serverless-webpack-271 +serverless-heaven__serverless-webpack-282 +serverless-heaven__serverless-webpack-334 +serverless-heaven__serverless-webpack-340 +serverless-heaven__serverless-webpack-381 +serverless-heaven__serverless-webpack-395 +serverless-heaven__serverless-webpack-413 +serverless-heaven__serverless-webpack-469 +serverless-heaven__serverless-webpack-471 +serverless-heaven__serverless-webpack-579 +serverless-heaven__serverless-webpack-663 +serverless-heaven__serverless-webpack-746 +serverless-heaven__serverless-webpack-748 +serverless-heaven__serverless-webpack-813 +serverless-operations__serverless-step-functions-552 +serverless-operations__serverless-step-functions-580 +serverless-operations__serverless-step-functions-605 +serverless-operations__serverless-step-functions-648 +serverless-operations__serverless-step-functions-657 +serverless__serverless-2701 +serverless__serverless-2736 +serverless__serverless-2743 +serverless__serverless-2774 +serverless__serverless-2796 +serverless__serverless-2799 +serverless__serverless-2809 +serverless__serverless-2816 +serverless__serverless-2845 +serverless__serverless-2847 +serverless__serverless-2891 +serverless__serverless-2893 +serverless__serverless-2910 +serverless__serverless-2922 +serverless__serverless-2937 +serverless__serverless-2940 +serverless__serverless-2945 +serverless__serverless-2952 +serverless__serverless-3064 +serverless__serverless-3067 +serverless__serverless-3095 +serverless__serverless-3107 +serverless__serverless-3111 +serverless__serverless-3180 +serverless__serverless-3186 +serverless__serverless-3213 +serverless__serverless-3217 +serverless__serverless-3334 +serverless__serverless-3429 +serverless__serverless-3443 +serverless__serverless-3457 +serverless__serverless-3505 +serverless__serverless-3507 +serverless__serverless-3521 +serverless__serverless-3548 +serverless__serverless-3609 +serverless__serverless-3642 +serverless__serverless-3647 +serverless__serverless-3657 +serverless__serverless-3660 +serverless__serverless-3672 +serverless__serverless-3680 +serverless__serverless-3692 +serverless__serverless-3700 +serverless__serverless-3701 +serverless__serverless-3705 +serverless__serverless-3729 +serverless__serverless-3746 +serverless__serverless-3808 +serverless__serverless-3842 +serverless__serverless-3848 +serverless__serverless-4192 +serverless__serverless-4198 +serverless__serverless-4238 +serverless__serverless-4249 +serverless__serverless-4268 +serverless__serverless-4279 +serverless__serverless-4293 +serverless__serverless-4372 +serverless__serverless-4448 +serverless__serverless-4460 +serverless__serverless-4531 +serverless__serverless-4552 +serverless__serverless-4559 +serverless__serverless-4576 +serverless__serverless-4586 +serverless__serverless-4590 +serverless__serverless-4596 +serverless__serverless-4601 +serverless__serverless-4606 +serverless__serverless-4636 +serverless__serverless-4640 +serverless__serverless-4650 +serverless__serverless-4694 +serverless__serverless-4701 +serverless__serverless-4768 +serverless__serverless-4793 +serverless__serverless-4854 +serverless__serverless-4879 +serverless__serverless-4890 +serverless__serverless-4925 +serverless__serverless-4947 +serverless__serverless-5029 +serverless__serverless-5080 +serverless__serverless-5082 +serverless__serverless-5156 +serverless__serverless-5161 +serverless__serverless-5166 +serverless__serverless-5229 +serverless__serverless-5256 +serverless__serverless-5299 +serverless__serverless-5312 +serverless__serverless-5314 +serverless__serverless-5328 +serverless__serverless-5351 +serverless__serverless-5443 +serverless__serverless-5492 +serverless__serverless-5509 +serverless__serverless-5531 +serverless__serverless-5602 +serverless__serverless-5604 +serverless__serverless-5635 +serverless__serverless-5638 +serverless__serverless-5639 +serverless__serverless-5650 +serverless__serverless-5656 +serverless__serverless-5662 +serverless__serverless-5692 +serverless__serverless-5694 +serverless__serverless-5728 +serverless__serverless-5744 +serverless__serverless-5775 +serverless__serverless-5799 +serverless__serverless-5808 +serverless__serverless-5809 +serverless__serverless-5840 +serverless__serverless-5842 +serverless__serverless-5851 +serverless__serverless-5860 +serverless__serverless-5865 +serverless__serverless-5880 +serverless__serverless-5885 +serverless__serverless-5926 +serverless__serverless-5956 +serverless__serverless-5988 +serverless__serverless-5994 +serverless__serverless-6000 +serverless__serverless-6038 +serverless__serverless-6057 +serverless__serverless-6073 +serverless__serverless-6121 +serverless__serverless-6128 +serverless__serverless-6192 +serverless__serverless-6196 +serverless__serverless-6244 +serverless__serverless-6255 +serverless__serverless-6261 +serverless__serverless-6272 +serverless__serverless-6310 +serverless__serverless-6322 +serverless__serverless-6332 +serverless__serverless-6345 +serverless__serverless-6365 +serverless__serverless-6366 +serverless__serverless-6372 +serverless__serverless-6383 +serverless__serverless-6402 +serverless__serverless-6417 +serverless__serverless-6427 +serverless__serverless-6445 +serverless__serverless-6446 +serverless__serverless-6447 +serverless__serverless-6456 +serverless__serverless-6477 +serverless__serverless-6491 +serverless__serverless-6518 +serverless__serverless-6520 +serverless__serverless-6534 +serverless__serverless-6543 +serverless__serverless-6545 +serverless__serverless-6556 +serverless__serverless-6606 +serverless__serverless-6658 +serverless__serverless-6689 +serverless__serverless-6711 +serverless__serverless-6719 +serverless__serverless-6823 +serverless__serverless-6827 +serverless__serverless-6835 +serverless__serverless-6922 +serverless__serverless-6954 +serverless__serverless-6996 +serverless__serverless-7031 +serverless__serverless-7040 +serverless__serverless-7044 +serverless__serverless-7054 +serverless__serverless-7120 +serverless__serverless-7126 +serverless__serverless-7239 +serverless__serverless-7252 +serverless__serverless-7283 +serverless__serverless-7285 +serverless__serverless-7333 +serverless__serverless-7398 +serverless__serverless-7540 +serverless__serverless-7617 +serverless__serverless-azure-functions-263 +serverless__serverless-azure-functions-275 +serverless__serverless-azure-functions-284 +serverless__serverless-azure-functions-305 +serverless__serverless-azure-functions-318 +serverless__serverless-azure-functions-321 +serverless__serverless-azure-functions-322 +serverless__serverless-azure-functions-401 +serverless__serverless-azure-functions-402 +serverless__serverless-azure-functions-411 +serverless__serverless-azure-functions-443 +serverless__serverless-azure-functions-468 +serverless__serverless-azure-functions-475 +serverless__serverless-azure-functions-640 +servo__rust-url-728 +servo__rust-url-734 +servo__rust-url-839 +servo__rust-url-902 +servo__rust-url-975 +seung-lab__cloud-volume-375 +sfackler__rust-postgres-678 +sfackler__rust-postgres-780 +sfackler__rust-postgres-841 +sfdo-tooling__cumulusci-3334 +sfdo-tooling__cumulusci-3363 +sfdo-tooling__cumulusci-3365 +sfdo-tooling__cumulusci-3624 +sfdo-tooling__cumulusci-3645 +shapely__shapely-1685 +shapely__shapely-1760 +shapesecurity__salvation-102 +shapesecurity__salvation-106 +shapesecurity__salvation-114 +shapesecurity__salvation-118 +shapesecurity__salvation-122 +shapesecurity__salvation-131 +shapesecurity__salvation-134 +shapesecurity__salvation-141 +shapesecurity__salvation-153 +shapesecurity__salvation-171 +shapesecurity__salvation-182 +shapesecurity__salvation-186 +shapesecurity__salvation-192 +shapesecurity__salvation-203 +shapesecurity__salvation-204 +shapesecurity__salvation-211 +shapesecurity__salvation-214 +shapesecurity__salvation-235 +shapesecurity__salvation-82 +shapesecurity__salvation-92 +sharkdp__bat-1197 +sharkdp__bat-1276 +sharkdp__bat-3206 +sharkdp__bat-579 +sharkdp__fd-1079 +sharkdp__fd-1115 +sharkdp__fd-1121 +sharkdp__fd-1137 +sharkdp__fd-1162 +sharkdp__fd-1690 +sharkdp__fd-480 +sharkdp__fd-497 +sharkdp__fd-558 +sharkdp__fd-569 +sharkdp__fd-590 +sharkdp__fd-658 +sharkdp__fd-682 +sharkdp__fd-811 +sharkdp__fd-813 +sharkdp__fd-822 +sharkdp__fd-826 +sharkdp__fd-986 +sharkdp__numbat-168 +sharkdp__numbat-171 +sharkdp__numbat-197 +sharkdp__numbat-209 +sharkdp__numbat-222 +sharkdp__numbat-232 +sharkdp__numbat-244 +sharkdp__numbat-272 +sharkdp__numbat-312 +sharkdp__numbat-378 +sharkdp__numbat-379 +sharkdp__numbat-455 +sharkdp__numbat-461 +sharkdp__numbat-493 +sharkdp__numbat-495 +sharkdp__numbat-527 +sharkdp__numbat-636 +sharkdp__numbat-647 +shazow__whatsabi-107 +shazow__whatsabi-112 +shazow__whatsabi-134 +shazow__whatsabi-140 +shazow__whatsabi-147 +shazow__whatsabi-172 +shazow__whatsabi-174 +shellscape__postcss-less-101 +shellscape__postcss-less-66 +shellscape__postcss-less-68 +shellscape__postcss-less-72 +shellscape__postcss-less-97 +shellscape__postcss-less-98 +shepherdwind__velocity.js-114 +shepherdwind__velocity.js-55 +shepherdwind__velocity.js-64 +shepherdwind__velocity.js-67 +shepherdwind__velocity.js-73 +shepherdwind__velocity.js-90 +shepherdwind__velocity.js-92 +shepmaster__snafu-107 +shepmaster__snafu-117 +shepmaster__snafu-12 +shepmaster__snafu-129 +shepmaster__snafu-137 +shepmaster__snafu-141 +shepmaster__snafu-143 +shepmaster__snafu-147 +shepmaster__snafu-183 +shepmaster__snafu-193 +shepmaster__snafu-222 +shepmaster__snafu-237 +shepmaster__snafu-251 +shepmaster__snafu-271 +shepmaster__snafu-278 +shepmaster__snafu-31 +shepmaster__snafu-35 +shepmaster__snafu-361 +shepmaster__snafu-366 +shepmaster__snafu-397 +shepmaster__snafu-409 +shepmaster__snafu-438 +shepmaster__snafu-442 +shepmaster__snafu-47 +shepmaster__snafu-52 +shepmaster__snafu-56 +shiika-lang__shiika-527 +shini4i__argo-watcher-188 +shini4i__argo-watcher-249 +shini4i__argo-watcher-254 +shini4i__argo-watcher-309 +shipwright-io__build-1770 +shirou__gopsutil-1861 +shlinkio__shlink-1366 +shlinkio__shlink-1449 +shlinkio__shlink-1496 +shlinkio__shlink-1523 +shlinkio__shlink-web-client-339 +shlinkio__shlink-web-client-341 +shlinkio__shlink-web-client-346 +shlinkio__shlink-web-client-369 +shlinkio__shlink-web-client-381 +shlinkio__shlink-web-client-389 +shlinkio__shlink-web-client-392 +shlinkio__shlink-web-client-393 +shlinkio__shlink-web-client-399 +shlinkio__shlink-web-client-400 +shlinkio__shlink-web-client-402 +shlinkio__shlink-web-client-405 +shlinkio__shlink-web-client-444 +shlinkio__shlink-web-client-468 +shlinkio__shlink-web-client-470 +shlinkio__shlink-web-client-483 +shlinkio__shlink-web-client-488 +shlinkio__shlink-web-client-494 +shlinkio__shlink-web-client-501 +shopify__kubeaudit-374 +shopify__kubeaudit-376 +shopify__sarama-2427 +shopify__sarama-2453 +shopify__themekit-584 +shopify__themekit-593 +shopify__themekit-819 +shopify__themekit-828 +shopify__themekit-875 +shopware__frontends-1094 +shopware__frontends-1215 +shopware__frontends-915 +showdownjs__showdown-671 +showdownjs__showdown-732 +showdownjs__showdown-950 +shssoichiro__oxipng-529 +shssoichiro__oxipng-531 +shufo__blade-formatter-909 +shufo__blade-formatter-916 +sid88in__serverless-appsync-plugin-513 +sid88in__serverless-appsync-plugin-514 +sid88in__serverless-appsync-plugin-553 +sid88in__serverless-appsync-plugin-613 +sigma67__ytmusicapi-561 +sigmavirus24__github3.py-1199 +sigoden__dufs-328 +sigoden__dufs-403 +sigoden__dufs-449 +sigoden__dufs-497 +sigoden__dufs-521 +sigstore__cosign-2108 +sigstore__cosign-3549 +sigstore__fulcio-1777 +sigstore__fulcio-1931 +sigstore__rekor-967 +sigstore__sigstore-go-277 +sigstore__sigstore-go-366 +sigstore__sigstore-go-459 +sigstore__sigstore-go-465 +silx-kit__h5web-830 +silx-kit__silx-4090 +silx-kit__silx-4242 +silx-kit__silx-4282 +simonbaeumer__commander-59 +simonbaeumer__commander-89 +simpeg__simpeg-1334 +simpeg__simpeg-1361 +simpeg__simpeg-1548 +simpeg__simpeg-1550 +simpeg__simpeg-1565 +simpeg__simpeg-1621 +simpeg__simpeg-1633 +simple-icons__simple-icons-7824 +simple-icons__simple-icons-8077 +sinaptik-ai__pandas-ai-1012 +sinaptik-ai__pandas-ai-1019 +sinaptik-ai__pandas-ai-1048 +sinaptik-ai__pandas-ai-1071 +sinaptik-ai__pandas-ai-1084 +sinaptik-ai__pandas-ai-1097 +sinaptik-ai__pandas-ai-1099 +sinaptik-ai__pandas-ai-1161 +sinaptik-ai__pandas-ai-1295 +sindresorhus__awesome-lint-118 +sindresorhus__awesome-lint-129 +sindresorhus__awesome-lint-62 +sindresorhus__awesome-lint-63 +sindresorhus__awesome-lint-87 +sindresorhus__awesome-lint-98 +sindresorhus__boxen-58 +sindresorhus__boxen-59 +sindresorhus__boxen-63 +sindresorhus__boxen-88 +sindresorhus__camelcase-112 +sindresorhus__camelcase-49 +sindresorhus__camelcase-53 +sindresorhus__camelcase-62 +sindresorhus__camelcase-75 +sindresorhus__dot-prop-105 +sindresorhus__dot-prop-54 +sindresorhus__dot-prop-90 +sindresorhus__dot-prop-94 +sindresorhus__emittery-103 +sindresorhus__emittery-121 +sindresorhus__emittery-124 +sindresorhus__emittery-37 +sindresorhus__emittery-43 +sindresorhus__emittery-52 +sindresorhus__emittery-53 +sindresorhus__emittery-56 +sindresorhus__emittery-98 +sindresorhus__execa-180 +sindresorhus__execa-184 +sindresorhus__execa-187 +sindresorhus__execa-189 +sindresorhus__execa-194 +sindresorhus__execa-200 +sindresorhus__execa-271 +sindresorhus__execa-276 +sindresorhus__execa-397 +sindresorhus__execa-427 +sindresorhus__execa-466 +sindresorhus__execa-490 +sindresorhus__execa-528 +sindresorhus__execa-529 +sindresorhus__execa-531 +sindresorhus__execa-565 +sindresorhus__execa-572 +sindresorhus__execa-594 +sindresorhus__execa-602 +sindresorhus__execa-604 +sindresorhus__execa-609 +sindresorhus__execa-613 +sindresorhus__execa-621 +sindresorhus__execa-625 +sindresorhus__execa-658 +sindresorhus__execa-671 +sindresorhus__execa-686 +sindresorhus__got-114 +sindresorhus__got-172 +sindresorhus__got-183 +sindresorhus__got-2059 +sindresorhus__got-2100 +sindresorhus__got-2120 +sindresorhus__got-2162 +sindresorhus__got-277 +sindresorhus__got-286 +sindresorhus__got-295 +sindresorhus__got-297 +sindresorhus__got-301 +sindresorhus__got-302 +sindresorhus__got-307 +sindresorhus__got-320 +sindresorhus__got-335 +sindresorhus__got-360 +sindresorhus__got-386 +sindresorhus__got-413 +sindresorhus__got-429 +sindresorhus__got-441 +sindresorhus__got-451 +sindresorhus__got-452 +sindresorhus__got-455 +sindresorhus__got-456 +sindresorhus__got-464 +sindresorhus__got-496 +sindresorhus__got-498 +sindresorhus__got-518 +sindresorhus__got-521 +sindresorhus__got-564 +sindresorhus__got-577 +sindresorhus__got-579 +sindresorhus__got-589 +sindresorhus__got-596 +sindresorhus__got-608 +sindresorhus__got-613 +sindresorhus__got-633 +sindresorhus__got-640 +sindresorhus__got-643 +sindresorhus__got-651 +sindresorhus__got-652 +sindresorhus__got-659 +sindresorhus__got-660 +sindresorhus__got-935 +sindresorhus__got-995 +sindresorhus__is-100 +sindresorhus__is-104 +sindresorhus__is-86 +sindresorhus__is-90 +sindresorhus__is-97 +sindresorhus__mem-94 +sindresorhus__normalize-url-115 +sindresorhus__normalize-url-117 +sindresorhus__normalize-url-124 +sindresorhus__normalize-url-130 +sindresorhus__normalize-url-158 +sindresorhus__normalize-url-192 +sindresorhus__normalize-url-78 +sindresorhus__query-string-177 +sindresorhus__query-string-183 +sindresorhus__query-string-187 +sindresorhus__query-string-195 +sindresorhus__query-string-202 +sindresorhus__query-string-215 +sindresorhus__query-string-217 +sindresorhus__query-string-222 +sindresorhus__query-string-234 +sindresorhus__query-string-252 +sindresorhus__query-string-265 +sindresorhus__query-string-320 +sindresorhus__query-string-392 +sindresorhus__query-string-99 +sindresorhus__serialize-error-102 +sindresorhus__serialize-error-103 +sindresorhus__serialize-error-27 +sindresorhus__serialize-error-30 +sindresorhus__serialize-error-32 +sindresorhus__serialize-error-39 +sindresorhus__serialize-error-68 +sindresorhus__serialize-error-70 +sindresorhus__serialize-error-71 +singapore__renovate-1005 +singapore__renovate-1006 +singapore__renovate-1018 +singapore__renovate-1048 +singapore__renovate-1051 +singapore__renovate-1153 +singapore__renovate-130 +singapore__renovate-156 +singapore__renovate-163 +singapore__renovate-173 +singapore__renovate-266 +singapore__renovate-349 +singapore__renovate-377 +singapore__renovate-378 +singapore__renovate-432 +singapore__renovate-469 +singapore__renovate-475 +singapore__renovate-479 +singapore__renovate-526 +singapore__renovate-527 +singapore__renovate-561 +singapore__renovate-565 +singapore__renovate-604 +singapore__renovate-607 +singapore__renovate-631 +singapore__renovate-632 +singapore__renovate-635 +singapore__renovate-655 +singapore__renovate-664 +singapore__renovate-665 +singapore__renovate-673 +singapore__renovate-674 +singapore__renovate-711 +singapore__renovate-712 +singapore__renovate-733 +singapore__renovate-744 +singapore__renovate-748 +singapore__renovate-774 +singapore__renovate-786 +singapore__renovate-853 +singapore__renovate-854 +singapore__renovate-886 +singapore__renovate-910 +singapore__renovate-926 +singapore__renovate-944 +single-spa__single-spa-layout-24 +single-spa__single-spa-layout-65 +single-spa__single-spa-layout-70 +single-spa__single-spa-layout-95 +sinonjs__fake-timers-292 +sinonjs__fake-timers-349 +sinonjs__fake-timers-465 +sinonjs__fake-timers-505 +sinonjs__fake-timers-511 +sinonjs__fake-timers-515 +sinonjs__fake-timers-517 +sinonjs__lolex-209 +sinonjs__lolex-210 +sinonjs__lolex-214 +sinonjs__lolex-241 +sinonjs__lolex-244 +sinonjs__lolex-74 +sipsorcery-org__sipsorcery-1084 +sirupsen__logrus-1131 +sissbruecker__linkding-1024 +sissbruecker__linkding-688 +sissbruecker__linkding-691 +sissbruecker__linkding-971 +sissbruecker__linkding-984 +siteimprove__alfa-1777 +sivchari__gotwtr-213 +sivchari__gotwtr-219 +skeletonlabs__floating-ui-svelte-45 +skeletonlabs__floating-ui-svelte-59 +skeletonlabs__floating-ui-svelte-79 +skeletonlabs__floating-ui-svelte-81 +skeletonlabs__floating-ui-svelte-82 +skeletonlabs__floating-ui-svelte-85 +skeletonlabs__floating-ui-svelte-94 +skeletonlabs__floating-ui-svelte-97 +skovhus__jest-codemods-591 +skovhus__jest-codemods-606 +skovhus__jest-codemods-607 +skovhus__jest-codemods-611 +skovhus__jest-codemods-612 +skovhus__jest-codemods-628 +skrub-data__skrub-1445 +sktime__sktime-5490 +sktime__sktime-5570 +sktime__sktime-5615 +sktime__sktime-5656 +sktime__sktime-5977 +sktime__sktime-5980 +sktime__sktime-6143 +sktime__sktime-6282 +sktime__sktime-6473 +sktime__sktime-8178 +sktime__sktime-8192 +sktime__sktime-8247 +sktime__sktime-8358 +skupperproject__skupper-1302 +skupperproject__skupper-1881 +skupperproject__skupper-1883 +skupperproject__skupper-2159 +skx__monkey-100 +skx__monkey-104 +skx__monkey-54 +skx__monkey-56 +skx__monkey-63 +skx__monkey-71 +skx__monkey-80 +skx__monkey-91 +skx__monkey-95 +skygeario__skygear-server-1219 +skygeario__skygear-server-1504 +skypilot-org__skypilot-5577 +skypilot-org__skypilot-5756 +skypilot-org__skypilot-5985 +skypyproject__skypy-521 +skypyproject__skypy-554 +skypyproject__skypy-573 +slack-go__slack-1220 +slack-go__slack-1240 +slack-go__slack-1334 +slack-go__slack-1413 +slack-go__slack-1451 +slack-go__slack-1452 +slack-go__slack-862 +slackapi__bolt-js-878 +slackapi__bolt-js-879 +slackapi__bolt-js-900 +slackapi__python-slack-sdk-1022 +slackapi__python-slack-sdk-1061 +slackapi__python-slack-sdk-1083 +slackapi__python-slack-sdk-1137 +slackapi__python-slack-sdk-1237 +slackapi__python-slack-sdk-1259 +slackapi__python-slack-sdk-1262 +slackapi__python-slack-sdk-1374 +slackapi__python-slack-sdk-1423 +slackapi__python-slack-sdk-1425 +slackapi__python-slack-sdk-1431 +slackapi__python-slack-sdk-1452 +slackapi__python-slack-sdk-1492 +slackapi__python-slack-sdk-1635 +slackapi__python-slack-sdk-1638 +slackapi__python-slack-sdk-1703 +slackapi__python-slack-sdk-904 +slackapi__python-slack-sdk-905 +slackapi__python-slack-sdk-908 +slackapi__python-slack-sdk-909 +slackapi__python-slack-sdk-972 +slackapi__python-slack-sdk-993 +slackapi__python-slackclient-638 +slackapi__python-slackclient-706 +slackapi__python-slackclient-716 +slackapi__python-slackclient-751 +slackapi__python-slackclient-768 +slackapi__python-slackclient-833 +slackapi__slack-github-action-374 +slackapi__slack-github-action-409 +slackapi__slack-github-action-431 +slackapi__slack-github-action-449 +slashdotdash__commanded-102 +slashdotdash__commanded-87 +slevomat__coding-standard-1295 +slevomat__coding-standard-1509 +slimphp__slim-3106 +slimphp__slim-3319 +slimphp__slim-3321 +sloria__environs-391 +smallstep__cli-1045 +smallstep__crypto-346 +smallstep__crypto-744 +smooth-code__svgr-42 +smooth-code__svgr-47 +snowplow__snowplow-javascript-tracker-785 +softlayer__softlayer-python-1822 +softlayer__softlayer-python-2214 +softlayer__softlayer-python-648 +softlayer__softlayer-python-650 +softlayer__softlayer-python-663 +softlayer__softlayer-python-733 +softlayer__softlayer-python-741 +softlayer__softlayer-python-773 +software-mansion__typegpu-1366 +softwaremill__elasticmq-1117 +softwaremill__elasticmq-413 +softwaremill__elasticmq-443 +softwaremill__elasticmq-493 +softwaremill__elasticmq-555 +softwaremill__elasticmq-653 +softwaremill__elasticmq-657 +softwaremill__elasticmq-660 +softwaremill__elasticmq-698 +softwaremill__elasticmq-736 +softwaremill__elasticmq-755 +softwaremill__elasticmq-824 +softwaremill__elasticmq-950 +softwaremill__elasticmq-985 +softwaremill__sttp-openai-163 +softwaremill__sttp-openai-220 +softwaremill__sttp-openai-23 +softwaremill__sttp-openai-26 +softwaremill__sttp-openai-30 +softwaremill__sttp-openai-32 +softwaremill__sttp-openai-33 +softwaremill__sttp-openai-34 +softwaremill__sttp-openai-37 +softwaremill__sttp-openai-38 +softwaremill__sttp-openai-41 +softwaremill__sttp-openai-42 +softwaremill__sttp-openai-49 +softwaremill__sttp-openai-50 +softwaremill__sttp-openai-62 +solid__community-server-148 +solid__community-server-168 +solid__community-server-170 +solid__community-server-173 +solid__community-server-269 +solid__community-server-284 +solid__community-server-316 +solid__community-server-330 +solid__community-server-347 +solid__community-server-37 +solid__community-server-418 +solid__community-server-419 +solid__community-server-477 +solid__community-server-478 +solid__community-server-521 +solid__community-server-551 +solid__community-server-558 +solid__community-server-595 +solid__community-server-596 +solid__community-server-60 +solid__community-server-71 +solidjs-community__solid-primitives-787 +sonarsource__sonar-javascript-600 +sonarsource__sonar-javascript-601 +sonarsource__sonar-javascript-602 +sonarsource__sonar-javascript-784 +sonarsource__sonar-javascript-787 +sonatype-nexus-community__nancy-104 +sonatype-nexus-community__nancy-62 +sonatype-nexus-community__nancy-72 +sonatype-nexus-community__nancy-94 +soofstad__react-oauth2-pkce-165 +soofstad__react-oauth2-pkce-195 +soofstad__react-oauth2-pkce-27 +sopel-irc__sopel-2297 +sopel-irc__sopel-2320 +sopel-irc__sopel-2545 +sopel-irc__sopel-2561 +sopel-irc__sopel-2594 +sopel-irc__sopel-2629 +sopel-irc__sopel-2646 +sopel-irc__sopel-2653 +source-academy__js-slang-125 +source-academy__js-slang-155 +source-academy__js-slang-169 +source-academy__js-slang-170 +source-academy__js-slang-208 +source-academy__js-slang-66 +source-academy__js-slang-68 +source-academy__js-slang-70 +source-academy__js-slang-82 +sourcecred__sourcecred-423 +sourcecred__sourcecred-436 +sourcecred__sourcecred-653 +sourcecred__sourcecred-667 +sourcecred__sourcecred-738 +sourcecred__sourcecred-749 +sourcecred__sourcecred-784 +sourcecred__sourcecred-808 +sourcefrog__cargo-mutants-103 +sourcefrog__cargo-mutants-18 +sourcefrog__cargo-mutants-27 +sourcefrog__cargo-mutants-354 +sourcefrog__cargo-mutants-379 +sourcefrog__cargo-mutants-393 +sourcefrog__cargo-mutants-415 +sourcefrog__cargo-mutants-43 +sourcefrog__cargo-mutants-65 +sourcefrog__cargo-mutants-72 +spacetelescope__asdf-792 +spacetelescope__asdf-806 +spacetelescope__asdf-811 +spacetelescope__gwcs-498 +spacetelescope__gwcs-507 +spacetelescope__gwcs-512 +spacetelescope__gwcs-554 +spacetelescope__gwcs-565 +sparkpost__matchbox-816 +sparkpost__matchbox-817 +sparkpost__matchbox-821 +sparkpost__matchbox-862 +sparkpost__node-sparkpost-121 +sparkpost__node-sparkpost-139 +sparkpost__node-sparkpost-148 +sparkpost__node-sparkpost-165 +sparkpost__node-sparkpost-34 +sparkpost__node-sparkpost-43 +sparkpost__node-sparkpost-56 +sparkpost__node-sparkpost-66 +sparksuite__react-accessible-dropdown-menu-hook-71 +spatie__data-transfer-object-117 +spatie__data-transfer-object-199 +spatie__data-transfer-object-210 +spatie__data-transfer-object-218 +spatie__data-transfer-object-239 +spatie__data-transfer-object-304 +spatie__laravel-backup-1348 +spatie__laravel-backup-1365 +spatie__laravel-backup-1486 +spatie__laravel-permission-1959 +spatie__laravel-permission-2014 +spatie__laravel-permission-2091 +spatie__laravel-permission-2168 +spatie__laravel-permission-2219 +spatie__laravel-permission-2221 +spatie__laravel-permission-2228 +spatie__laravel-permission-2341 +spatie__laravel-permission-2396 +spatie__laravel-permission-2658 +spatie__laravel-permission-2759 +spatie__laravel-permission-2803 +spatie__opening-hours-225 +spatie__opening-hours-232 +spatie__opening-hours-251 +spatie__opening-hours-254 +spatie__opening-hours-256 +spatie__opening-hours-259 +spatie__opening-hours-267 +spatie__opening-hours-269 +spatie__opening-hours-276 +spaze__phpstan-disallowed-calls-102 +spaze__phpstan-disallowed-calls-107 +spaze__phpstan-disallowed-calls-109 +spaze__phpstan-disallowed-calls-128 +spaze__phpstan-disallowed-calls-132 +spaze__phpstan-disallowed-calls-134 +spaze__phpstan-disallowed-calls-141 +spaze__phpstan-disallowed-calls-147 +spaze__phpstan-disallowed-calls-150 +spaze__phpstan-disallowed-calls-163 +spaze__phpstan-disallowed-calls-167 +spaze__phpstan-disallowed-calls-186 +spaze__phpstan-disallowed-calls-225 +spaze__phpstan-disallowed-calls-232 +spaze__phpstan-disallowed-calls-242 +spaze__phpstan-disallowed-calls-248 +spaze__phpstan-disallowed-calls-289 +spaze__phpstan-disallowed-calls-293 +spaze__phpstan-disallowed-calls-304 +spdx__tools-golang-106 +spdx__tools-golang-119 +spdx__tools-golang-210 +spdx__tools-golang-218 +spdx__tools-golang-220 +spdx__tools-golang-246 +spdx__tools-golang-43 +spdx__tools-golang-44 +spdx__tools-golang-58 +spdx__tools-golang-63 +spdx__tools-golang-64 +spdx__tools-golang-68 +spdx__tools-golang-88 +spdx__tools-golang-89 +spdx__tools-golang-95 +spectreconsole__spectre.console-1432 +spectreconsole__spectre.console-1514 +spectreconsole__spectre.console-1627 +spectreconsole__spectre.console-1942 +speee__jsx-slack-101 +speee__jsx-slack-120 +speee__jsx-slack-139 +speee__jsx-slack-165 +speee__jsx-slack-182 +speee__jsx-slack-185 +speee__jsx-slack-197 +speee__jsx-slack-205 +speee__jsx-slack-206 +speee__jsx-slack-207 +speee__jsx-slack-78 +speee__jsx-slack-80 +speee__jsx-slack-91 +speee__jsx-slack-96 +speee__jsx-slack-97 +spegel-org__spegel-601 +spegel-org__spegel-771 +spegel-org__spegel-806 +spegel-org__spegel-832 +spegel-org__spegel-889 +spf13__afero-245 +spf13__afero-260 +spf13__afero-287 +spf13__afero-366 +spf13__cobra-1088 +spf13__cobra-2238 +spf13__cobra-299 +spf13__cobra-402 +spf13__cobra-410 +spf13__cobra-438 +spf13__cobra-538 +spf13__cobra-996 +spf13__viper-1135 +spf13__viper-1160 +spf13__viper-1181 +spf13__viper-1260 +spf13__viper-1387 +spf13__viper-1627 +spf13__viper-1849 +spf13__viper-1857 +spf13__viper-1872 +spf13__viper-2003 +spf13__viper-673 +spf13__viper-809 +spf13__viper-972 +spidernet-io__spiderpool-1671 +spidernet-io__spiderpool-1762 +spidernet-io__spiderpool-1768 +spidernet-io__spiderpool-1806 +spidernet-io__spiderpool-2370 +spidernet-io__spiderpool-2518 +spikeinterface__spikeinterface-1707 +spikeinterface__spikeinterface-1762 +spikeinterface__spikeinterface-1999 +spikeinterface__spikeinterface-2610 +spikeinterface__spikeinterface-2716 +spikeinterface__spikeinterface-2757 +spikeinterface__spikeinterface-2775 +spikeinterface__spikeinterface-3017 +spikeinterface__spikeinterface-3024 +spikeinterface__spikeinterface-3047 +spikeinterface__spikeinterface-3120 +spikeinterface__spikeinterface-3180 +spikeinterface__spikeinterface-3309 +spikeinterface__spikeinterface-3347 +spikeinterface__spikeinterface-3701 +spikeinterface__spikeinterface-3778 +spikeinterface__spikeinterface-3829 +spikeinterface__spikeinterface-961 +spotahome__redis-operator-353 +spotahome__redis-operator-588 +sql-formatter-org__sql-formatter-414 +sql-formatter-org__sql-formatter-417 +sql-formatter-org__sql-formatter-420 +sql-formatter-org__sql-formatter-421 +sql-formatter-org__sql-formatter-422 +sql-formatter-org__sql-formatter-425 +sql-formatter-org__sql-formatter-458 +sql-formatter-org__sql-formatter-491 +sql-formatter-org__sql-formatter-511 +sql-formatter-org__sql-formatter-516 +sql-formatter-org__sql-formatter-544 +sql-formatter-org__sql-formatter-565 +sql-formatter-org__sql-formatter-568 +sql-formatter-org__sql-formatter-603 +sql-formatter-org__sql-formatter-880 +sqlc-dev__sqlc-3827 +sqlkata__querybuilder-557 +square__kotlinpoet-514 +src-d__go-mysql-server-372 +src-d__go-mysql-server-417 +src-d__go-mysql-server-420 +src-d__go-mysql-server-422 +src-d__go-mysql-server-459 +src-d__go-mysql-server-851 +src-d__go-mysql-server-854 +srl-labs__containerlab-1721 +srl-labs__containerlab-2509 +srvaroa__labeler-124 +srvaroa__labeler-150 +srvaroa__labeler-154 +srvaroa__labeler-159 +srvaroa__labeler-163 +srvaroa__labeler-47 +srvaroa__labeler-58 +srvaroa__labeler-60 +srvaroa__labeler-70 +srvaroa__labeler-80 +sse-secure-systems__connaisseur-1599 +sse-secure-systems__connaisseur-1714 +sse-secure-systems__connaisseur-1823 +st3v3nmw__obsidian-spaced-repetition-1081 +st3v3nmw__obsidian-spaced-repetition-277 +st3v3nmw__obsidian-spaced-repetition-856 +st3v3nmw__obsidian-spaced-repetition-867 +st3v3nmw__obsidian-spaced-repetition-964 +st3v3nmw__obsidian-spaced-repetition-971 +st3v3nmw__obsidian-spaced-repetition-972 +stac-utils__pystac-1001 +stac-utils__pystac-1003 +stac-utils__pystac-1006 +stac-utils__pystac-1016 +stac-utils__pystac-1018 +stac-utils__pystac-1049 +stac-utils__pystac-1103 +stac-utils__pystac-1169 +stac-utils__pystac-1222 +stac-utils__pystac-1231 +stac-utils__pystac-1263 +stac-utils__pystac-1337 +stac-utils__pystac-1361 +stac-utils__pystac-1365 +stac-utils__pystac-1406 +stac-utils__pystac-1423 +stac-utils__pystac-1484 +stac-utils__pystac-1495 +stac-utils__pystac-1496 +stac-utils__pystac-1509 +stac-utils__pystac-1512 +stac-utils__pystac-1522 +stac-utils__pystac-161 +stac-utils__pystac-207 +stac-utils__pystac-208 +stac-utils__pystac-221 +stac-utils__pystac-232 +stac-utils__pystac-447 +stac-utils__pystac-509 +stac-utils__pystac-511 +stac-utils__pystac-561 +stac-utils__pystac-607 +stac-utils__pystac-699 +stac-utils__pystac-700 +stac-utils__pystac-705 +stac-utils__pystac-725 +stac-utils__pystac-751 +stac-utils__pystac-782 +stac-utils__pystac-794 +stac-utils__pystac-808 +stac-utils__pystac-826 +stac-utils__pystac-885 +stac-utils__pystac-900 +stac-utils__pystac-966 +stac-utils__pystac-984 +stac-utils__pystac-986 +stac-utils__pystac-999 +stac-utils__pystac-client-126 +stac-utils__pystac-client-160 +stac-utils__pystac-client-164 +stac-utils__pystac-client-222 +stac-utils__pystac-client-338 +stac-utils__pystac-client-362 +stac-utils__pystac-client-363 +stac-utils__pystac-client-364 +stac-utils__pystac-client-373 +stac-utils__pystac-client-477 +stac-utils__pystac-client-530 +stac-utils__pystac-client-696 +stac-utils__pystac-client-709 +stac-utils__pystac-client-782 +stac-utils__stac-fastapi-729 +stackexchange__dnscontrol-2332 +stan-dev__cmdstanpy-688 +stan-dev__cmdstanpy-783 +stanfordnlp__dspy-1556 +stanfordnlp__dspy-1853 +stanfordnlp__dspy-8053 +stanfordnlp__dspy-8089 +stanfordnlp__dspy-8339 +stanfordnlp__dspy-8340 +stardog-union__stardog.js-151 +stardog-union__stardog.js-229 +statamic-rad-pack__runway-500 +statamic-rad-pack__runway-542 +statamic-rad-pack__runway-543 +statamic-rad-pack__runway-595 +statamic-rad-pack__runway-601 +statamic-rad-pack__runway-629 +statamic-rad-pack__runway-638 +statamic-rad-pack__runway-639 +statamic__cms-10003 +statamic__cms-10012 +statamic__cms-10013 +statamic__cms-10066 +statamic__cms-10113 +statamic__cms-10200 +statamic__cms-10226 +statamic__cms-10229 +statamic__cms-10246 +statamic__cms-10265 +statamic__cms-10266 +statamic__cms-10267 +statamic__cms-10282 +statamic__cms-10301 +statamic__cms-10322 +statamic__cms-10332 +statamic__cms-10336 +statamic__cms-10426 +statamic__cms-10541 +statamic__cms-10542 +statamic__cms-10548 +statamic__cms-10552 +statamic__cms-10553 +statamic__cms-10555 +statamic__cms-10584 +statamic__cms-10585 +statamic__cms-10587 +statamic__cms-10590 +statamic__cms-10591 +statamic__cms-10595 +statamic__cms-10681 +statamic__cms-10682 +statamic__cms-10687 +statamic__cms-10903 +statamic__cms-10909 +statamic__cms-11133 +statamic__cms-11219 +statamic__cms-11234 +statamic__cms-11246 +statamic__cms-11326 +statamic__cms-11334 +statamic__cms-11372 +statamic__cms-11373 +statamic__cms-11374 +statamic__cms-11447 +statamic__cms-11450 +statamic__cms-11498 +statamic__cms-11514 +statamic__cms-11544 +statamic__cms-11571 +statamic__cms-11597 +statamic__cms-11651 +statamic__cms-11704 +statamic__cms-11766 +statamic__cms-6931 +statamic__cms-7173 +statamic__cms-7205 +statamic__cms-7243 +statamic__cms-7279 +statamic__cms-7302 +statamic__cms-7313 +statamic__cms-7334 +statamic__cms-7343 +statamic__cms-7353 +statamic__cms-7420 +statamic__cms-7433 +statamic__cms-7435 +statamic__cms-7467 +statamic__cms-7469 +statamic__cms-7478 +statamic__cms-7486 +statamic__cms-7488 +statamic__cms-7509 +statamic__cms-7594 +statamic__cms-7596 +statamic__cms-7613 +statamic__cms-7616 +statamic__cms-7635 +statamic__cms-7666 +statamic__cms-7714 +statamic__cms-7730 +statamic__cms-7757 +statamic__cms-7799 +statamic__cms-7805 +statamic__cms-7863 +statamic__cms-8023 +statamic__cms-8048 +statamic__cms-8049 +statamic__cms-8067 +statamic__cms-8174 +statamic__cms-8205 +statamic__cms-8207 +statamic__cms-8219 +statamic__cms-8250 +statamic__cms-8327 +statamic__cms-8335 +statamic__cms-8447 +statamic__cms-8449 +statamic__cms-8461 +statamic__cms-8505 +statamic__cms-8531 +statamic__cms-8564 +statamic__cms-8568 +statamic__cms-8574 +statamic__cms-8607 +statamic__cms-8651 +statamic__cms-8715 +statamic__cms-8720 +statamic__cms-8725 +statamic__cms-8728 +statamic__cms-8742 +statamic__cms-8842 +statamic__cms-8892 +statamic__cms-8894 +statamic__cms-8910 +statamic__cms-8915 +statamic__cms-8918 +statamic__cms-8921 +statamic__cms-8924 +statamic__cms-8926 +statamic__cms-8927 +statamic__cms-8928 +statamic__cms-8953 +statamic__cms-8956 +statamic__cms-8957 +statamic__cms-9000 +statamic__cms-9010 +statamic__cms-9016 +statamic__cms-9018 +statamic__cms-9019 +statamic__cms-9020 +statamic__cms-9029 +statamic__cms-9031 +statamic__cms-9034 +statamic__cms-9035 +statamic__cms-9038 +statamic__cms-9084 +statamic__cms-9104 +statamic__cms-9124 +statamic__cms-9134 +statamic__cms-9154 +statamic__cms-9183 +statamic__cms-9210 +statamic__cms-9225 +statamic__cms-9275 +statamic__cms-9276 +statamic__cms-9300 +statamic__cms-9317 +statamic__cms-9353 +statamic__cms-9364 +statamic__cms-9380 +statamic__cms-9440 +statamic__cms-9483 +statamic__cms-9488 +statamic__cms-9499 +statamic__cms-9537 +statamic__cms-9539 +statamic__cms-9542 +statamic__cms-9586 +statamic__cms-9605 +statamic__cms-9606 +statamic__cms-9607 +statamic__cms-9612 +statamic__cms-9672 +statamic__cms-9685 +statamic__cms-9702 +statamic__cms-9704 +statamic__cms-9744 +statamic__cms-9791 +statamic__cms-9792 +statamic__cms-9793 +statamic__cms-9800 +statamic__cms-9819 +statamic__cms-9828 +statamic__cms-9850 +statamic__cms-9877 +statamic__cms-9906 +statamic__cms-9926 +statamic__cms-9954 +statamic__cms-9973 +statamic__cms-9990 +statamic__eloquent-driver-100 +statamic__eloquent-driver-136 +statamic__eloquent-driver-158 +statamic__eloquent-driver-176 +statamic__eloquent-driver-56 +stateful__vscode-runme-348 +stateful__vscode-runme-473 +stateful__vscode-runme-474 +statelyai__xstate-5329 +static-web-server__static-web-server-166 +static-web-server__static-web-server-452 +static-web-server__static-web-server-466 +static-web-server__static-web-server-471 +static-web-server__static-web-server-495 +statsmodels__statsmodels-9016 +statsmodels__statsmodels-9311 +stealjs__steal-720 +stebalien__tempfile-177 +stebalien__tempfile-225 +stebalien__tempfile-250 +stebalien__tempfile-286 +stebalien__tempfile-299 +stebalien__tempfile-355 +stebalien__tempfile-38 +stellar__django-polaris-654 +stellar__django-polaris-711 +stellar__go-5168 +stellar__go-5484 +stellar__go-5748 +stellar__rs-soroban-env-1033 +stellar__rs-soroban-env-1053 +stellar__rs-soroban-env-1407 +stellar__rs-soroban-env-1555 +stephencelis__sqlite.swift-1062 +stephencelis__sqlite.swift-1210 +stephencelis__sqlite.swift-1218 +stephenh__ts-proto-1052 +stephenh__ts-proto-482 +stephenh__ts-proto-653 +stephenh__ts-proto-982 +stern__stern-344 +steveukx__git-js-541 +steveukx__git-js-550 +steveukx__git-js-563 +stfc__fparser-302 +stfc__fparser-356 +stfc__fparser-408 +stfc__fparser-451 +stfc__fparser-462 +stfc__fparser-467 +stfc__psyclone-1850 +stfc__psyclone-1894 +stfc__psyclone-1900 +stfc__psyclone-1914 +stfc__psyclone-2015 +stfc__psyclone-2084 +stfc__psyclone-2086 +stfc__psyclone-2124 +stfc__psyclone-2147 +stfc__psyclone-2230 +stfc__psyclone-2231 +stfc__psyclone-2301 +stfc__psyclone-2309 +stfc__psyclone-2342 +stfc__psyclone-2361 +stfc__psyclone-2362 +stfc__psyclone-2363 +stfc__psyclone-2365 +stfc__psyclone-2378 +stfc__psyclone-2380 +stfc__psyclone-2493 +stfc__psyclone-2508 +stfc__psyclone-2517 +stfc__psyclone-2545 +stfc__psyclone-2567 +stfc__psyclone-2572 +stfc__psyclone-2609 +stfc__psyclone-2628 +stfc__psyclone-2637 +stfc__psyclone-2645 +stfc__psyclone-2673 +stfc__psyclone-2685 +stfc__psyclone-2767 +stfc__psyclone-2914 +stfc__psyclone-2953 +stfc__psyclone-2983 +stfc__psyclone-3029 +stfc__psyclone-3037 +stingraysoftware__stingray-203 +stingraysoftware__stingray-236 +stingraysoftware__stingray-289 +stingraysoftware__stingray-324 +stingraysoftware__stingray-797 +stingraysoftware__stingray-814 +stingraysoftware__stingray-822 +stingraysoftware__stingray-858 +stingraysoftware__stingray-865 +stingraysoftware__stingray-874 +stoplightio__spectral-1020 +stoplightio__spectral-1059 +stoplightio__spectral-1077 +stoplightio__spectral-2224 +stoplightio__spectral-2272 +stoplightio__spectral-2304 +stoplightio__spectral-2326 +stoplightio__spectral-2389 +stoplightio__spectral-2440 +stoplightio__spectral-2526 +stoplightio__spectral-2538 +stoplightio__spectral-2573 +stoplightio__spectral-2614 +stoplightio__spectral-2632 +stoplightio__spectral-2638 +stoplightio__spectral-2648 +stoplightio__spectral-477 +stoplightio__spectral-480 +stoplightio__spectral-515 +stoplightio__spectral-617 +stoplightio__spectral-675 +stoplightio__spectral-712 +stoplightio__spectral-758 +stoplightio__spectral-913 +stoplightio__spectral-914 +stormpath__stormpath-sdk-java-568 +stranger6667__postmarker-191 +stravalib__stravalib-522 +stravalib__stravalib-584 +strawberry-graphql__strawberry-103 +strawberry-graphql__strawberry-55 +streamich__memfs-1024 +streamich__memfs-1069 +streamich__memfs-1076 +streamich__memfs-1079 +streamich__memfs-866 +streamich__memfs-867 +streamich__memfs-882 +streamich__memfs-891 +streamich__memfs-941 +streamich__react-use-1684 +streamich__react-use-1870 +streamich__react-use-1944 +streamich__react-use-817 +streamlink__streamlink-122 +streamlink__streamlink-135 +streamlink__streamlink-1550 +streamlink__streamlink-1833 +streamlink__streamlink-1857 +streamlink__streamlink-2085 +streamlink__streamlink-2653 +streamlink__streamlink-2654 +streamlink__streamlink-2671 +streamlink__streamlink-469 +streamlink__streamlink-508 +streamlink__streamlink-785 +streamlink__streamlink-969 +stretchr__testify-686 +stretchr__testify-839 +stretchr__testify-855 +stretchr__testify-871 +stretchr__testify-914 +stretchr__testify-919 +stretchr__testify-920 +stretchr__testify-929 +stretchr__testify-937 +striglia__pyramid_swagger-191 +striglia__pyramid_swagger-196 +striglia__pyramid_swagger-221 +striglia__pyramid_swagger-223 +stripe__stripe-cli-245 +stripe__stripe-cli-248 +stripe__stripe-cli-705 +stripe__stripe-go-1607 +stripe__stripe-go-1735 +stripe__stripe-go-512 +stripe__stripe-go-789 +strongloop__loopback-datasource-juggler-1269 +strongloop__loopback-datasource-juggler-1276 +strongloop__loopback-datasource-juggler-1438 +strongloop__loopback-datasource-juggler-1726 +strongloop__loopback-datasource-juggler-1782 +strongloop__loopback-datasource-juggler-1790 +strongloop__loopback-datasource-juggler-1799 +strongloop__loopback-datasource-juggler-818 +styled-components__babel-plugin-styled-components-112 +styled-components__babel-plugin-styled-components-17 +styled-components__babel-plugin-styled-components-228 +styled-components__babel-plugin-styled-components-28 +styled-components__babel-plugin-styled-components-298 +styled-components__babel-plugin-styled-components-30 +styled-components__babel-plugin-styled-components-334 +styled-components__babel-plugin-styled-components-339 +styled-components__babel-plugin-styled-components-340 +styled-components__babel-plugin-styled-components-359 +styled-components__babel-plugin-styled-components-6 +styled-components__babel-plugin-styled-components-94 +styled-components__stylelint-processor-styled-components-107 +styled-components__stylelint-processor-styled-components-17 +styled-components__stylelint-processor-styled-components-59 +styled-components__stylelint-processor-styled-components-74 +styled-components__stylelint-processor-styled-components-84 +styled-system__styled-system-536 +styled-system__styled-system-584 +styled-system__styled-system-585 +styled-system__styled-system-595 +styled-system__styled-system-679 +styled-system__styled-system-723 +styled-system__styled-system-812 +styled-system__styled-system-824 +styleguidist__react-docgen-typescript-405 +styleguidist__react-docgen-typescript-433 +styleguidist__react-styleguidist-1142 +styleguidist__react-styleguidist-1296 +styleguidist__react-styleguidist-1690 +styleguidist__react-styleguidist-662 +styleguidist__react-styleguidist-803 +styleguidist__react-styleguidist-814 +styleguidist__react-styleguidist-938 +styleguidist__react-styleguidist-978 +stylelint-scss__stylelint-scss-1023 +stylelint-scss__stylelint-scss-1060 +stylelint-scss__stylelint-scss-1103 +stylelint-scss__stylelint-scss-570 +stylelint-scss__stylelint-scss-574 +stylelint-scss__stylelint-scss-575 +stylelint-scss__stylelint-scss-715 +stylelint-scss__stylelint-scss-740 +stylelint-scss__stylelint-scss-767 +stylelint-scss__stylelint-scss-768 +stylelint-scss__stylelint-scss-844 +stylelint-scss__stylelint-scss-847 +stylelint-scss__stylelint-scss-848 +stylelint-scss__stylelint-scss-867 +stylelint-scss__stylelint-scss-870 +stylelint-scss__stylelint-scss-872 +stylelint-scss__stylelint-scss-883 +stylelint-scss__stylelint-scss-970 +stylelint-scss__stylelint-scss-985 +stylelint__vscode-stylelint-325 +stylelint__vscode-stylelint-330 +stylelint__vscode-stylelint-339 +stylelint__vscode-stylelint-340 +stylelint__vscode-stylelint-356 +stylelint__vscode-stylelint-358 +stylelint__vscode-stylelint-399 +stylelint__vscode-stylelint-442 +stylelint__vscode-stylelint-635 +stylelint__vscode-stylelint-650 +stylelint__vscode-stylelint-672 +stylelint__vscode-stylelint-699 +submariner-io__lighthouse-222 +submariner-io__lighthouse-574 +submariner-io__lighthouse-879 +submariner-io__submariner-operator-1172 +substratusai__kubeai-263 +substratusai__kubeai-268 +substratusai__kubeai-436 +substratusai__kubeai-437 +sunng87__handlebars-rust-217 +sunng87__handlebars-rust-277 +sunng87__handlebars-rust-282 +sunng87__handlebars-rust-338 +sunng87__handlebars-rust-461 +sunng87__handlebars-rust-473 +sunng87__handlebars-rust-581 +sunng87__handlebars-rust-657 +supabase__cli-2904 +supabase__cli-325 +supabase__gotrue-1368 +superfly__flyctl-4133 +superfly__flyctl-4138 +surface-ui__surface_formatter-53 +surface-ui__surface_formatter-54 +surface-ui__surface_formatter-56 +surrealdb__surrealdb.go-225 +surveyjs__survey-analytics-456 +surveyjs__survey-analytics-552 +survivejs__webpack-merge-32 +suse-edge__edge-image-builder-360 +suse-edge__edge-image-builder-506 +suse-edge__edge-image-builder-530 +suse-edge__edge-image-builder-660 +suse-edge__edge-image-builder-687 +suzuki-shunsuke__tfcmt-1257 +suzuki-shunsuke__tfcmt-80 +sveltejs__cli-432 +sveltejs__eslint-plugin-svelte-1054 +sveltejs__eslint-plugin-svelte-1091 +sveltejs__eslint-plugin-svelte-1107 +sveltejs__eslint-plugin-svelte-1108 +sveltejs__eslint-plugin-svelte-1227 +sveltejs__eslint-plugin-svelte-1231 +sveltejs__eslint-plugin-svelte-772 +sveltejs__eslint-plugin-svelte-841 +sveltejs__eslint-plugin-svelte-864 +sveltejs__eslint-plugin-svelte-918 +sveltejs__eslint-plugin-svelte-922 +sveltejs__kit-3562 +sveltejs__kit-3571 +sveltejs__prettier-plugin-svelte-119 +sveltejs__prettier-plugin-svelte-120 +sveltejs__prettier-plugin-svelte-122 +sveltejs__prettier-plugin-svelte-133 +sveltejs__prettier-plugin-svelte-140 +sveltejs__prettier-plugin-svelte-141 +sveltejs__prettier-plugin-svelte-148 +sveltejs__prettier-plugin-svelte-152 +sveltejs__prettier-plugin-svelte-172 +sveltejs__prettier-plugin-svelte-174 +sveltejs__prettier-plugin-svelte-175 +sveltejs__prettier-plugin-svelte-176 +sveltejs__prettier-plugin-svelte-178 +sveltejs__prettier-plugin-svelte-187 +sveltejs__prettier-plugin-svelte-195 +sveltejs__prettier-plugin-svelte-200 +sveltejs__prettier-plugin-svelte-203 +sveltejs__prettier-plugin-svelte-204 +sveltejs__prettier-plugin-svelte-206 +sveltejs__prettier-plugin-svelte-208 +sveltejs__prettier-plugin-svelte-216 +sveltejs__prettier-plugin-svelte-220 +sveltejs__prettier-plugin-svelte-226 +sveltejs__prettier-plugin-svelte-260 +sveltejs__prettier-plugin-svelte-268 +sveltejs__prettier-plugin-svelte-269 +sveltejs__prettier-plugin-svelte-282 +sveltejs__prettier-plugin-svelte-306 +sveltejs__prettier-plugin-svelte-315 +sveltejs__prettier-plugin-svelte-324 +sveltejs__prettier-plugin-svelte-325 +sveltejs__prettier-plugin-svelte-345 +sveltejs__prettier-plugin-svelte-354 +sveltejs__prettier-plugin-svelte-356 +sveltejs__prettier-plugin-svelte-357 +sveltejs__prettier-plugin-svelte-425 +svenstaro__miniserve-1482 +svg__svgo-741 +svg__svgo-758 +svg__svgo-821 +svg__svgo-916 +svg__svgo-935 +swagger-api__swagger-parser-1132 +swagger-api__swagger-parser-1456 +swagger-api__swagger-parser-1502 +swagger-api__swagger-parser-1707 +swagger-api__swagger-parser-1877 +swagger-api__swagger-parser-216 +swagger-api__swagger-ui-7545 +swagger-api__swagger-ui-7941 +swagger-api__swagger-ui-8400 +swagger-api__swagger-ui-9343 +swaggest__openapi-go-110 +swaggest__openapi-go-138 +swaggest__openapi-go-146 +swaggest__openapi-go-46 +swaggest__openapi-go-50 +swaggest__openapi-go-52 +swaggest__openapi-go-72 +swaggest__rest-124 +swaggest__rest-125 +swaggest__rest-126 +swaggest__rest-128 +swaggest__rest-140 +swaggest__rest-144 +swaggest__rest-195 +swaggest__rest-213 +swaggest__rest-64 +swaggest__rest-72 +swaggest__rest-73 +swaggest__rest-86 +swaggo__swag-1883 +swellaby__rusty-hook-100 +swellaby__rusty-hook-116 +swellaby__rusty-hook-143 +swellaby__rusty-hook-147 +swellaby__rusty-hook-73 +swift-server__swiftly-75 +swiftlang__swift-syntax-1164 +swiftlang__swift-syntax-1170 +swiftlang__swift-syntax-1248 +swiftlang__swift-syntax-1281 +swiftlang__swift-syntax-1282 +swiftlang__swift-syntax-1402 +swiftlang__swift-syntax-1498 +swiftlang__swift-syntax-1510 +swiftlang__swift-syntax-1532 +swiftlang__swift-syntax-1553 +swiftlang__swift-syntax-1661 +swiftlang__swift-syntax-1677 +swiftlang__swift-syntax-1683 +swiftlang__swift-syntax-1693 +swiftlang__swift-syntax-1745 +swiftlang__swift-syntax-1773 +swiftlang__swift-syntax-1791 +swiftlang__swift-syntax-1809 +swiftlang__swift-syntax-1820 +swiftlang__swift-syntax-1833 +swiftlang__swift-syntax-2115 +swiftlang__swift-syntax-2132 +swiftlang__swift-syntax-2139 +swiftlang__swift-syntax-2176 +swiftlang__swift-syntax-2186 +swiftlang__swift-syntax-2215 +swiftlang__swift-syntax-2257 +swiftlang__swift-syntax-2320 +swiftlang__swift-syntax-2327 +swiftlang__swift-syntax-2345 +swiftlang__swift-syntax-2370 +swiftlang__swift-syntax-2475 +swiftlang__swift-syntax-2543 +swiftlang__swift-syntax-2604 +swiftlang__swift-syntax-2605 +swiftlang__swift-syntax-2660 +swiftlang__swift-syntax-2712 +swiftlang__swift-syntax-2727 +swiftlang__swift-syntax-2826 +swiftlang__swift-syntax-3098 +swiftlang__swift-syntax-3104 +swiftlang__swift-syntax-3116 +swisnl__json-api-client-108 +swisnl__json-api-client-90 +swoosh__swoosh-852 +swoosh__swoosh-853 +swoosh__swoosh-883 +swup__swup-869 +sylabs__singularity-cri-345 +symfony__flex-685 +symfony__flex-728 +symfony__flex-767 +symfony__flex-769 +symfony__flex-798 +symfony__flex-831 +symfony__flex-858 +symfony__flex-867 +symfony__flex-869 +symfony__flex-883 +symfony__flex-937 +symfony__flex-978 +symfony__flex-994 +symfony__monolog-bundle-368 +symfony__monolog-bundle-387 +symfony__monolog-bundle-388 +symfony__monolog-bundle-438 +symfony__monolog-bundle-446 +symplify__symplify-2060 +symplify__symplify-3879 +symplify__symplify-3932 +symplify__symplify-4379 +symplify__symplify-4380 +symplify__symplify-4452 +symplify__symplify-4499 +symplify__symplify-4514 +synth-inference__synthdid-41 +synthetixio__synthetix-v3-192 +synthetixio__synthetix-v3-234 +synthetixio__synthetix-v3-564 +syself__cluster-api-provider-hetzner-1162 +syself__cluster-api-provider-hetzner-1387 +syself__cluster-api-provider-hetzner-1415 +syself__cluster-api-provider-hetzner-1416 +syself__cluster-api-provider-hetzner-1590 +syself__cluster-api-provider-hetzner-932 +syself__cluster-api-provider-hetzner-935 +systemd__mkosi-1080 +systemd__mkosi-2044 +systemd__mkosi-2181 +systemd__mkosi-2376 +systemd__mkosi-2583 +systemd__mkosi-2859 +systemd__mkosi-2861 +systemd__mkosi-2954 +systemd__mkosi-3216 +systemd__mkosi-3346 +systemd__mkosi-3586 +systemd__mkosi-806 +systemd__mkosi-892 +syuilo__aiscript-157 +syuilo__aiscript-166 +syuilo__aiscript-209 +syuilo__aiscript-217 +syuilo__aiscript-236 +syuilo__aiscript-244 +syuilo__aiscript-257 +syuilo__aiscript-285 +syuilo__aiscript-313 +syuilo__aiscript-329 +szdc__tiktok-api-70 +tableauio__tableau-100 +tableauio__tableau-122 +tableauio__tableau-128 +tableauio__tableau-141 +tableauio__tableau-152 +tableauio__tableau-175 +tableauio__tableau-207 +tableauio__tableau-44 +tableauio__tableau-89 +tableauio__tableau-95 +tablelandnetwork__go-tableland-549 +taiki-e__cargo-hack-25 +taiki-e__cargo-hack-32 +taiki-e__cargo-hack-36 +taiki-e__cargo-hack-41 +taiki-e__cargo-hack-46 +taiki-e__cargo-hack-49 +taiki-e__cargo-hack-55 +taiki-e__cargo-hack-61 +taiki-e__cargo-hack-64 +taiki-e__cargo-hack-66 +taiki-e__cargo-hack-70 +taiki-e__cargo-hack-82 +taiki-e__cargo-hack-85 +taiki-e__cargo-llvm-cov-173 +taiki-e__cargo-llvm-cov-249 +taiki-e__cargo-llvm-cov-91 +tailwindlabs__headlessui-2972 +tailwindlabs__tailwindcss-2075 +tailwindlabs__tailwindcss-2108 +tailwindlabs__tailwindcss-2322 +tailwindlabs__tailwindcss-2331 +tailwindlabs__tailwindcss-2333 +tailwindlabs__tailwindcss-2337 +tailwindlabs__tailwindcss-2353 +tailwindlabs__tailwindcss-2364 +tailwindlabs__tailwindcss-2376 +tailwindlabs__tailwindcss-2382 +tailwindlabs__tailwindcss-2536 +tailwindlabs__tailwindcss-2548 +tailwindlabs__tailwindcss-2643 +tailwindlabs__tailwindcss-4260 +tailwindlabs__tailwindcss-4263 +tailwindlabs__tailwindcss-4272 +tailwindlabs__tailwindcss-4335 +tailwindlabs__tailwindcss-4508 +tailwindlabs__tailwindcss-4795 +tailwindlabs__tailwindcss-4817 +tailwindlabs__tailwindcss-5038 +tailwindlabs__tailwindcss-5223 +tailwindlabs__tailwindcss-5245 +tailwindlabs__tailwindcss-5252 +tailwindlabs__tailwindcss-jit-119 +tailwindlabs__tailwindcss-jit-127 +tailwindlabs__tailwindcss-jit-150 +tailwindlabs__tailwindcss-jit-151 +tailwindlabs__tailwindcss-jit-155 +tailwindlabs__tailwindcss-jit-157 +tailwindlabs__tailwindcss-jit-161 +tailwindlabs__tailwindcss-jit-164 +tailwindlabs__tailwindcss-jit-177 +tailwindlabs__tailwindcss-jit-30 +tailwindlabs__tailwindcss-jit-69 +tailwindlabs__tailwindcss-jit-89 +tailwindlabs__tailwindcss-jit-99 +takluyver__flit-168 +takluyver__flit-169 +takluyver__flit-181 +takluyver__flit-210 +takluyver__flit-232 +takluyver__flit-234 +takluyver__flit-286 +tallarium__reverse_proxy_plug-12 +tallarium__reverse_proxy_plug-177 +tallarium__reverse_proxy_plug-180 +tallarium__reverse_proxy_plug-186 +tallarium__reverse_proxy_plug-197 +tallarium__reverse_proxy_plug-232 +tannerlinsley__react-query-1660 +tannerlinsley__react-query-1665 +tannerlinsley__react-query-2108 +tannerlinsley__react-query-2249 +tannerlinsley__react-query-2275 +tannerlinsley__react-query-2851 +tannerlinsley__react-query-2892 +tannerlinsley__react-query-2933 +tannerlinsley__react-query-2950 +tannerlinsley__react-query-2992 +tannerlinsley__react-query-3032 +tannerlinsley__react-query-3081 +tannerlinsley__react-query-3098 +tannerlinsley__react-query-3106 +tannerlinsley__react-query-3140 +tannerlinsley__react-query-3183 +tannerlinsley__react-query-3216 +tannerlinsley__react-query-3223 +tannerlinsley__react-query-3464 +tannerlinsley__react-query-3613 +tannerlinsley__react-query-827 +tannerlinsley__react-query-976 +tanstack__query-5713 +tanstack__query-6088 +tanstack__router-1544 +tanstack__router-1548 +tanstack__router-1561 +tanstack__router-1810 +tanstack__router-1813 +tanstack__router-1922 +tanstack__router-1946 +tanstack__router-1947 +tanstack__router-2021 +tanstack__router-2027 +tanstack__router-2074 +tanstack__router-2075 +tanstack__router-2090 +tanstack__router-2235 +tanstack__router-2259 +tanstack__router-2261 +tanstack__router-2543 +tanstack__router-2610 +tanstack__router-2640 +tanstack__router-2955 +tanstack__router-3095 +tanstack__router-3269 +tanstack__router-3289 +tanstack__router-3331 +tanstack__router-3337 +tanstack__router-3423 +tanstack__router-3496 +tanstack__router-3671 +tartiflette__tartiflette-234 +tartiflette__tartiflette-236 +tartiflette__tartiflette-293 +tartiflette__tartiflette-310 +tartiflette__tartiflette-383 +tartiflette__tartiflette-384 +tartiflette__tartiflette-454 +tatethurston__nextjs-routes-116 +tatethurston__nextjs-routes-129 +tatethurston__nextjs-routes-134 +tatethurston__nextjs-routes-52 +tatethurston__nextjs-routes-57 +tatethurston__nextjs-routes-77 +tatethurston__nextjs-routes-79 +tatethurston__nextjs-routes-80 +tatuylonen__wiktextract-1107 +tatuylonen__wiktextract-1142 +tatuylonen__wiktextract-1157 +tatuylonen__wiktextract-1188 +tatuylonen__wiktextract-1213 +tatuylonen__wiktextract-1215 +tatuylonen__wiktextract-1220 +tatuylonen__wiktextract-1271 +tatuylonen__wiktextract-541 +tatuylonen__wiktextract-881 +tatuylonen__wiktextract-893 +tatuylonen__wiktextract-931 +tatuylonen__wiktextract-971 +tatuylonen__wiktextract-978 +tatuylonen__wiktextract-986 +tbd54566975__ssi-service-552 +tbd54566975__ssi-service-565 +tbd54566975__ssi-service-568 +tbd54566975__ssi-service-583 +tbd54566975__ssi-service-584 +tbd54566975__ssi-service-589 +tbd54566975__ssi-service-627 +tclindner__npm-package-json-lint-21 +tclindner__npm-package-json-lint-51 +tclindner__npm-package-json-lint-61 +tdameritrade__stumpy-1015 +tdameritrade__stumpy-1070 +tdameritrade__stumpy-1078 +tdameritrade__stumpy-288 +tdameritrade__stumpy-649 +tdameritrade__stumpy-655 +tdameritrade__stumpy-656 +tdameritrade__stumpy-806 +tdameritrade__stumpy-817 +tdameritrade__stumpy-856 +tdameritrade__stumpy-983 +tealeg__xlsx-531 +tealeg__xlsx-549 +tealeg__xlsx-550 +tealeg__xlsx-554 +tealeg__xlsx-645 +tealeg__xlsx-697 +tealeg__xlsx-698 +tealeg__xlsx-816 +tealeg__xlsx-819 +tealeg__xlsx-838 +techarohq__anubis-881 +technologyadvice__obey-60 +technologyadvice__obey-61 +technologyadvice__obey-65 +technologyadvice__obey-69 +teddriggs__darling-12 +teddriggs__darling-177 +teddriggs__darling-193 +teddriggs__darling-258 +teddriggs__darling-269 +teddriggs__darling-270 +teddriggs__darling-272 +teddriggs__darling-274 +teddriggs__darling-276 +teddriggs__darling-297 +teddriggs__darling-310 +teddriggs__darling-318 +teddriggs__darling-319 +teddriggs__darling-323 +teddriggs__darling-337 +teddriggs__darling-339 +tediousjs__node-mssql-1356 +tediousjs__node-mssql-1520 +tediousjs__node-mssql-742 +tediousjs__node-mssql-853 +tediousjs__node-mssql-901 +tediousjs__node-mssql-960 +tefra__xsdata-310 +tefra__xsdata-499 +tefra__xsdata-695 +tefra__xsdata-699 +tefra__xsdata-801 +tefra__xsdata-820 +tefra__xsdata-881 +tektoncd__operator-1171 +tektoncd__operator-1713 +tektoncd__operator-2004 +tektoncd__operator-2022 +tektoncd__operator-2482 +tektoncd__operator-2542 +tektoncd__operator-345 +tektoncd__operator-428 +tektoncd__operator-642 +tektoncd__results-690 +teleporthq__teleport-code-generators-221 +teleporthq__teleport-code-generators-223 +teleporthq__teleport-code-generators-227 +teleporthq__teleport-code-generators-262 +teleporthq__teleport-code-generators-272 +teleporthq__teleport-code-generators-291 +teleporthq__teleport-code-generators-338 +teleporthq__teleport-code-generators-351 +teleporthq__teleport-code-generators-380 +teleporthq__teleport-code-generators-555 +teleporthq__teleport-code-generators-575 +temporalio__ui-267 +tendermint__spn-176 +tendermint__spn-248 +tensorflow__datasets-240 +tensorflow__datasets-242 +tensorflow__datasets-404 +tensorflow__datasets-892 +terraform-docs__terraform-docs-307 +terraform-docs__terraform-docs-327 +terraform-docs__terraform-docs-384 +terraform-docs__terraform-docs-416 +terraform-docs__terraform-docs-429 +terraform-docs__terraform-docs-483 +terraform-docs__terraform-docs-509 +terraform-docs__terraform-docs-527 +terraform-docs__terraform-docs-535 +terraform-docs__terraform-docs-537 +terraform-docs__terraform-docs-544 +terraform-docs__terraform-docs-565 +terraform-docs__terraform-docs-570 +terraform-docs__terraform-docs-586 +terraform-docs__terraform-docs-587 +terraform-docs__terraform-docs-770 +terraform-docs__terraform-docs-833 +terrapower__armi-2102 +terrapower__armi-2175 +test-results-reporter__reporter-167 +test-results-reporter__reporter-26 +testem__testem-1463 +testem__testem-1748 +testing-library__angular-testing-library-35 +testing-library__svelte-testing-library-362 +testing-library__svelte-testing-library-404 +tetratelabs__getenvoy-171 +tetratelabs__getenvoy-182 +tetratelabs__getenvoy-184 +tetratelabs__getenvoy-251 +tetratelabs__getenvoy-253 +tetratelabs__getenvoy-255 +tetratelabs__getenvoy-265 +tetratelabs__wazero-242 +tetratelabs__wazero-371 +tetratelabs__wazero-419 +tetratelabs__wazero-466 +tetratelabs__wazero-527 +tetratelabs__wazero-534 +tetratelabs__wazero-535 +textileio__go-threads-478 +textualize__rich-1804 +textualize__rich-1834 +textualize__rich-1842 +textualize__rich-2031 +textualize__rich-2038 +textualize__rich-2201 +textualize__rich-2219 +textualize__rich-2225 +textualize__rich-2226 +textualize__rich-2247 +textualize__rich-2294 +textualize__rich-2296 +textualize__rich-2489 +textualize__rich-2491 +textualize__rich-2513 +textualize__rich-2642 +textualize__rich-2799 +textualize__rich-2804 +textualize__rich-2806 +textualize__rich-2943 +textualize__rich-3006 +textualize__rich-3067 +textualize__rich-3105 +textualize__rich-3130 +textualize__rich-3180 +textualize__rich-3296 +textualize__rich-3518 +textualize__rich-3718 +tfsec__tfsec-846 +tfsec__tfsec-848 +theacodes__nox-140 +theacodes__nox-145 +theacodes__nox-147 +theacodes__nox-152 +theacodes__nox-185 +theacodes__nox-187 +theacodes__nox-217 +theacodes__nox-267 +theacodes__nox-310 +theacodes__nox-312 +theacodes__nox-314 +theacodes__nox-359 +theacodes__nox-361 +theacodes__nox-363 +theacodes__nox-388 +theacodes__nox-393 +theacodes__nox-401 +theacodes__nox-413 +theacodes__nox-418 +theacodes__nox-420 +theacodes__nox-425 +theacodes__nox-432 +theacodes__nox-434 +theacodes__nox-439 +theacodes__nox-448 +theacodes__nox-466 +theacodes__nox-472 +theacodes__nox-482 +theacodes__nox-489 +theacodes__nox-522 +theacodes__nox-523 +theacodes__nox-535 +theacodes__nox-537 +theacodes__nox-538 +theacodes__nox-543 +theacodes__nox-567 +thebrainfamily__cypress-cucumber-preprocessor-234 +thebrainfamily__cypress-cucumber-preprocessor-331 +thebrainfamily__cypress-cucumber-preprocessor-346 +thebrainfamily__cypress-cucumber-preprocessor-45 +thebrainfamily__cypress-cucumber-preprocessor-557 +thehubbleproject__hubble-contracts-346 +thehubbleproject__hubble-contracts-657 +thehubbleproject__hubble-contracts-667 +theislab__scanpy-2187 +thelounge__thelounge-2538 +thelounge__thelounge-2569 +thenewboston-developers__website-1578 +theodinproject__odin-bot-v2-110 +theodinproject__odin-bot-v2-125 +theodinproject__odin-bot-v2-212 +theodinproject__odin-bot-v2-227 +theodinproject__odin-bot-v2-259 +theodinproject__odin-bot-v2-419 +theodinproject__odin-bot-v2-430 +theodinproject__odin-bot-v2-440 +theodinproject__odin-bot-v2-513 +theodinproject__odin-bot-v2-548 +theodinproject__odin-bot-v2-556 +theodinproject__odin-bot-v2-567 +theodinproject__odin-bot-v2-659 +theodinproject__odin-bot-v2-687 +theodinproject__odin-bot-v2-700 +theodinproject__odin-bot-v2-707 +thephpleague__commonmark-1034 +thephpleague__commonmark-1038 +thephpleague__commonmark-1061 +thephpleague__commonmark-530 +thephpleague__commonmark-533 +thephpleague__commonmark-604 +thephpleague__commonmark-787 +thephpleague__commonmark-871 +thephpleague__commonmark-883 +thephpleague__commonmark-899 +thephpleague__commonmark-909 +thephpleague__commonmark-952 +thephpleague__commonmark-993 +thephpleague__oauth2-client-1032 +thephpleague__oauth2-client-1053 +thephpleague__oauth2-server-1198 +thephpleague__oauth2-server-1210 +thephpleague__oauth2-server-1215 +thephpleague__oauth2-server-1304 +thephpleague__oauth2-server-1410 +thephpleague__oauth2-server-1412 +thephpleague__oauth2-server-1420 +thephpleague__openapi-psr7-validator-126 +thephpleague__openapi-psr7-validator-131 +thephpleague__openapi-psr7-validator-159 +theskumar__python-dotenv-224 +theupdateframework__go-tuf-182 +theupdateframework__go-tuf-214 +theupdateframework__go-tuf-310 +theupdateframework__go-tuf-354 +theupdateframework__go-tuf-479 +theupdateframework__go-tuf-645 +theupdateframework__python-tuf-2273 +theupdateframework__python-tuf-2378 +theupdateframework__python-tuf-2481 +theupdateframework__python-tuf-2551 +theupdateframework__python-tuf-2612 +theupdateframework__python-tuf-2632 +theupdateframework__python-tuf-2650 +theupdateframework__python-tuf-2789 +theupdateframework__python-tuf-2808 +thomasdezeeuw__a10-115 +thomasdezeeuw__a10-116 +thomasdezeeuw__a10-117 +thomasdezeeuw__a10-137 +threefoldtech__zos-1699 +threefoldtech__zos-2019 +threefoldtech__zos-354 +threefoldtech__zos-385 +threefoldtech__zos-414 +threefoldtech__zos-431 +threefoldtech__zos-445 +threefoldtech__zos-481 +threefoldtech__zos-570 +threefoldtech__zos-959 +tidewave-ai__tidewave_phoenix-16 +tidewave-ai__tidewave_phoenix-71 +tighten__tlint-205 +tighten__tlint-219 +tighten__tlint-224 +tighten__tlint-243 +tighten__tlint-255 +tighten__tlint-259 +tighten__tlint-264 +tighten__tlint-286 +tighten__tlint-346 +tighten__tlint-347 +tighten__tlint-351 +tighten__tlint-371 +tighten__ziggy-754 +tighten__ziggy-778 +tightenco__tlint-113 +tightenco__tlint-119 +tightenco__tlint-131 +tightenco__tlint-136 +tightenco__tlint-166 +tightenco__tlint-23 +tightenco__tlint-24 +tightenco__tlint-35 +tightenco__tlint-45 +tightenco__tlint-62 +tikv__client-go-1021 +tikv__client-go-1105 +tikv__client-go-1115 +tikv__client-go-1127 +tikv__client-go-1140 +tikv__client-go-1174 +tikv__client-go-1178 +tikv__client-go-1181 +tikv__client-go-1182 +tikv__client-go-1183 +tikv__client-go-1184 +tikv__client-go-1192 +tikv__client-go-1203 +tikv__client-go-1273 +tikv__client-go-1300 +tikv__client-go-1344 +tikv__client-go-1377 +tikv__client-go-1402 +tikv__client-go-1407 +tikv__client-go-1409 +tikv__client-go-1417 +tikv__client-go-1642 +tikv__client-go-1712 +tikv__client-go-566 +tikv__client-go-843 +tikv__client-go-942 +tikv__client-go-969 +tikv__client-go-978 +tikv__pd-5302 +tikv__pd-5480 +tikv__pd-5769 +tikv__pd-6927 +tikv__pd-7087 +tikv__pd-7122 +tikv__pd-7149 +tikv__pd-7688 +tikv__pd-7793 +tikv__pd-9092 +tilt-dev__tilt-6493 +timholy__revise.jl-785 +timholy__revise.jl-793 +timholy__revise.jl-909 +timholy__revise.jl-943 +timholy__snoopcompile.jl-408 +timholy__snoopcompile.jl-415 +timholy__snoopcompile.jl-417 +timothycrosley__isort-1029 +timothycrosley__isort-1031 +timothycrosley__isort-222 +timothycrosley__isort-230 +timothycrosley__isort-232 +timothycrosley__isort-390 +timothycrosley__isort-465 +timothycrosley__isort-536 +timothycrosley__isort-775 +timothycrosley__isort-802 +timothycrosley__isort-810 +timothycrosley__isort-819 +timothycrosley__isort-891 +timothycrosley__isort-892 +timothycrosley__isort-893 +timothycrosley__isort-900 +timothycrosley__isort-911 +timothycrosley__isort-917 +timothycrosley__isort-946 +timothycrosley__isort-972 +timshannon__bolthold-129 +tinylib__msgp-378 +tinylibs__tinybench-150 +tinylibs__tinybench-210 +tinylibs__tinybench-51 +tinylibs__tinybench-75 +tjtanjin__react-chatbotify-134 +tjtanjin__react-chatbotify-174 +tjtanjin__react-chatbotify-179 +tjtanjin__react-chatbotify-212 +tjtanjin__react-chatbotify-216 +tjtanjin__react-chatbotify-234 +tjtanjin__react-chatbotify-236 +tjtanjin__react-chatbotify-238 +tjtanjin__react-chatbotify-240 +tjtanjin__react-chatbotify-243 +tjtanjin__react-chatbotify-252 +tjtanjin__react-chatbotify-271 +tjtanjin__react-chatbotify-287 +tkh44__emotion-118 +tkh44__emotion-144 +tkh44__emotion-218 +tkh44__emotion-253 +tkh44__emotion-256 +tkh44__emotion-52 +tkh44__emotion-86 +tkh44__emotion-91 +tkh44__emotion-98 +tldr-pages__tldr-node-client-366 +tldr-pages__tldr-node-client-421 +tlienart__franklin.jl-422 +tlienart__franklin.jl-435 +tlienart__franklin.jl-448 +tlienart__judoc.jl-422 +tlienart__judoc.jl-435 +tlienart__judoc.jl-448 +tmc__langchaingo-136 +tmc__langchaingo-199 +tobie__specref-649 +tobie__specref-690 +tobie__specref-702 +tobie__specref-753 +tobie__specref-851 +tobikodata__sqlmesh-1817 +tobikodata__sqlmesh-2056 +tobikodata__sqlmesh-2477 +tobikodata__sqlmesh-2486 +tobikodata__sqlmesh-2520 +tobikodata__sqlmesh-2547 +tobikodata__sqlmesh-2555 +tobikodata__sqlmesh-2688 +tobikodata__sqlmesh-2731 +tobikodata__sqlmesh-2903 +tobikodata__sqlmesh-3058 +tobikodata__sqlmesh-3082 +tobikodata__sqlmesh-3093 +tobikodata__sqlmesh-3103 +tobikodata__sqlmesh-3166 +tobikodata__sqlmesh-3182 +tobikodata__sqlmesh-3446 +tobikodata__sqlmesh-3455 +tobikodata__sqlmesh-3457 +tobikodata__sqlmesh-3539 +tobikodata__sqlmesh-3654 +tobikodata__sqlmesh-4347 +toblerity__shapely-1090 +toblerity__shapely-1166 +toblerity__shapely-1174 +toblerity__shapely-1192 +toblerity__shapely-849 +toblerity__shapely-851 +toblerity__shapely-895 +toblerity__shapely-898 +tochemey__goakt-617 +tokio-rs__bytes-432 +tokio-rs__bytes-450 +tokio-rs__mio-1276 +tokio-rs__mio-1647 +tomarrell__lbadd-131 +tomarrell__lbadd-149 +tomarrell__lbadd-150 +tomarrell__lbadd-154 +tomarrell__lbadd-170 +tomarrell__lbadd-206 +tomarrell__lbadd-65 +tomarrell__lbadd-86 +tomekpiotrowski__lets_expect-38 +tomekpiotrowski__lets_expect-60 +tomekpiotrowski__lets_expect-84 +tomplus__kubernetes_asyncio-254 +tomplus__kubernetes_asyncio-258 +tomplus__kubernetes_asyncio-330 +tomplus__kubernetes_asyncio-331 +tomplus__kubernetes_asyncio-347 +tomplus__kubernetes_asyncio-61 +tomwhite__cubed-200 +tomwhite__cubed-209 +tomwhite__cubed-211 +tomwhite__cubed-257 +tomwhite__cubed-289 +tomwhite__cubed-303 +tomwhite__cubed-346 +tomwhite__cubed-368 +tomwright__dasel-192 +tootsdk__tootsdk-247 +tootsdk__tootsdk-301 +topolvm__topolvm-1006 +topolvm__topolvm-723 +topolvm__topolvm-892 +tornadoweb__tornado-2081 +tornadoweb__tornado-2162 +tornadoweb__tornado-3436 +tornadoweb__tornado-3477 +tornadoweb__tornado-3488 +tornadoweb__tornado-3489 +tornadoweb__tornado-3503 +tornadoweb__tornado-3521 +tortoise__aerich-427 +tox-dev__pipdeptree-171 +tox-dev__pipdeptree-195 +tox-dev__pipdeptree-239 +tox-dev__pipdeptree-240 +tox-dev__pipdeptree-273 +tox-dev__pipdeptree-274 +tox-dev__pipdeptree-279 +tox-dev__pipdeptree-310 +tox-dev__pipdeptree-318 +tox-dev__pipdeptree-342 +tox-dev__pipdeptree-345 +tox-dev__pipdeptree-357 +tox-dev__pipdeptree-366 +tox-dev__pipdeptree-373 +tox-dev__pipdeptree-394 +tox-dev__pipdeptree-429 +tox-dev__pipdeptree-488 +tox-dev__sphinx-autodoc-typehints-171 +tox-dev__sphinx-autodoc-typehints-191 +tox-dev__sphinx-autodoc-typehints-199 +tox-dev__sphinx-autodoc-typehints-208 +tox-dev__sphinx-autodoc-typehints-279 +tox-dev__sphinx-autodoc-typehints-287 +tox-dev__sphinx-autodoc-typehints-294 +tox-dev__sphinx-autodoc-typehints-299 +tox-dev__sphinx-autodoc-typehints-307 +tox-dev__sphinx-autodoc-typehints-309 +tox-dev__sphinx-autodoc-typehints-316 +tox-dev__sphinx-autodoc-typehints-319 +tox-dev__sphinx-autodoc-typehints-399 +tox-dev__sphinx-autodoc-typehints-418 +tox-dev__sphinx-autodoc-typehints-422 +tox-dev__sphinx-autodoc-typehints-445 +tox-dev__sphinx-autodoc-typehints-468 +tox-dev__sphinx-autodoc-typehints-474 +tox-dev__sphinx-autodoc-typehints-482 +tox-dev__sphinx-autodoc-typehints-537 +tox-dev__sphinx-autodoc-typehints-538 +tox-dev__tox-1098 +tox-dev__tox-381 +tox-dev__tox-391 +tox-dev__tox-392 +tox-dev__tox-591 +tox-dev__tox-628 +tox-dev__tox-992 +tqdm__tqdm-1055 +tqdm__tqdm-270 +tqdm__tqdm-292 +tqdm__tqdm-378 +tqdm__tqdm-49 +tqdm__tqdm-535 +tqdm__tqdm-537 +tqdm__tqdm-592 +tqdm__tqdm-617 +tqdm__tqdm-63 +tqdm__tqdm-799 +tqdm__tqdm-822 +tqdm__tqdm-850 +tqdm__tqdm-86 +tradingview__lightweight-charts-118 +tradingview__lightweight-charts-168 +tradingview__lightweight-charts-269 +tradingview__lightweight-charts-755 +trailofbits__pip-audit-12 +trailofbits__pip-audit-162 +trailofbits__pip-audit-175 +trailofbits__pip-audit-228 +trailofbits__pip-audit-249 +trailofbits__pip-audit-359 +trailofbits__pip-audit-95 +trailsjs__trails-193 +trailsjs__trails-203 +trailsjs__trails-271 +trailsjs__trails-317 +traptitech__neoshowcase-491 +triggermesh__aws-event-sources-152 +triggermesh__aws-event-sources-331 +trikoder__oauth2-bundle-199 +trinodb__trino-python-client-564 +true-myth__true-myth-1051 +true-myth__true-myth-959 +trustwallet__blockatlas-1329 +trustwallet__blockatlas-1407 +tursodatabase__libsql-790 +tv-labs__lua-30 +tv-labs__lua-36 +tv-labs__lua-41 +tv-labs__lua-42 +tv-labs__lua-65 +twbs__bootlint-392 +tweag__fawltydeps-224 +tweag__fawltydeps-242 +tweag__fawltydeps-365 +tweag__fawltydeps-394 +tweag__fawltydeps-469 +tweag__fawltydeps-479 +tweag__fawltydeps-492 +tweag__fawltydeps-495 +tweag__nickel-1879 +tweag__nickel-1883 +tweag__nickel-2000 +tweag__nickel-2042 +tweag__nickel-363 +twigjs__twig.js-850 +twigjs__twig.js-873 +twigjs__twig.js-879 +twigjs__twig.js-881 +twigjs__twig.js-911 +twigphp__twig-3344 +twigphp__twig-3617 +twigphp__twig-3622 +twigphp__twig-3654 +twigphp__twig-3671 +twigphp__twig-3704 +twigphp__twig-3957 +twigphp__twig-3961 +twigphp__twig-4023 +twigphp__twig-4044 +twigphp__twig-4049 +twigphp__twig-4081 +twigphp__twig-4083 +twigphp__twig-4091 +twigphp__twig-4131 +twigphp__twig-4178 +twigphp__twig-4187 +twigphp__twig-4212 +twigphp__twig-4221 +twigphp__twig-4237 +twigphp__twig-4286 +twigphp__twig-4301 +twigphp__twig-4304 +twigphp__twig-4310 +twigphp__twig-4318 +twigphp__twig-4334 +twigphp__twig-4336 +twigphp__twig-4338 +twigphp__twig-4339 +twigphp__twig-4340 +twigphp__twig-4341 +twigphp__twig-4342 +twigphp__twig-4349 +twigphp__twig-4352 +twigphp__twig-4359 +twigphp__twig-4367 +twigphp__twig-4378 +twigphp__twig-4391 +twigphp__twig-4441 +twigphp__twig-4475 +twigphp__twig-4496 +twigphp__twig-4500 +twigphp__twig-4501 +twigphp__twig-4511 +twigphp__twig-4519 +twigphp__twig-4536 +twigphp__twig-4548 +twigphp__twig-4565 +twigphp__twig-4583 +twilio-labs__serverless-toolkit-392 +twilio-labs__serverless-toolkit-462 +twin__gatus-221 +twisted__pydoctor-191 +twisted__pydoctor-196 +twisted__pydoctor-307 +twisted__pydoctor-309 +twisted__pydoctor-491 +twisted__pydoctor-502 +twisted__pydoctor-515 +twisted__towncrier-696 +twisted__treq-385 +twisted__treq-400 +twitch-apis__twitch-js-104 +twitch-apis__twitch-js-126 +twitch-apis__twitch-js-139 +twitch-apis__twitch-js-143 +twitch-apis__twitch-js-159 +twmb__franz-go-1044 +twmb__franz-go-963 +twpayne__chezmoi-1032 +twpayne__chezmoi-1034 +twpayne__chezmoi-29 +txtdirect__txtdirect-345 +tyktechnologies__tyk-6855 +typedorm__typedorm-111 +typedorm__typedorm-114 +typedorm__typedorm-127 +typedorm__typedorm-129 +typedorm__typedorm-130 +typedorm__typedorm-136 +typedorm__typedorm-140 +typedorm__typedorm-147 +typedorm__typedorm-15 +typedorm__typedorm-151 +typedorm__typedorm-155 +typedorm__typedorm-160 +typedorm__typedorm-161 +typedorm__typedorm-166 +typedorm__typedorm-170 +typedorm__typedorm-172 +typedorm__typedorm-196 +typedorm__typedorm-242 +typedorm__typedorm-243 +typedorm__typedorm-246 +typedorm__typedorm-25 +typedorm__typedorm-26 +typedorm__typedorm-262 +typedorm__typedorm-32 +typedorm__typedorm-326 +typedorm__typedorm-331 +typedorm__typedorm-47 +typedorm__typedorm-48 +typedorm__typedorm-57 +typedorm__typedorm-59 +typedorm__typedorm-63 +typedorm__typedorm-65 +typedorm__typedorm-76 +typedorm__typedorm-77 +typedorm__typedorm-91 +typescript-eslint__tslint-to-eslint-config-1060 +typescript-eslint__tslint-to-eslint-config-1066 +typescript-eslint__tslint-to-eslint-config-1067 +typescript-eslint__tslint-to-eslint-config-1068 +typescript-eslint__tslint-to-eslint-config-1070 +typescript-eslint__tslint-to-eslint-config-1144 +typescript-eslint__tslint-to-eslint-config-1151 +typescript-eslint__tslint-to-eslint-config-122 +typescript-eslint__tslint-to-eslint-config-124 +typescript-eslint__tslint-to-eslint-config-126 +typescript-eslint__tslint-to-eslint-config-1370 +typescript-eslint__tslint-to-eslint-config-1397 +typescript-eslint__tslint-to-eslint-config-1467 +typescript-eslint__tslint-to-eslint-config-1468 +typescript-eslint__tslint-to-eslint-config-1719 +typescript-eslint__tslint-to-eslint-config-190 +typescript-eslint__tslint-to-eslint-config-192 +typescript-eslint__tslint-to-eslint-config-194 +typescript-eslint__tslint-to-eslint-config-195 +typescript-eslint__tslint-to-eslint-config-196 +typescript-eslint__tslint-to-eslint-config-197 +typescript-eslint__tslint-to-eslint-config-198 +typescript-eslint__tslint-to-eslint-config-199 +typescript-eslint__tslint-to-eslint-config-201 +typescript-eslint__tslint-to-eslint-config-203 +typescript-eslint__tslint-to-eslint-config-205 +typescript-eslint__tslint-to-eslint-config-222 +typescript-eslint__tslint-to-eslint-config-223 +typescript-eslint__tslint-to-eslint-config-227 +typescript-eslint__tslint-to-eslint-config-235 +typescript-eslint__tslint-to-eslint-config-237 +typescript-eslint__tslint-to-eslint-config-242 +typescript-eslint__tslint-to-eslint-config-246 +typescript-eslint__tslint-to-eslint-config-248 +typescript-eslint__tslint-to-eslint-config-255 +typescript-eslint__tslint-to-eslint-config-258 +typescript-eslint__tslint-to-eslint-config-262 +typescript-eslint__tslint-to-eslint-config-265 +typescript-eslint__tslint-to-eslint-config-273 +typescript-eslint__tslint-to-eslint-config-276 +typescript-eslint__tslint-to-eslint-config-281 +typescript-eslint__tslint-to-eslint-config-282 +typescript-eslint__tslint-to-eslint-config-283 +typescript-eslint__tslint-to-eslint-config-284 +typescript-eslint__tslint-to-eslint-config-291 +typescript-eslint__tslint-to-eslint-config-297 +typescript-eslint__tslint-to-eslint-config-304 +typescript-eslint__tslint-to-eslint-config-305 +typescript-eslint__tslint-to-eslint-config-308 +typescript-eslint__tslint-to-eslint-config-314 +typescript-eslint__tslint-to-eslint-config-332 +typescript-eslint__tslint-to-eslint-config-334 +typescript-eslint__tslint-to-eslint-config-336 +typescript-eslint__tslint-to-eslint-config-348 +typescript-eslint__tslint-to-eslint-config-405 +typescript-eslint__tslint-to-eslint-config-408 +typescript-eslint__tslint-to-eslint-config-409 +typescript-eslint__tslint-to-eslint-config-412 +typescript-eslint__tslint-to-eslint-config-418 +typescript-eslint__tslint-to-eslint-config-419 +typescript-eslint__tslint-to-eslint-config-424 +typescript-eslint__tslint-to-eslint-config-443 +typescript-eslint__tslint-to-eslint-config-444 +typescript-eslint__tslint-to-eslint-config-446 +typescript-eslint__tslint-to-eslint-config-536 +typescript-eslint__tslint-to-eslint-config-586 +typescript-eslint__tslint-to-eslint-config-637 +typescript-eslint__tslint-to-eslint-config-648 +typescript-eslint__tslint-to-eslint-config-650 +typescript-eslint__tslint-to-eslint-config-707 +typescript-eslint__tslint-to-eslint-config-712 +typescript-eslint__tslint-to-eslint-config-731 +typescript-eslint__tslint-to-eslint-config-755 +typescript-eslint__tslint-to-eslint-config-798 +typescript-eslint__tslint-to-eslint-config-837 +typescript-eslint__tslint-to-eslint-config-860 +typescript-eslint__tslint-to-eslint-config-861 +typescript-eslint__tslint-to-eslint-config-864 +typestack__class-validator-1025 +typestack__class-validator-1612 +typestack__class-validator-1687 +typestack__class-validator-1692 +typestack__class-validator-1785 +typestack__class-validator-1794 +typestack__class-validator-2196 +typestack__class-validator-600 +typestack__class-validator-673 +typst__hayagriva-257 +typst__hayagriva-273 +typst__hayagriva-287 +typst__hayagriva-334 +ua-parser__uap-core-458 +ua-parser__uap-core-536 +ua-parser__uap-core-591 +ua-parser__uap-core-592 +uber-go__dig-282 +uber-go__dig-322 +uber-go__dig-329 +uber-go__fx-1032 +uber-go__fx-1053 +uber-go__fx-1068 +uber-go__fx-1154 +uber-go__fx-1215 +uber-go__fx-771 +uber-go__fx-789 +uber-go__fx-795 +uber-go__fx-802 +uber-go__fx-813 +uber-go__fx-872 +uber-go__fx-931 +uber-go__fx-982 +uber-web__baseui-1173 +uber-web__baseui-1286 +uber-web__baseui-1560 +uber-web__baseui-1645 +uber-web__baseui-1663 +uber-web__baseui-977 +uber__cadence-3080 +uber__causalml-844 +uber__makisu-219 +uber__makisu-250 +uber__makisu-269 +uber__makisu-309 +uber__makisu-326 +uber__prototool-347 +uber__prototool-416 +ubilabs__react-geosuggest-509 +ucan-lab__laravel-dacapo-147 +ucan-lab__laravel-dacapo-176 +ucan-lab__laravel-dacapo-183 +ucan-lab__laravel-dacapo-199 +ucan-lab__laravel-dacapo-203 +ucfopen__canvasapi-352 +ucfopen__canvasapi-355 +ucfopen__canvasapi-467 +ucfopen__canvasapi-503 +ucfopen__canvasapi-527 +ucfopen__canvasapi-571 +ucfopen__canvasapi-673 +un-ts__eslint-plugin-import-x-209 +un-ts__eslint-plugin-import-x-393 +un-ts__prettier-455 +un-ts__prettier-472 +un-ts__synckit-145 +un-ts__synckit-184 +un-ts__synckit-199 +un-ts__synckit-208 +un-ts__synckit-211 +un-ts__synckit-213 +unexpectedjs__unexpected-571 +unexpectedjs__unexpected-581 +unexpectedjs__unexpected-651 +ungarj__mapchete-466 +ungarj__mapchete-683 +ungarj__mapchete-685 +unidata__netcdf-c-1298 +unidata__netcdf-c-1301 +unidata__netcdf-c-1523 +unidata__netcdf-c-1525 +unidata__netcdf-c-1528 +unidata__netcdf-c-1530 +unidata__netcdf-c-1564 +unidata__netcdf-c-1570 +unidata__netcdf-c-1662 +unidata__netcdf-c-1674 +unidata__netcdf-c-1692 +unidata__netcdf-c-1781 +unidata__netcdf-c-1828 +unidata__netcdf-c-1959 +unidata__netcdf-c-2065 +unidata__siphon-855 +unidoc__unidoc-258 +unidoc__unidoc-336 +unidoc__unidoc-338 +unidoc__unidoc-360 +unjs__h3-409 +unjs__h3-421 +unjs__h3-422 +unjs__h3-476 +unjs__h3-479 +unjs__h3-482 +unjs__h3-556 +unjs__h3-564 +unjs__h3-577 +unjs__h3-612 +unjs__h3-618 +unjs__h3-641 +unjs__h3-756 +unjs__h3-974 +unjs__h3-981 +unjs__ufo-48 +unjs__ufo-68 +unleash__unleash-client-go-143 +unleash__unleash-client-java-177 +unleash__unleash-client-java-211 +unleash__unleash-client-java-41 +unleash__unleash-client-java-46 +unleash__unleash-client-java-50 +unleash__unleash-client-java-87 +unleash__unleash-client-python-157 +unleash__unleash-client-python-206 +unleash__unleash-client-python-218 +unleash__unleash-client-python-223 +unleash__unleash-client-python-285 +unleash__unleash-client-python-357 +urfave__cli-1078 +urfave__cli-1083 +urfave__cli-1390 +urfave__cli-1448 +urfave__cli-1640 +urfave__cli-1645 +urfave__cli-1671 +urfave__cli-1673 +urql-graphql__urql-2999 +urql-graphql__urql-3051 +urql-graphql__urql-3131 +urql-graphql__urql-3165 +urql-graphql__urql-3167 +urql-graphql__urql-3169 +urql-graphql__urql-3196 +urql-graphql__urql-3200 +urql-graphql__urql-3224 +urql-graphql__urql-3229 +urql-graphql__urql-3356 +urql-graphql__urql-3363 +urql-graphql__urql-3371 +urql-graphql__urql-3442 +urql-graphql__urql-3505 +urql-graphql__urql-3573 +urql-graphql__urql-3650 +urql-graphql__urql-3703 +useblocks__sphinx-needs-1101 +useblocks__sphinx-needs-1102 +useblocks__sphinx-needs-1428 +usebruno__bruno-2991 +userfront__userfront-core-105 +userfront__userfront-core-111 +userfront__userfront-core-123 +userfront__userfront-core-139 +userfront__userfront-core-15 +userfront__userfront-core-17 +userfront__userfront-core-22 +userfront__userfront-core-25 +userfront__userfront-core-26 +userfront__userfront-core-35 +userfront__userfront-core-50 +userfront__userfront-core-52 +userfront__userfront-core-55 +userfront__userfront-core-71 +userfront__userfront-core-78 +userfront__userfront-core-82 +userfront__userfront-core-84 +userfront__userfront-core-86 +userfront__userfront-core-89 +userfront__userfront-core-97 +v2fly__v2ray-core-3101 +v2fly__v2ray-core-3103 +vacanza__holidays-2052 +vacanza__holidays-2092 +vacanza__holidays-2106 +vacanza__holidays-2197 +vacanza__holidays-2354 +vacanza__holidays-2386 +vacanza__holidays-2409 +vacanza__holidays-2442 +vacanza__holidays-2463 +vacanza__holidays-2487 +vacanza__holidays-2502 +vacanza__holidays-2521 +vacanza__holidays-2525 +vacanza__holidays-2529 +vacanza__holidays-2532 +vacanza__holidays-2631 +vacanza__holidays-2700 +vacanza__holidays-2714 +vacanza__holidays-2720 +vacanza__holidays-2727 +vacanza__holidays-2737 +vackosar__gitflow-incremental-builder-146 +vackosar__gitflow-incremental-builder-151 +vackosar__gitflow-incremental-builder-152 +vackosar__gitflow-incremental-builder-158 +vackosar__gitflow-incremental-builder-160 +vackosar__gitflow-incremental-builder-168 +vackosar__gitflow-incremental-builder-174 +vackosar__gitflow-incremental-builder-249 +vackosar__gitflow-incremental-builder-287 +validatorjs__validator.js-1191 +validatorjs__validator.js-1227 +validatorjs__validator.js-1306 +validatorjs__validator.js-1312 +validatorjs__validator.js-1419 +validatorjs__validator.js-1546 +validatorjs__validator.js-1566 +validatorjs__validator.js-1623 +validatorjs__validator.js-1679 +validatorjs__validator.js-1689 +validatorjs__validator.js-1711 +validatorjs__validator.js-1714 +validatorjs__validator.js-1715 +validatorjs__validator.js-1809 +validatorjs__validator.js-1810 +validatorjs__validator.js-1813 +validatorjs__validator.js-1844 +validatorjs__validator.js-2046 +validatorjs__validator.js-2112 +validatorjs__validator.js-2122 +validatorjs__validator.js-2134 +validatorjs__validator.js-2136 +validatorjs__validator.js-2197 +validatorjs__validator.js-2237 +validatorjs__validator.js-2345 +validatorjs__validator.js-2514 +validatorjs__validator.js-2553 +valyala__fasthttp-2011 +vanilla-extract-css__vanilla-extract-1036 +vanilla-extract-css__vanilla-extract-1054 +vanilla-extract-css__vanilla-extract-1254 +vanilla-extract-css__vanilla-extract-996 +vanus-labs__vanus-434 +vanus-labs__vanus-455 +vanus-labs__vanus-458 +vanus-labs__vanus-472 +vanvalenlab__deepcell-tf-673 +vapor__jwt-kit-150 +vapor__jwt-kit-177 +vapor__jwt-kit-187 +vapor__jwt-kit-82 +vapor__multipart-kit-66 +vapor__multipart-kit-71 +vaskoz__dailycodingproblem-go-10 +vaskoz__dailycodingproblem-go-102 +vaskoz__dailycodingproblem-go-104 +vaskoz__dailycodingproblem-go-106 +vaskoz__dailycodingproblem-go-108 +vaskoz__dailycodingproblem-go-111 +vaskoz__dailycodingproblem-go-115 +vaskoz__dailycodingproblem-go-116 +vaskoz__dailycodingproblem-go-117 +vaskoz__dailycodingproblem-go-12 +vaskoz__dailycodingproblem-go-120 +vaskoz__dailycodingproblem-go-122 +vaskoz__dailycodingproblem-go-125 +vaskoz__dailycodingproblem-go-126 +vaskoz__dailycodingproblem-go-128 +vaskoz__dailycodingproblem-go-131 +vaskoz__dailycodingproblem-go-133 +vaskoz__dailycodingproblem-go-137 +vaskoz__dailycodingproblem-go-140 +vaskoz__dailycodingproblem-go-142 +vaskoz__dailycodingproblem-go-144 +vaskoz__dailycodingproblem-go-146 +vaskoz__dailycodingproblem-go-148 +vaskoz__dailycodingproblem-go-150 +vaskoz__dailycodingproblem-go-154 +vaskoz__dailycodingproblem-go-158 +vaskoz__dailycodingproblem-go-16 +vaskoz__dailycodingproblem-go-160 +vaskoz__dailycodingproblem-go-162 +vaskoz__dailycodingproblem-go-164 +vaskoz__dailycodingproblem-go-170 +vaskoz__dailycodingproblem-go-172 +vaskoz__dailycodingproblem-go-174 +vaskoz__dailycodingproblem-go-176 +vaskoz__dailycodingproblem-go-178 +vaskoz__dailycodingproblem-go-18 +vaskoz__dailycodingproblem-go-182 +vaskoz__dailycodingproblem-go-186 +vaskoz__dailycodingproblem-go-188 +vaskoz__dailycodingproblem-go-190 +vaskoz__dailycodingproblem-go-193 +vaskoz__dailycodingproblem-go-195 +vaskoz__dailycodingproblem-go-199 +vaskoz__dailycodingproblem-go-20 +vaskoz__dailycodingproblem-go-201 +vaskoz__dailycodingproblem-go-202 +vaskoz__dailycodingproblem-go-206 +vaskoz__dailycodingproblem-go-207 +vaskoz__dailycodingproblem-go-208 +vaskoz__dailycodingproblem-go-210 +vaskoz__dailycodingproblem-go-213 +vaskoz__dailycodingproblem-go-215 +vaskoz__dailycodingproblem-go-216 +vaskoz__dailycodingproblem-go-218 +vaskoz__dailycodingproblem-go-22 +vaskoz__dailycodingproblem-go-220 +vaskoz__dailycodingproblem-go-222 +vaskoz__dailycodingproblem-go-224 +vaskoz__dailycodingproblem-go-228 +vaskoz__dailycodingproblem-go-233 +vaskoz__dailycodingproblem-go-239 +vaskoz__dailycodingproblem-go-24 +vaskoz__dailycodingproblem-go-241 +vaskoz__dailycodingproblem-go-243 +vaskoz__dailycodingproblem-go-244 +vaskoz__dailycodingproblem-go-249 +vaskoz__dailycodingproblem-go-250 +vaskoz__dailycodingproblem-go-256 +vaskoz__dailycodingproblem-go-26 +vaskoz__dailycodingproblem-go-261 +vaskoz__dailycodingproblem-go-262 +vaskoz__dailycodingproblem-go-264 +vaskoz__dailycodingproblem-go-266 +vaskoz__dailycodingproblem-go-268 +vaskoz__dailycodingproblem-go-269 +vaskoz__dailycodingproblem-go-271 +vaskoz__dailycodingproblem-go-276 +vaskoz__dailycodingproblem-go-277 +vaskoz__dailycodingproblem-go-279 +vaskoz__dailycodingproblem-go-28 +vaskoz__dailycodingproblem-go-281 +vaskoz__dailycodingproblem-go-283 +vaskoz__dailycodingproblem-go-289 +vaskoz__dailycodingproblem-go-290 +vaskoz__dailycodingproblem-go-293 +vaskoz__dailycodingproblem-go-295 +vaskoz__dailycodingproblem-go-296 +vaskoz__dailycodingproblem-go-30 +vaskoz__dailycodingproblem-go-300 +vaskoz__dailycodingproblem-go-306 +vaskoz__dailycodingproblem-go-307 +vaskoz__dailycodingproblem-go-308 +vaskoz__dailycodingproblem-go-310 +vaskoz__dailycodingproblem-go-317 +vaskoz__dailycodingproblem-go-318 +vaskoz__dailycodingproblem-go-319 +vaskoz__dailycodingproblem-go-32 +vaskoz__dailycodingproblem-go-321 +vaskoz__dailycodingproblem-go-323 +vaskoz__dailycodingproblem-go-328 +vaskoz__dailycodingproblem-go-330 +vaskoz__dailycodingproblem-go-332 +vaskoz__dailycodingproblem-go-337 +vaskoz__dailycodingproblem-go-338 +vaskoz__dailycodingproblem-go-339 +vaskoz__dailycodingproblem-go-34 +vaskoz__dailycodingproblem-go-341 +vaskoz__dailycodingproblem-go-344 +vaskoz__dailycodingproblem-go-349 +vaskoz__dailycodingproblem-go-350 +vaskoz__dailycodingproblem-go-351 +vaskoz__dailycodingproblem-go-354 +vaskoz__dailycodingproblem-go-357 +vaskoz__dailycodingproblem-go-361 +vaskoz__dailycodingproblem-go-366 +vaskoz__dailycodingproblem-go-368 +vaskoz__dailycodingproblem-go-369 +vaskoz__dailycodingproblem-go-370 +vaskoz__dailycodingproblem-go-372 +vaskoz__dailycodingproblem-go-374 +vaskoz__dailycodingproblem-go-38 +vaskoz__dailycodingproblem-go-380 +vaskoz__dailycodingproblem-go-383 +vaskoz__dailycodingproblem-go-384 +vaskoz__dailycodingproblem-go-385 +vaskoz__dailycodingproblem-go-389 +vaskoz__dailycodingproblem-go-390 +vaskoz__dailycodingproblem-go-392 +vaskoz__dailycodingproblem-go-394 +vaskoz__dailycodingproblem-go-396 +vaskoz__dailycodingproblem-go-398 +vaskoz__dailycodingproblem-go-40 +vaskoz__dailycodingproblem-go-402 +vaskoz__dailycodingproblem-go-403 +vaskoz__dailycodingproblem-go-406 +vaskoz__dailycodingproblem-go-407 +vaskoz__dailycodingproblem-go-410 +vaskoz__dailycodingproblem-go-412 +vaskoz__dailycodingproblem-go-414 +vaskoz__dailycodingproblem-go-416 +vaskoz__dailycodingproblem-go-418 +vaskoz__dailycodingproblem-go-420 +vaskoz__dailycodingproblem-go-422 +vaskoz__dailycodingproblem-go-425 +vaskoz__dailycodingproblem-go-429 +vaskoz__dailycodingproblem-go-430 +vaskoz__dailycodingproblem-go-433 +vaskoz__dailycodingproblem-go-435 +vaskoz__dailycodingproblem-go-437 +vaskoz__dailycodingproblem-go-438 +vaskoz__dailycodingproblem-go-440 +vaskoz__dailycodingproblem-go-442 +vaskoz__dailycodingproblem-go-444 +vaskoz__dailycodingproblem-go-446 +vaskoz__dailycodingproblem-go-448 +vaskoz__dailycodingproblem-go-450 +vaskoz__dailycodingproblem-go-451 +vaskoz__dailycodingproblem-go-455 +vaskoz__dailycodingproblem-go-456 +vaskoz__dailycodingproblem-go-457 +vaskoz__dailycodingproblem-go-459 +vaskoz__dailycodingproblem-go-46 +vaskoz__dailycodingproblem-go-461 +vaskoz__dailycodingproblem-go-463 +vaskoz__dailycodingproblem-go-466 +vaskoz__dailycodingproblem-go-468 +vaskoz__dailycodingproblem-go-471 +vaskoz__dailycodingproblem-go-474 +vaskoz__dailycodingproblem-go-476 +vaskoz__dailycodingproblem-go-478 +vaskoz__dailycodingproblem-go-48 +vaskoz__dailycodingproblem-go-480 +vaskoz__dailycodingproblem-go-484 +vaskoz__dailycodingproblem-go-486 +vaskoz__dailycodingproblem-go-488 +vaskoz__dailycodingproblem-go-490 +vaskoz__dailycodingproblem-go-494 +vaskoz__dailycodingproblem-go-495 +vaskoz__dailycodingproblem-go-496 +vaskoz__dailycodingproblem-go-497 +vaskoz__dailycodingproblem-go-499 +vaskoz__dailycodingproblem-go-50 +vaskoz__dailycodingproblem-go-500 +vaskoz__dailycodingproblem-go-504 +vaskoz__dailycodingproblem-go-505 +vaskoz__dailycodingproblem-go-507 +vaskoz__dailycodingproblem-go-509 +vaskoz__dailycodingproblem-go-511 +vaskoz__dailycodingproblem-go-513 +vaskoz__dailycodingproblem-go-515 +vaskoz__dailycodingproblem-go-518 +vaskoz__dailycodingproblem-go-52 +vaskoz__dailycodingproblem-go-520 +vaskoz__dailycodingproblem-go-522 +vaskoz__dailycodingproblem-go-524 +vaskoz__dailycodingproblem-go-526 +vaskoz__dailycodingproblem-go-527 +vaskoz__dailycodingproblem-go-532 +vaskoz__dailycodingproblem-go-535 +vaskoz__dailycodingproblem-go-536 +vaskoz__dailycodingproblem-go-54 +vaskoz__dailycodingproblem-go-545 +vaskoz__dailycodingproblem-go-546 +vaskoz__dailycodingproblem-go-549 +vaskoz__dailycodingproblem-go-550 +vaskoz__dailycodingproblem-go-551 +vaskoz__dailycodingproblem-go-552 +vaskoz__dailycodingproblem-go-554 +vaskoz__dailycodingproblem-go-557 +vaskoz__dailycodingproblem-go-558 +vaskoz__dailycodingproblem-go-56 +vaskoz__dailycodingproblem-go-562 +vaskoz__dailycodingproblem-go-564 +vaskoz__dailycodingproblem-go-567 +vaskoz__dailycodingproblem-go-569 +vaskoz__dailycodingproblem-go-571 +vaskoz__dailycodingproblem-go-573 +vaskoz__dailycodingproblem-go-576 +vaskoz__dailycodingproblem-go-58 +vaskoz__dailycodingproblem-go-581 +vaskoz__dailycodingproblem-go-582 +vaskoz__dailycodingproblem-go-584 +vaskoz__dailycodingproblem-go-588 +vaskoz__dailycodingproblem-go-591 +vaskoz__dailycodingproblem-go-592 +vaskoz__dailycodingproblem-go-595 +vaskoz__dailycodingproblem-go-6 +vaskoz__dailycodingproblem-go-60 +vaskoz__dailycodingproblem-go-604 +vaskoz__dailycodingproblem-go-606 +vaskoz__dailycodingproblem-go-608 +vaskoz__dailycodingproblem-go-610 +vaskoz__dailycodingproblem-go-614 +vaskoz__dailycodingproblem-go-617 +vaskoz__dailycodingproblem-go-619 +vaskoz__dailycodingproblem-go-620 +vaskoz__dailycodingproblem-go-621 +vaskoz__dailycodingproblem-go-623 +vaskoz__dailycodingproblem-go-624 +vaskoz__dailycodingproblem-go-625 +vaskoz__dailycodingproblem-go-627 +vaskoz__dailycodingproblem-go-630 +vaskoz__dailycodingproblem-go-632 +vaskoz__dailycodingproblem-go-634 +vaskoz__dailycodingproblem-go-636 +vaskoz__dailycodingproblem-go-638 +vaskoz__dailycodingproblem-go-64 +vaskoz__dailycodingproblem-go-641 +vaskoz__dailycodingproblem-go-643 +vaskoz__dailycodingproblem-go-646 +vaskoz__dailycodingproblem-go-652 +vaskoz__dailycodingproblem-go-653 +vaskoz__dailycodingproblem-go-655 +vaskoz__dailycodingproblem-go-657 +vaskoz__dailycodingproblem-go-659 +vaskoz__dailycodingproblem-go-667 +vaskoz__dailycodingproblem-go-672 +vaskoz__dailycodingproblem-go-677 +vaskoz__dailycodingproblem-go-678 +vaskoz__dailycodingproblem-go-68 +vaskoz__dailycodingproblem-go-680 +vaskoz__dailycodingproblem-go-683 +vaskoz__dailycodingproblem-go-690 +vaskoz__dailycodingproblem-go-691 +vaskoz__dailycodingproblem-go-70 +vaskoz__dailycodingproblem-go-710 +vaskoz__dailycodingproblem-go-713 +vaskoz__dailycodingproblem-go-715 +vaskoz__dailycodingproblem-go-717 +vaskoz__dailycodingproblem-go-722 +vaskoz__dailycodingproblem-go-726 +vaskoz__dailycodingproblem-go-727 +vaskoz__dailycodingproblem-go-729 +vaskoz__dailycodingproblem-go-730 +vaskoz__dailycodingproblem-go-731 +vaskoz__dailycodingproblem-go-732 +vaskoz__dailycodingproblem-go-733 +vaskoz__dailycodingproblem-go-734 +vaskoz__dailycodingproblem-go-735 +vaskoz__dailycodingproblem-go-736 +vaskoz__dailycodingproblem-go-737 +vaskoz__dailycodingproblem-go-74 +vaskoz__dailycodingproblem-go-741 +vaskoz__dailycodingproblem-go-744 +vaskoz__dailycodingproblem-go-746 +vaskoz__dailycodingproblem-go-749 +vaskoz__dailycodingproblem-go-751 +vaskoz__dailycodingproblem-go-755 +vaskoz__dailycodingproblem-go-759 +vaskoz__dailycodingproblem-go-761 +vaskoz__dailycodingproblem-go-763 +vaskoz__dailycodingproblem-go-765 +vaskoz__dailycodingproblem-go-767 +vaskoz__dailycodingproblem-go-769 +vaskoz__dailycodingproblem-go-771 +vaskoz__dailycodingproblem-go-773 +vaskoz__dailycodingproblem-go-775 +vaskoz__dailycodingproblem-go-777 +vaskoz__dailycodingproblem-go-779 +vaskoz__dailycodingproblem-go-784 +vaskoz__dailycodingproblem-go-786 +vaskoz__dailycodingproblem-go-788 +vaskoz__dailycodingproblem-go-790 +vaskoz__dailycodingproblem-go-792 +vaskoz__dailycodingproblem-go-794 +vaskoz__dailycodingproblem-go-798 +vaskoz__dailycodingproblem-go-80 +vaskoz__dailycodingproblem-go-800 +vaskoz__dailycodingproblem-go-802 +vaskoz__dailycodingproblem-go-806 +vaskoz__dailycodingproblem-go-807 +vaskoz__dailycodingproblem-go-808 +vaskoz__dailycodingproblem-go-809 +vaskoz__dailycodingproblem-go-810 +vaskoz__dailycodingproblem-go-813 +vaskoz__dailycodingproblem-go-82 +vaskoz__dailycodingproblem-go-822 +vaskoz__dailycodingproblem-go-86 +vaskoz__dailycodingproblem-go-872 +vaskoz__dailycodingproblem-go-88 +vaskoz__dailycodingproblem-go-89 +vaskoz__dailycodingproblem-go-904 +vaskoz__dailycodingproblem-go-92 +vaskoz__dailycodingproblem-go-94 +vaskoz__dailycodingproblem-go-946 +vaskoz__dailycodingproblem-go-950 +vaskoz__dailycodingproblem-go-957 +vaskoz__dailycodingproblem-go-96 +vazco__uniforms-1363 +vazco__uniforms-346 +vazco__uniforms-672 +vazco__uniforms-687 +vazco__uniforms-695 +vazco__uniforms-725 +vazco__uniforms-733 +vega__ts-json-schema-generator-2230 +vega__ts-json-schema-generator-2305 +vega__vega-lite-671 +vega__vega-lite-685 +vega__vega-lite-702 +vega__vega-lite-720 +vegaprotocol__go-wallet-241 +vegaprotocol__vegawallet-359 +vegaprotocol__vegawallet-361 +vegaprotocol__vegawallet-367 +vegaprotocol__vegawallet-368 +vegaprotocol__vegawallet-372 +vegaprotocol__vegawallet-383 +vegaprotocol__vegawallet-405 +vegaprotocol__vegawallet-409 +vegaprotocol__vegawallet-410 +vegaprotocol__vegawallet-423 +vegaprotocol__vegawallet-435 +vegaprotocol__vegawallet-450 +vegaprotocol__vegawallet-505 +vegaprotocol__vegawallet-552 +vegaprotocol__vegawallet-560 +vendure-ecommerce__ngx-translate-extract-45 +vendure-ecommerce__ngx-translate-extract-46 +vendure-ecommerce__ngx-translate-extract-51 +vendure-ecommerce__ngx-translate-extract-53 +vendure-ecommerce__ngx-translate-extract-55 +vendure-ecommerce__ngx-translate-extract-60 +vendure-ecommerce__ngx-translate-extract-61 +versent__saml2aws-1006 +verygoodopensource__very_good_cli-1261 +verygoodopensource__very_good_cli-1285 +verygoodopensource__very_good_cli-130 +verygoodopensource__very_good_cli-148 +verygoodopensource__very_good_cli-154 +verygoodopensource__very_good_cli-155 +verygoodopensource__very_good_cli-600 +verygoodopensource__very_good_cli-647 +verygoodopensource__very_good_cli-739 +verygoodopensource__very_good_cli-777 +verygoodopensource__very_good_cli-814 +verygoodopensource__very_good_cli-920 +verygoodopensource__very_good_cli-922 +vgteam__sequencetubemap-188 +vgteam__sequencetubemap-307 +vgteam__sequencetubemap-336 +vgteam__sequencetubemap-346 +vgteam__sequencetubemap-366 +vgteam__sequencetubemap-376 +vgteam__sequencetubemap-380 +vgteam__sequencetubemap-387 +vgteam__sequencetubemap-393 +vgteam__sequencetubemap-399 +vhdl-ls__rust_hdl-272 +vhdl-ls__rust_hdl-306 +vhdl-ls__rust_hdl-319 +vhdl-ls__rust_hdl-326 +vhdl-ls__rust_hdl-330 +vhdl-ls__rust_hdl-336 +vhdl-ls__rust_hdl-371 +viacominc__data-point-148 +viacominc__data-point-150 +viacominc__data-point-151 +viacominc__data-point-173 +viacominc__data-point-183 +viacominc__data-point-191 +viacominc__data-point-193 +viacominc__data-point-194 +viacominc__data-point-203 +viacominc__data-point-21 +viacominc__data-point-212 +viacominc__data-point-214 +viacominc__data-point-218 +viacominc__data-point-220 +viacominc__data-point-228 +viacominc__data-point-232 +viacominc__data-point-234 +viacominc__data-point-251 +viacominc__data-point-26 +viacominc__data-point-283 +viacominc__data-point-286 +viacominc__data-point-316 +viacominc__data-point-318 +viacominc__data-point-329 +viacominc__data-point-33 +viacominc__data-point-341 +viacominc__data-point-35 +viacominc__data-point-387 +viacominc__data-point-417 +viacominc__data-point-420 +viacominc__data-point-425 +viacominc__data-point-438 +viacominc__data-point-452 +viacominc__data-point-494 +viacominc__data-point-67 +victoravelar__mollie-api-go-159 +victoravelar__mollie-api-go-16 +victoravelar__mollie-api-go-29 +victoravelar__mollie-api-go-30 +victoravelar__mollie-api-go-37 +victoravelar__mollie-api-go-38 +victoravelar__mollie-api-go-41 +victoravelar__mollie-api-go-435 +victoravelar__mollie-api-go-44 +victoravelar__mollie-api-go-84 +victoriametrics__victoriametrics-8938 +video-dev__hls.js-5366 +video-dev__hls.js-5502 +video-dev__hls.js-6007 +video-dev__hls.js-6141 +video-dev__hls.js-6692 +video-dev__hls.js-6760 +video-dev__hls.js-6857 +video-dev__hls.js-6951 +video-dev__hls.js-7045 +video-dev__hls.js-7048 +video-dev__hls.js-7124 +vigetlabs__microcosm-355 +vigetlabs__microcosm-364 +vigetlabs__microcosm-385 +vigetlabs__microcosm-406 +vigetlabs__microcosm-486 +vincentlanglet__twig-cs-fixer-217 +vincentlanglet__twig-cs-fixer-236 +vincentlanglet__twig-cs-fixer-239 +vincentlanglet__twig-cs-fixer-247 +vincentlanglet__twig-cs-fixer-259 +vincentlanglet__twig-cs-fixer-264 +vincentlanglet__twig-cs-fixer-323 +violentmonkey__violentmonkey-2224 +virtual-kubelet__virtual-kubelet-685 +virtuslab__git-machete-179 +virtuslab__git-machete-248 +virtuslab__git-machete-330 +virtuslab__git-machete-348 +virtuslab__git-machete-350 +virtuslab__git-machete-353 +virtuslab__git-machete-354 +virtuslab__git-machete-463 +virtuslab__git-machete-487 +virtuslab__git-machete-525 +virtuslab__git-machete-534 +virtuslab__git-machete-828 +vitalik__django-ninja-1185 +vitalik__django-ninja-228 +vitalik__django-ninja-687 +vitessio__vitess-11419 +vitessio__vitess-12213 +vkcom__noverify-1142 +vlucas__frisby-373 +vlucas__frisby-417 +vlucas__frisby-426 +vlucas__frisby-431 +vlucas__frisby-457 +vlucas__frisby-479 +vlucas__frisby-511 +vmware-labs__reconciler-runtime-213 +vmware-labs__reconciler-runtime-221 +vmware-labs__reconciler-runtime-232 +vmware-labs__reconciler-runtime-288 +vmware-labs__reconciler-runtime-304 +vmware-tanzu__carvel-imgpkg-435 +vmware-tanzu__carvel-imgpkg-440 +vmware-tanzu__carvel-imgpkg-443 +vmware-tanzu__pinniped-1122 +vmware-tanzu__pinniped-645 +vmware-tanzu__vm-operator-78 +vmware__govmomi-1734 +vmware__govmomi-1737 +vmware__govmomi-2017 +vmware__govmomi-2111 +vmware__govmomi-2137 +vmware__govmomi-2226 +vmware__govmomi-2274 +vmware__govmomi-2814 +vmware__govmomi-3104 +vmware__govmomi-3277 +vmware__govmomi-3390 +vmware__govmomi-3399 +vmware__govmomi-3462 +vmware__govmomi-3518 +vmware__govmomi-3524 +vmware__govmomi-3628 +vmware__govmomi-3632 +vmware__tern-250 +vmware__tern-255 +vmware__tern-259 +vmware__tern-295 +vmware__tern-355 +vmware__tern-359 +vmware__tern-360 +vmware__tern-453 +vmware__tern-460 +volkovlabs__volkovlabs-dynamictext-panel-196 +volkovlabs__volkovlabs-dynamictext-panel-280 +volkovlabs__volkovlabs-dynamictext-panel-281 +volkovlabs__volkovlabs-dynamictext-panel-338 +volta-cli__volta-1292 +volta-cli__volta-1755 +vscode-neovim__vscode-neovim-2140 +vshn__k8up-164 +vshn__k8up-186 +vsiakka__gherkin-lint-52 +vsiakka__gherkin-lint-85 +vue-a11y__eslint-plugin-vuejs-accessibility-13 +vue-a11y__eslint-plugin-vuejs-accessibility-146 +vue-a11y__eslint-plugin-vuejs-accessibility-26 +vue-a11y__eslint-plugin-vuejs-accessibility-27 +vue-a11y__eslint-plugin-vuejs-accessibility-40 +vue-a11y__eslint-plugin-vuejs-accessibility-58 +vue-a11y__eslint-plugin-vuejs-accessibility-86 +vue-a11y__eslint-plugin-vuejs-accessibility-87 +vue-gl__vue-gl-989 +vuejs__composition-api-520 +vuejs__composition-api-531 +vuejs__composition-api-532 +vuejs__composition-api-546 +vuejs__composition-api-547 +vuejs__composition-api-548 +vuejs__composition-api-551 +vuejs__composition-api-584 +vuejs__composition-api-622 +vuejs__composition-api-655 +vuejs__composition-api-660 +vuejs__composition-api-692 +vuejs__composition-api-717 +vuejs__composition-api-722 +vuejs__composition-api-730 +vuejs__composition-api-732 +vuejs__composition-api-760 +vuejs__composition-api-791 +vuejs__composition-api-799 +vuejs__composition-api-808 +vuejs__eslint-plugin-vue-1001 +vuejs__eslint-plugin-vue-1015 +vuejs__eslint-plugin-vue-1016 +vuejs__eslint-plugin-vue-1019 +vuejs__eslint-plugin-vue-1071 +vuejs__eslint-plugin-vue-1086 +vuejs__eslint-plugin-vue-1144 +vuejs__eslint-plugin-vue-1162 +vuejs__eslint-plugin-vue-1166 +vuejs__eslint-plugin-vue-1187 +vuejs__eslint-plugin-vue-1192 +vuejs__eslint-plugin-vue-1222 +vuejs__eslint-plugin-vue-1232 +vuejs__eslint-plugin-vue-1238 +vuejs__eslint-plugin-vue-1255 +vuejs__eslint-plugin-vue-1267 +vuejs__eslint-plugin-vue-1289 +vuejs__eslint-plugin-vue-1367 +vuejs__eslint-plugin-vue-1389 +vuejs__eslint-plugin-vue-1400 +vuejs__eslint-plugin-vue-1401 +vuejs__eslint-plugin-vue-1469 +vuejs__eslint-plugin-vue-1525 +vuejs__eslint-plugin-vue-1586 +vuejs__eslint-plugin-vue-1626 +vuejs__eslint-plugin-vue-1644 +vuejs__eslint-plugin-vue-1707 +vuejs__eslint-plugin-vue-1712 +vuejs__eslint-plugin-vue-1713 +vuejs__eslint-plugin-vue-1718 +vuejs__eslint-plugin-vue-1725 +vuejs__eslint-plugin-vue-1736 +vuejs__eslint-plugin-vue-1760 +vuejs__eslint-plugin-vue-1771 +vuejs__eslint-plugin-vue-1790 +vuejs__eslint-plugin-vue-1804 +vuejs__eslint-plugin-vue-1811 +vuejs__eslint-plugin-vue-1822 +vuejs__eslint-plugin-vue-1854 +vuejs__eslint-plugin-vue-2013 +vuejs__eslint-plugin-vue-2019 +vuejs__eslint-plugin-vue-2024 +vuejs__eslint-plugin-vue-2045 +vuejs__eslint-plugin-vue-2073 +vuejs__eslint-plugin-vue-2194 +vuejs__eslint-plugin-vue-2198 +vuejs__eslint-plugin-vue-2204 +vuejs__eslint-plugin-vue-2210 +vuejs__eslint-plugin-vue-2213 +vuejs__eslint-plugin-vue-2222 +vuejs__eslint-plugin-vue-2229 +vuejs__eslint-plugin-vue-2268 +vuejs__eslint-plugin-vue-2280 +vuejs__eslint-plugin-vue-2293 +vuejs__eslint-plugin-vue-2301 +vuejs__eslint-plugin-vue-2320 +vuejs__eslint-plugin-vue-2334 +vuejs__eslint-plugin-vue-2487 +vuejs__eslint-plugin-vue-2489 +vuejs__eslint-plugin-vue-2494 +vuejs__eslint-plugin-vue-2505 +vuejs__eslint-plugin-vue-2537 +vuejs__eslint-plugin-vue-2554 +vuejs__eslint-plugin-vue-2595 +vuejs__eslint-plugin-vue-2598 +vuejs__eslint-plugin-vue-2609 +vuejs__eslint-plugin-vue-2610 +vuejs__eslint-plugin-vue-2611 +vuejs__eslint-plugin-vue-2617 +vuejs__eslint-plugin-vue-2639 +vuejs__eslint-plugin-vue-2684 +vuejs__eslint-plugin-vue-2685 +vuejs__eslint-plugin-vue-2736 +vuejs__eslint-plugin-vue-32 +vuejs__eslint-plugin-vue-647 +vuejs__eslint-plugin-vue-843 +vuejs__vue-next-4959 +vuejs__vue-next-4978 +vuejs__vue-next-4979 +vuejs__vue-next-4985 +vuejs__vue-next-5017 +vuejs__vue-next-5026 +vuepress__vuepress-next-1264 +vuepress__vuepress-next-1314 +vuepress__vuepress-next-1421 +vuepress__vuepress-next-1452 +vulpemventures__marina-505 +vyperlang__vyper-2677 +vyperlang__vyper-2784 +vyperlang__vyper-2805 +vyperlang__vyper-2821 +vyperlang__vyper-2828 +vyperlang__vyper-2834 +vyperlang__vyper-2871 +vyperlang__vyper-2877 +vyperlang__vyper-2880 +vyperlang__vyper-2887 +vyperlang__vyper-2911 +vyperlang__vyper-3008 +vyperlang__vyper-3010 +vyperlang__vyper-3023 +vyperlang__vyper-3030 +vyperlang__vyper-3035 +vyperlang__vyper-3057 +vyperlang__vyper-3061 +vyperlang__vyper-3079 +vyperlang__vyper-3156 +vyperlang__vyper-3157 +vyperlang__vyper-3160 +vyperlang__vyper-3174 +vyperlang__vyper-3187 +vyperlang__vyper-3235 +vyperlang__vyper-3240 +vyperlang__vyper-3242 +vyperlang__vyper-3261 +vyperlang__vyper-3264 +vyperlang__vyper-3266 +vyperlang__vyper-3276 +vyperlang__vyper-3288 +vyperlang__vyper-3303 +vyperlang__vyper-3307 +vyperlang__vyper-3333 +vyperlang__vyper-3375 +vyperlang__vyper-3398 +vyperlang__vyper-3473 +vyperlang__vyper-3529 +vyperlang__vyper-3605 +vyperlang__vyper-3805 +vyperlang__vyper-4271 +vyperlang__vyper-4550 +vyperlang__vyper-4677 +w3c__webidl2.js-105 +w3c__webidl2.js-106 +w3c__webidl2.js-108 +w3c__webidl2.js-110 +w3c__webidl2.js-129 +w3c__webidl2.js-171 +w3c__webidl2.js-173 +w3c__webidl2.js-177 +w3c__webidl2.js-185 +w3c__webidl2.js-229 +w3c__webidl2.js-232 +w3c__webidl2.js-87 +wafflespeanut__paperclip-272 +wal-g__wal-g-1319 +wal-g__wal-g-593 +wal-g__wal-g-702 +wangguanquan__eec-136 +wangguanquan__eec-162 +warner__python-ecdsa-191 +warpdesign__react-explorer-129 +warpnet__salt-lint-207 +warpnet__salt-lint-209 +warpnet__salt-lint-210 +warpnet__salt-lint-213 +warpnet__salt-lint-214 +warpnet__salt-lint-231 +warpnet__salt-lint-272 +warpnet__salt-lint-274 +warpnet__salt-lint-284 +washingtonpost__ans-schema-112 +washingtonpost__ans-schema-123 +washingtonpost__ans-schema-129 +washingtonpost__ans-schema-88 +washingtonpost__ans-schema-90 +washingtonpost__ans-schema-94 +washingtonpost__ans-schema-96 +weaveworks__eksctl-1705 +weaveworks__eksctl-1902 +weaveworks__eksctl-1957 +weaveworks__eksctl-2004 +weaveworks__eksctl-2055 +weaveworks__eksctl-2660 +weaveworks__eksctl-2852 +weaveworks__eksctl-3146 +weaveworks__eksctl-3205 +weaveworks__eksctl-3232 +weaveworks__eksctl-3339 +weaveworks__eksctl-3515 +weaveworks__eksctl-3693 +weaveworks__eksctl-3810 +weaveworks__eksctl-3899 +weaveworks__eksctl-3942 +weaveworks__eksctl-3962 +weaveworks__eksctl-3989 +weaveworks__eksctl-4065 +weaveworks__eksctl-4128 +weaveworks__eksctl-4209 +weaveworks__eksctl-4220 +weaveworks__eksctl-4290 +weaveworks__eksctl-4331 +weaveworks__eksctl-4401 +weaveworks__eksctl-4629 +weaveworks__eksctl-4688 +weaveworks__eksctl-4737 +weaveworks__eksctl-4782 +weaveworks__eksctl-4809 +weaveworks__eksctl-4922 +weaveworks__eksctl-4928 +weaveworks__eksctl-5055 +weaveworks__eksctl-5136 +weaveworks__eksctl-5201 +weaveworks__eksctl-5287 +weaveworks__eksctl-5357 +weaveworks__eksctl-5369 +weaveworks__eksctl-5543 +weaveworks__eksctl-5623 +weaveworks__eksctl-5627 +weaveworks__eksctl-5634 +weaveworks__eksctl-5643 +weaveworks__eksctl-5678 +weaveworks__eksctl-5735 +weaveworks__eksctl-5929 +weaveworks__eksctl-6038 +weaveworks__eksctl-6094 +weaveworks__eksctl-6100 +weaveworks__flagger-492 +weaveworks__flagger-715 +weaveworks__flux-2211 +weaviate__weaviate-4104 +web-push-libs__web-push-404 +web-push-libs__web-push-456 +web-push-libs__web-push-458 +web-push-libs__web-push-841 +web-scrobbler__web-scrobbler-3804 +web-scrobbler__web-scrobbler-4667 +webonyx__graphql-php-1068 +webonyx__graphql-php-1180 +webonyx__graphql-php-1365 +webonyx__graphql-php-1372 +webonyx__graphql-php-1382 +webpack-contrib__compression-webpack-plugin-144 +webpack-contrib__compression-webpack-plugin-159 +webpack-contrib__compression-webpack-plugin-212 +webpack-contrib__copy-webpack-plugin-333 +webpack-contrib__copy-webpack-plugin-338 +webpack-contrib__copy-webpack-plugin-341 +webpack-contrib__copy-webpack-plugin-375 +webpack-contrib__copy-webpack-plugin-420 +webpack-contrib__copy-webpack-plugin-448 +webpack-contrib__copy-webpack-plugin-475 +webpack-contrib__copy-webpack-plugin-477 +webpack-contrib__copy-webpack-plugin-524 +webpack-contrib__copy-webpack-plugin-541 +webpack-contrib__copy-webpack-plugin-590 +webpack-contrib__css-loader-1035 +webpack-contrib__css-loader-1036 +webpack-contrib__css-loader-1065 +webpack-contrib__css-loader-1069 +webpack-contrib__css-loader-1072 +webpack-contrib__css-loader-1108 +webpack-contrib__css-loader-1178 +webpack-contrib__css-loader-1196 +webpack-contrib__css-loader-1209 +webpack-contrib__css-loader-1219 +webpack-contrib__css-loader-1261 +webpack-contrib__css-loader-1324 +webpack-contrib__css-loader-1349 +webpack-contrib__css-loader-917 +webpack-contrib__css-loader-939 +webpack-contrib__css-loader-972 +webpack-contrib__mini-css-extract-plugin-640 +webpack-contrib__mini-css-extract-plugin-651 +webpack-contrib__mini-css-extract-plugin-685 +webpack-contrib__mini-css-extract-plugin-709 +webpack-contrib__mini-css-extract-plugin-817 +webpack-contrib__mini-css-extract-plugin-826 +webpack-contrib__mini-css-extract-plugin-844 +webpack-contrib__mini-css-extract-plugin-881 +webpack-contrib__source-map-loader-101 +webpack-contrib__source-map-loader-114 +webpack-contrib__source-map-loader-117 +webpack-contrib__source-map-loader-120 +webpack-contrib__style-loader-393 +webpack-contrib__style-loader-448 +webpack-contrib__style-loader-485 +webpack-contrib__style-loader-521 +webpack-contrib__style-loader-535 +webpack-contrib__uglifyjs-webpack-plugin-249 +webpack-contrib__uglifyjs-webpack-plugin-250 +webpack-contrib__uglifyjs-webpack-plugin-251 +webpack-contrib__uglifyjs-webpack-plugin-268 +webpack-contrib__uglifyjs-webpack-plugin-284 +webpack-contrib__uglifyjs-webpack-plugin-382 +webpack__enhanced-resolve-289 +webpack__enhanced-resolve-293 +webpack__enhanced-resolve-305 +webpack__enhanced-resolve-337 +webpack__enhanced-resolve-340 +webpack__enhanced-resolve-347 +webpack__enhanced-resolve-380 +webpack__enhanced-resolve-423 +websockets__ws-1471 +websockets__ws-1494 +websockets__ws-2160 +websockets__ws-2218 +websockets__ws-2229 +websockets__ws-945 +websockets__ws-956 +websockets__ws-971 +weld__weld-junit-106 +weld__weld-junit-133 +weld__weld-junit-23 +weld__weld-junit-27 +weld__weld-junit-35 +weld__weld-junit-38 +weld__weld-junit-5 +weld__weld-junit-51 +weld__weld-junit-75 +weld__weld-junit-88 +weld__weld-junit-94 +weld__weld-junit-98 +whatyouhide__redix-125 +whatyouhide__stream_data-11 +whatyouhide__stream_data-174 +whatyouhide__stream_data-57 +whatyouhide__stream_data-62 +wheresrhys__fetch-mock-824 +wheresrhys__fetch-mock-869 +wheresrhys__fetch-mock-913 +whitequark__ipaddr.js-141 +whitequark__ipaddr.js-163 +whitequark__ipaddr.js-174 +whitfin__cachex-292 +whitfin__cachex-294 +whitfin__cachex-338 +whitfin__cachex-339 +whitfin__cachex-341 +whitfin__cachex-343 +whitfin__cachex-354 +whitfin__cachex-360 +whitfin__cachex-362 +whitfin__cachex-372 +whitfin__cachex-374 +whitfin__cachex-375 +whitfin__cachex-378 +whitfin__cachex-392 +whitfin__cachex-403 +wicg__webpackage-394 +wikimedia-gadgets__twinkle-1504 +wikimedia-gadgets__twinkle-1523 +wikimedia-gadgets__twinkle-1524 +wikimedia-gadgets__twinkle-1544 +wikimedia-gadgets__twinkle-1597 +wikimedia-gadgets__twinkle-1601 +wikimedia-gadgets__twinkle-1602 +wikimedia-gadgets__twinkle-1616 +wikimedia-gadgets__twinkle-1960 +wikimedia-gadgets__twinkle-2030 +wikunia__constraintsolver.jl-227 +wikunia__javis.jl-107 +wikunia__javis.jl-37 +wikunia__javis.jl-54 +wikunia__javis.jl-69 +wikunia__javis.jl-71 +wilkerlucio__pathom-138 +winnow-rs__winnow-130 +withspectrum__draft-js-markdown-plugin-11 +withspectrum__draft-js-markdown-plugin-43 +withspectrum__draft-js-markdown-plugin-53 +wizardsardine__liana-957 +wntrblm__nox-627 +wntrblm__nox-639 +wntrblm__nox-641 +wntrblm__nox-647 +wntrblm__nox-688 +wntrblm__nox-730 +wntrblm__nox-756 +wntrblm__nox-795 +wntrblm__nox-798 +wntrblm__nox-804 +wntrblm__nox-807 +wntrblm__nox-809 +wntrblm__nox-815 +wntrblm__nox-829 +wntrblm__nox-900 +wntrblm__nox-901 +wntrblm__nox-903 +wntrblm__nox-906 +wntrblm__nox-913 +wntrblm__nox-922 +wntrblm__nox-932 +wntrblm__nox-933 +wntrblm__nox-935 +wntrblm__nox-941 +wntrblm__nox-957 +wojtekmach__req-100 +wojtekmach__req-444 +wojtekmach__req-67 +wojtekmach__req-70 +wojtekmach__req-92 +woodruffw__zizmor-337 +woodruffw__zizmor-340 +woodruffw__zizmor-570 +woodruffw__zizmor-616 +woodruffw__zizmor-621 +woodruffw__zizmor-640 +woodruffw__zizmor-644 +woodruffw__zizmor-660 +woodruffw__zizmor-664 +woodruffw__zizmor-683 +woodruffw__zizmor-750 +wordpress__wordpress-coding-standards-2056 +wordpress__wordpress-coding-standards-2121 +wordpress__wordpress-coding-standards-2145 +wordpress__wordpress-coding-standards-2146 +wordpress__wordpress-coding-standards-2186 +wordpress__wordpress-coding-standards-2187 +wordpress__wordpress-coding-standards-2197 +wordpress__wordpress-coding-standards-2237 +wordpress__wordpress-coding-standards-2266 +wordpress__wordpress-coding-standards-2289 +wordpress__wordpress-coding-standards-2297 +wordpress__wordpress-coding-standards-2362 +wordpress__wordpress-coding-standards-2392 +worksapplications__sudachi.rs-183 +worksapplications__sudachi.rs-190 +worksapplications__sudachi.rs-62 +woylie__doggo-195 +woylie__doggo-196 +woylie__doggo-379 +woylie__flop_phoenix-221 +woylie__flop_phoenix-245 +woylie__flop_phoenix-265 +woylie__flop_phoenix-279 +woylie__flop_phoenix-364 +woylie__flop_phoenix-406 +woylie__flop_phoenix-469 +wp-api__node-wpapi-416 +wtforms__wtforms-548 +wtforms__wtforms-551 +wtforms__wtforms-568 +wtforms__wtforms-582 +wtforms__wtforms-583 +wtforms__wtforms-592 +wtforms__wtforms-595 +wtforms__wtforms-596 +wtforms__wtforms-601 +wtforms__wtforms-605 +wtforms__wtforms-614 +wtforms__wtforms-615 +wtforms__wtforms-661 +wtforms__wtforms-688 +wtforms__wtforms-694 +wtforms__wtforms-721 +wtforms__wtforms-739 +wtforms__wtforms-765 +wtforms__wtforms-797 +wtforms__wtforms-808 +wtforms__wtforms-809 +wtforms__wtforms-823 +xampprocky__tokei-1096 +xampprocky__tokei-1175 +xampprocky__tokei-344 +xampprocky__tokei-346 +xampprocky__tokei-535 +xanzy__go-gitlab-2049 +xataio__client-ts-34 +xataio__client-ts-52 +xataio__pgstream-201 +xataio__pgstream-219 +xataio__pgstream-248 +xataio__pgstream-312 +xataio__pgstream-315 +xataio__pgstream-83 +xataio__pgstream-92 +xd009642__tarpaulin-1206 +xd009642__tarpaulin-904 +xd009642__tarpaulin-923 +xeqi__peridot-52 +xgcm__xgcm-250 +xgcm__xgcm-343 +xgcm__xgcm-348 +xgcm__xgcm-358 +xgcm__xgcm-435 +xgcm__xgcm-439 +xgcm__xgcm-451 +xgcm__xgcm-515 +xgcm__xgcm-615 +xico2k__laravel-vue-i18n-104 +xico2k__laravel-vue-i18n-109 +xico2k__laravel-vue-i18n-118 +xico2k__laravel-vue-i18n-146 +xico2k__laravel-vue-i18n-155 +xico2k__laravel-vue-i18n-156 +xico2k__laravel-vue-i18n-159 +xico2k__laravel-vue-i18n-191 +xico2k__laravel-vue-i18n-73 +xico2k__laravel-vue-i18n-88 +xjamundx__eslint-plugin-promise-30 +xjamundx__eslint-plugin-promise-39 +xjamundx__eslint-plugin-promise-51 +xjamundx__eslint-plugin-promise-71 +xjamundx__eslint-plugin-promise-99 +xknx__xknx-1008 +xknx__xknx-1031 +xknx__xknx-1066 +xknx__xknx-1074 +xknx__xknx-1190 +xknx__xknx-1199 +xknx__xknx-1204 +xknx__xknx-1227 +xknx__xknx-1277 +xknx__xknx-1466 +xknx__xknx-1502 +xknx__xknx-1567 +xknx__xknx-1572 +xknx__xknx-1617 +xknx__xknx-1642 +xknx__xknx-1663 +xknx__xknx-454 +xknx__xknx-469 +xknx__xknx-470 +xknx__xknx-472 +xknx__xknx-482 +xknx__xknx-485 +xknx__xknx-544 +xknx__xknx-572 +xknx__xknx-690 +xknx__xknx-822 +xknx__xknx-832 +xknx__xknx-910 +xknx__xknx-951 +xlsform__pyxform-418 +xlsform__pyxform-468 +xlsform__pyxform-478 +xlsform__pyxform-485 +xlsform__pyxform-487 +xlsform__pyxform-489 +xlsform__pyxform-538 +xlsform__pyxform-718 +xlsform__pyxform-719 +xlsform__pyxform-732 +xlsform__pyxform-734 +xlsform__pyxform-772 +xonsh__xonsh-4715 +xuperchain__xuperunion-601 +y2z__monolith-422 +y2z__monolith-452 +y2z__monolith-454 +yagoferrer__map-tools-152 +yagoferrer__map-tools-184 +yagoferrer__map-tools-191 +yamatoiizuka__palt-typesetting-118 +yamatoiizuka__palt-typesetting-210 +yamatoiizuka__palt-typesetting-212 +yamatoiizuka__palt-typesetting-215 +yamatoiizuka__palt-typesetting-218 +yamatoiizuka__palt-typesetting-336 +yamatoiizuka__palt-typesetting-339 +yamatoiizuka__palt-typesetting-77 +yamatoiizuka__palt-typesetting-94 +yannickcr__eslint-plugin-react-1011 +yannickcr__eslint-plugin-react-1051 +yannickcr__eslint-plugin-react-1086 +yannickcr__eslint-plugin-react-1089 +yannickcr__eslint-plugin-react-1093 +yannickcr__eslint-plugin-react-1106 +yannickcr__eslint-plugin-react-1250 +yannickcr__eslint-plugin-react-1256 +yannickcr__eslint-plugin-react-1260 +yannickcr__eslint-plugin-react-1302 +yannickcr__eslint-plugin-react-1340 +yannickcr__eslint-plugin-react-1370 +yannickcr__eslint-plugin-react-1527 +yannickcr__eslint-plugin-react-1539 +yannickcr__eslint-plugin-react-1547 +yannickcr__eslint-plugin-react-161 +yannickcr__eslint-plugin-react-1616 +yannickcr__eslint-plugin-react-1643 +yannickcr__eslint-plugin-react-1645 +yannickcr__eslint-plugin-react-1653 +yannickcr__eslint-plugin-react-1659 +yannickcr__eslint-plugin-react-1735 +yannickcr__eslint-plugin-react-1829 +yannickcr__eslint-plugin-react-1851 +yannickcr__eslint-plugin-react-1868 +yannickcr__eslint-plugin-react-1883 +yannickcr__eslint-plugin-react-1890 +yannickcr__eslint-plugin-react-1924 +yannickcr__eslint-plugin-react-2008 +yannickcr__eslint-plugin-react-223 +yannickcr__eslint-plugin-react-2643 +yannickcr__eslint-plugin-react-2673 +yannickcr__eslint-plugin-react-274 +yannickcr__eslint-plugin-react-2755 +yannickcr__eslint-plugin-react-2943 +yannickcr__eslint-plugin-react-2949 +yannickcr__eslint-plugin-react-2992 +yannickcr__eslint-plugin-react-430 +yannickcr__eslint-plugin-react-51 +yannickcr__eslint-plugin-react-586 +yannickcr__eslint-plugin-react-601 +yannickcr__eslint-plugin-react-602 +yannickcr__eslint-plugin-react-638 +yannickcr__eslint-plugin-react-644 +yannickcr__eslint-plugin-react-665 +yannickcr__eslint-plugin-react-676 +yannickcr__eslint-plugin-react-689 +yannickcr__eslint-plugin-react-705 +yannickcr__eslint-plugin-react-707 +yannickcr__eslint-plugin-react-719 +yannickcr__eslint-plugin-react-72 +yannickcr__eslint-plugin-react-722 +yannickcr__eslint-plugin-react-755 +yannickcr__eslint-plugin-react-768 +yannickcr__eslint-plugin-react-773 +yannickcr__eslint-plugin-react-78 +yannickcr__eslint-plugin-react-82 +yargs__yargs-1080 +yargs__yargs-1143 +yargs__yargs-1366 +yargs__yargs-1376 +yargs__yargs-1414 +yargs__yargs-548 +yargs__yargs-549 +yargs__yargs-740 +yargs__yargs-790 +yargs__yargs-864 +yargs__yargs-907 +yargs__yargs-962 +yargs__yargs-988 +yargs__yargs-parser-100 +yargs__yargs-parser-102 +yargs__yargs-parser-103 +yargs__yargs-parser-119 +yargs__yargs-parser-128 +yargs__yargs-parser-132 +yargs__yargs-parser-164 +yargs__yargs-parser-165 +yargs__yargs-parser-167 +yargs__yargs-parser-171 +yargs__yargs-parser-182 +yargs__yargs-parser-199 +yargs__yargs-parser-206 +yargs__yargs-parser-234 +yargs__yargs-parser-238 +yargs__yargs-parser-262 +yargs__yargs-parser-268 +yargs__yargs-parser-43 +yargs__yargs-parser-45 +yargs__yargs-parser-51 +yargs__yargs-parser-75 +yarpc__yab-300 +yelp__bravado-core-154 +yelp__bravado-core-165 +yelp__bravado-core-183 +yelp__bravado-core-191 +yelp__bravado-core-212 +yelp__bravado-core-218 +yelp__bravado-core-240 +yelp__bravado-core-34 +yelp__bravado-core-367 +yelp__bravado-core-372 +yelp__bravado-core-41 +yelp__bravado-core-44 +yelp__bravado-core-84 +yelp__mrjob-2155 +yelp__mrjob-2197 +ymrl__a11y-visualizer-113 +ymrl__a11y-visualizer-115 +ymrl__a11y-visualizer-142 +ymrl__a11y-visualizer-147 +ymrl__a11y-visualizer-41 +ymrl__a11y-visualizer-42 +yoctol__bottender-107 +yoctol__bottender-127 +yoctol__bottender-139 +yoctol__bottender-145 +yoctol__bottender-164 +yoctol__bottender-182 +yoctol__bottender-219 +yoctol__bottender-234 +yoctol__bottender-243 +yoctol__bottender-252 +yoctol__bottender-268 +yoctol__bottender-281 +yoctol__bottender-287 +yoctol__bottender-302 +yoctol__bottender-343 +yoctol__bottender-519 +yoctol__bottender-572 +yoctol__bottender-635 +yoctol__bottender-831 +yoctol__bottender-93 +yogthos__migratus-223 +yogthos__migratus-231 +yogthos__migratus-254 +yogthos__migratus-271 +yokecd__yoke-144 +yonahd__kor-324 +yonahd__kor-336 +yonahd__kor-362 +yonahd__kor-366 +yonahd__kor-403 +yshavit__mdq-115 +yshavit__mdq-130 +yshavit__mdq-159 +yshavit__mdq-172 +yshavit__mdq-175 +yshavit__mdq-185 +yshavit__mdq-189 +yshavit__mdq-252 +yshavit__mdq-289 +yshavit__mdq-309 +yshavit__mdq-371 +yshavit__mdq-391 +yshavit__mdq-86 +ysugimoto__falco-153 +ysugimoto__falco-460 +ysugimoto__falco-461 +yt-dlp__yt-dlp-12667 +yt-dlp__yt-dlp-12832 +yt-dlp__yt-dlp-12919 +yt-dlp__yt-dlp-13234 +yt-dlp__yt-dlp-13350 +yt-dlp__yt-dlp-13361 +yt-dlp__yt-dlp-13403 +yt-dlp__yt-dlp-13651 +yt-dlp__yt-dlp-1482 +yt-dlp__yt-dlp-4357 +yt-dlp__yt-dlp-4704 +yt-dlp__yt-dlp-7683 +yt-dlp__yt-dlp-7710 +yt-dlp__yt-dlp-7712 +yt-dlp__yt-dlp-7929 +yt-dlp__yt-dlp-9037 +yt-dlp__yt-dlp-9227 +yt-project__unyt-102 +yt-project__unyt-109 +yt-project__unyt-152 +yt-project__unyt-153 +yt-project__unyt-172 +yt-project__unyt-176 +yt-project__unyt-211 +yt-project__unyt-31 +yt-project__unyt-54 +yt-project__unyt-58 +yt-project__unyt-59 +yt-project__unyt-61 +yt-project__unyt-72 +yt-project__unyt-80 +yt-project__yt-4638 +yt-project__yt-5077 +yuin__gopher-lua-332 +yuin__gopher-lua-427 +yuin__gopher-lua-460 +yuin__gopher-lua-496 +yukinarit__pyserde-249 +yukinarit__pyserde-281 +yukinarit__pyserde-303 +yukinarit__pyserde-321 +yukinarit__pyserde-354 +yukinarit__pyserde-377 +yukinarit__pyserde-389 +yukinarit__pyserde-430 +yukinarit__pyserde-486 +yukinarit__pyserde-518 +yukinarit__pyserde-542 +yukinarit__pyserde-601 +yukinarit__pyserde-618 +yukinarit__pyserde-646 +yusukehosonuma__swiftprettyprint-92 +zalando-incubator__kube-ingress-aws-controller-523 +zalando__logbook-33 +zalando__logbook-56 +zalando__logbook-69 +zalando__logbook-76 +zalando__logbook-98 +zalando__patroni-1991 +zalando__patroni-2029 +zalando__patroni-2304 +zalando__patroni-2308 +zalando__patroni-2344 +zalando__patroni-2391 +zalando__patroni-2398 +zalando__patroni-2659 +zalando__patroni-2724 +zalando__patroni-2766 +zalando__patroni-2781 +zalando__patroni-2791 +zalando__patroni-3018 +zalando__zappr-242 +zalando__zappr-289 +zalando__zappr-294 +zalando__zappr-331 +zalando__zappr-333 +zalando__zappr-340 +zalando__zappr-439 +zalando__zappr-504 +zalando__zappr-509 +zalando__zappr-527 +zauberzeug__nicegui-2746 +zauberzeug__nicegui-4550 +zauberzeug__nicegui-625 +zcash__librustzcash-1213 +zcash__librustzcash-1585 +zcash__librustzcash-174 +zcashfoundation__frost-281 +zcashfoundation__frost-361 +zcashfoundation__frost-418 +zcashfoundation__frost-419 +zcashfoundation__frost-453 +zcashfoundation__frost-474 +zcashfoundation__frost-477 +zcashfoundation__frost-564 +zcashfoundation__frost-728 +zcashfoundation__frost-797 +zcashfoundation__frost-878 +zcashfoundation__zebra-8769 +zcashfoundation__zebra-8788 +zegl__kube-score-110 +zegl__kube-score-135 +zegl__kube-score-181 +zegl__kube-score-192 +zegl__kube-score-205 +zegl__kube-score-287 +zegl__kube-score-289 +zegl__kube-score-294 +zegl__kube-score-317 +zegl__kube-score-385 +zegl__kube-score-399 +zegl__kube-score-451 +zegl__kube-score-489 +zegl__kube-score-543 +zegl__kube-score-55 +zegl__kube-score-588 +zegl__kube-score-65 +zegl__kube-score-69 +zeit-ui__react-151 +zeit-ui__react-202 +zeit-ui__react-233 +zeit-ui__react-265 +zeit-ui__react-290 +zeit-ui__react-325 +zeit__swr-104 +zeit__swr-105 +zeit__swr-130 +zeit__swr-186 +zeit__swr-207 +zeit__swr-211 +zeit__swr-231 +zeit__swr-245 +zeit__swr-265 +zeit__swr-277 +zeit__swr-279 +zeit__swr-296 +zeit__swr-82 +zenstruck__foundry-804 +zestedesavoir__zmarkdown-248 +zestedesavoir__zmarkdown-253 +zgoat__goatcounter-489 +zh-lx__pinyin-pro-226 +zh-lx__pinyin-pro-231 +zh-lx__pinyin-pro-238 +zh-lx__pinyin-pro-240 +zh-lx__pinyin-pro-245 +zh-lx__pinyin-pro-248 +zh-lx__pinyin-pro-272 +zh-lx__pinyin-pro-276 +zh-lx__pinyin-pro-279 +zh-lx__pinyin-pro-287 +zhiburt__tabled-160 +zhiburt__tabled-21 +zhiburt__tabled-233 +zhiburt__tabled-24 +zhiburt__tabled-317 +zhiburt__tabled-320 +zhiburt__tabled-34 +zhiburt__tabled-364 +zhiburt__tabled-394 +zhiburt__tabled-397 +zhiburt__tabled-60 +zhiburt__tabled-70 +zhiburt__tabled-79 +zigpy__zha-device-handlers-2625 +zigpy__zha-device-handlers-2629 +zigpy__zha-device-handlers-2658 +zigpy__zha-device-handlers-2695 +zigpy__zha-device-handlers-2833 +zigpy__zha-device-handlers-2844 +zigpy__zha-device-handlers-3752 +zigpy__zha-device-handlers-4130 +zkat__miette-107 +zkat__miette-117 +zkat__miette-121 +zkat__miette-335 +zkat__miette-341 +zkat__miette-358 +zkat__miette-370 +zkat__miette-39 +zkat__miette-409 +zmap__zlint-299 +zoofio__flexx-232 +zoofio__flexx-236 +zoofio__flexx-290 +zoofio__flexx-328 +zooniverse__panoptes-front-end-4396 +zopefoundation__btrees-141 +zopefoundation__btrees-158 +zopefoundation__btrees-163 +zopefoundation__restrictedpython-272 +zopefoundation__restrictedpython-288 +zopefoundation__zodb-355 +zopefoundation__zope.interface-335 +zulip__zulip-terminal-1167 +zulip__zulip-terminal-1374 +zulip__zulip-terminal-1442 +zulip__zulip-terminal-1448 +zulip__zulip-terminal-1463 +zulip__zulip-terminal-1521 +zulko__moviepy-1768 +zulko__moviepy-2114 diff --git a/resources_servers/swe_rebench/diagnose_failures.py b/resources_servers/swe_rebench/diagnose_failures.py new file mode 100644 index 00000000000..d20a2b2f9ee --- /dev/null +++ b/resources_servers/swe_rebench/diagnose_failures.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Separate golden-patch failures caused by the sandbox from failures of the row itself. + +This exists because `evaluation_completed` does not answer the question. A build that is +OOM-killed, or a test suite that runs out of disk, still produces a parsed log and a verdict -- +the tests simply failed. That grades identically to a genuinely broken golden patch, so raising +the memory limit would silently change the "supported" set. + +The signatures below are read out of the captured test output, so a failure is attributed to +resources only on direct evidence, never inferred from the fact that it failed. + + python resources_servers/swe_rebench/diagnose_failures.py results/.../pass1_job_X.jsonl +""" + +from __future__ import annotations + +import argparse +import json +import sys +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +# Ordered: the first match wins, so the most specific cause is reported. +RESOURCE_SIGNATURES: tuple[tuple[str, tuple[str, ...]], ...] = ( + ( + "disk_full", + ("no space left on device", "enospc", "disk quota exceeded", "write error: no space"), + ), + ( + "oom", + ( + "out of memory", + "outofmemoryerror", + "cannot allocate memory", + "oom-kill", + "oom killed", + "killed process", + "memoryerror", + "signal: killed", + "runtime: out of memory", + "fatal error: out of memory", + "std::bad_alloc", + "exit status 137", + "javaheapspace", + "java heap space", + "gc overhead limit exceeded", + ), + ), + ( + "process_killed", + # A bare SIGKILL with no allocator message. Usually the cgroup OOM killer, but the + # evidence is weaker, so it is reported separately rather than folded into `oom`. + ("killed", "sigkill", "terminated by signal 9"), + ), + ( + "too_many_files", + ("too many open files", "emfile"), + ), + ( + "network", + # NOT "the sandbox has no internet" -- it does; Go, npm and composer all fetch + # successfully in the same sandboxes. This is an egress fault for one toolchain, most + # often a JVM on a dual-stack network preferring an IPv6 address it has no route to. + # Either way it is an environment problem, not evidence that the golden patch is wrong. + ( + "could not resolve host", + "connection refused", + "network is unreachable", + "temporary failure in name resolution", + "etimedout", + "econnreset", + "proxyconnect", + ), + ), +) + + +def classify_output(text: str) -> str | None: + """Return the resource cause evidenced in the output, or None.""" + lowered = text.lower() + for label, needles in RESOURCE_SIGNATURES: + if any(needle in lowered for needle in needles): + return label + return None + + +def _rows(path: Path): + with path.open(encoding="utf-8") as handle: + for line in handle: + line = line.strip() + if line: + try: + yield json.loads(line) + except json.JSONDecodeError: + continue + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("rollouts_jsonl", type=Path) + parser.add_argument( + "--timeout-s", + type=float, + default=1200.0, + help="The configured evaluation timeout; runs within --near of it are treated as timing out.", + ) + parser.add_argument("--near", type=float, default=0.9, help="Fraction of the timeout that counts as 'near'.") + parser.add_argument("--show", type=int, default=4, help="Example instance ids to print per cause.") + args = parser.parse_args() + + if not args.rollouts_jsonl.exists(): + print(f"no such file: {args.rollouts_jsonl}", file=sys.stderr) + return 2 + + total = 0 + resolved = 0 + failures: list[dict[str, Any]] = [] + durations: list[float] = [] + + for row in _rows(args.rollouts_jsonl): + total += 1 + duration = float(row.get("patch_verification_time_taken") or 0.0) + durations.append(duration) + if row.get("resolved"): + resolved += 1 + continue + failures.append(row) + + if total == 0: + print("no rows", file=sys.stderr) + return 2 + + causes: Counter[str] = Counter() + examples: dict[str, list[str]] = defaultdict(list) + by_language: dict[str, Counter[str]] = defaultdict(Counter) + + for row in failures: + instance_id = str(row.get("instance_id") or "?") + language = str(row.get("language") or "unknown") + duration = float(row.get("patch_verification_time_taken") or 0.0) + output = str(row.get("test_output") or "") + error = str(row.get("error") or "") + + if not row.get("evaluation_completed", False): + cause = "no_verdict" + elif duration >= args.timeout_s * args.near: + # Ran to (or near) the ceiling. With CPU requests well below limits this is the + # shape CPU starvation takes: the work is not wrong, it just never finished. + cause = "timeout" + elif (row.get("test_results") or {}).get("tests_observed", 0) == 0 and (row.get("test_results") is not None): + # The parser saw zero tests, so nothing ran: the build or setup died before the + # suite started. Parser-agnostic, and a different thing from "the tests failed". + # Most often dependency drift -- an image pinned months ago resolving today's + # packages, e.g. cargo pulling a crate that needs a newer edition than its + # toolchain supports. The golden patch is not implicated either way. + cause = classify_output(output + "\n" + error) or "no_tests_ran" + else: + cause = classify_output(output + "\n" + error) or "row_failure" + + causes[cause] += 1 + by_language[language][cause] += 1 + if len(examples[cause]) < args.show: + examples[cause].append(f"{instance_id} ({language}, {duration:.0f}s)") + + # Causes that are about the environment rather than the row. `no_tests_ran` is included: + # a suite that never started says nothing about whether the golden patch is correct. + resource_causes = { + "oom", + "disk_full", + "process_killed", + "too_many_files", + "network", + "timeout", + "no_verdict", + "no_tests_ran", + } + resource_total = sum(count for cause, count in causes.items() if cause in resource_causes) + + print(f"rows: {total} resolved: {resolved} ({100 * resolved / total:.1f}%) failures: {len(failures)}") + if durations: + ordered = sorted(durations) + p50 = ordered[len(ordered) // 2] + p95 = ordered[min(len(ordered) - 1, int(len(ordered) * 0.95))] + print( + f"verification seconds: p50={p50:.0f} p95={p95:.0f} max={ordered[-1]:.0f} (timeout {args.timeout_s:.0f})" + ) + print() + print("failure attribution:") + for cause, count in causes.most_common(): + marker = "ENV" if cause in resource_causes else "row" + share = 100 * count / max(len(failures), 1) + print(f" {cause:<16} {count:>5} ({share:5.1f}% of failures) [{marker}]") + for example in examples[cause]: + print(f" e.g. {example}") + + print() + if not failures: + print("VERDICT: no failures to attribute") + elif resource_total == 0: + print("VERDICT: no failure shows resource evidence — these look like genuine row failures.") + print(" Raising sandbox limits would not change the supported set.") + else: + share = 100 * resource_total / len(failures) + print( + f"VERDICT: {resource_total}/{len(failures)} failures ({share:.1f}%) show resource or environment evidence." + ) + print(" Raise the relevant limit and re-measure before treating these rows as broken.") + + if by_language: + print("\n per-language failure causes:") + for language, counts in sorted(by_language.items(), key=lambda kv: -sum(kv[1].values())): + summary = " ".join(f"{cause}={count}" for cause, count in counts.most_common()) + print(f" {language:<10} {summary}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/resources_servers/swe_rebench/log_parsers.py b/resources_servers/swe_rebench/log_parsers.py new file mode 100644 index 00000000000..99123d7f3ce --- /dev/null +++ b/resources_servers/swe_rebench/log_parsers.py @@ -0,0 +1,142 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Access to SWE-rebench's own test-log parsers. + +Each dataset row names the parser that reads its test output (``install_config.log_parser``), +and the dataset spans 34 of them across 20 languages. Reimplementing that set here would be a +standing correctness risk: a parser that drifts from upstream silently misreads test results and +turns a passing patch into a failure. + +So the upstream module is fetched and used directly. It is MIT licensed. It is fetched rather +than vendored because it is ~3.5k lines of third-party code whose only stable contract is the +``NAME_TO_PARSER`` mapping, and a stale copy is worse than an explicit dependency. +""" + +from __future__ import annotations + +import importlib.util +import os +import shutil +import subprocess +import sys +import time +from pathlib import Path +from types import ModuleType +from typing import Callable + + +UPSTREAM_REPO = "https://github.com/SWE-rebench/SWE-rebench-V2.git" +# Pinned so a parser change upstream cannot silently move scores between runs. Bump +# deliberately, and re-baseline when you do. +UPSTREAM_COMMIT = "main" + +# Upstream has moved this file between releases; accept both layouts rather than pinning one. +_PARSER_RELATIVE_PATHS = (Path("lib") / "agent" / "log_parsers.py", Path("agent") / "log_parsers.py") + +_MODULE: ModuleType | None = None + + +def _clone_locked(destination: Path, timeout_s: float = 600.0) -> None: + """Clone once across concurrent workers, using a mkdir lock. + + ``gym env start`` may bring several server workers up at once, and an unsynchronised clone + into a shared path yields a half-written tree that imports with a confusing error. + """ + if _parser_path(destination) is not None: + return + destination.parent.mkdir(parents=True, exist_ok=True) + lock_path = destination.parent / f".{destination.name}.clone.lockdir" + waited = 0.0 + while True: + try: + lock_path.mkdir() + break + except FileExistsError: + if _parser_path(destination) is not None: + return + if waited > timeout_s: + raise TimeoutError(f"timed out waiting for the SWE-rebench clone lock at {lock_path}") + time.sleep(2.0) + waited += 2.0 + try: + if _parser_path(destination) is not None: + return + shutil.rmtree(destination, ignore_errors=True) + subprocess.run( + ["git", "clone", "--depth", "1", UPSTREAM_REPO, str(destination)], + check=True, + capture_output=True, + ) + if UPSTREAM_COMMIT != "main": + subprocess.run(["git", "fetch", "--depth", "1", "origin", UPSTREAM_COMMIT], cwd=destination, check=True) + subprocess.run(["git", "checkout", UPSTREAM_COMMIT], cwd=destination, check=True) + finally: + shutil.rmtree(lock_path, ignore_errors=True) + + +def _parser_path(repo_dir: Path) -> Path | None: + for relative in _PARSER_RELATIVE_PATHS: + candidate = repo_dir / relative + if candidate.exists(): + return candidate + return None + + +def load_parsers(cache_dir: Path) -> ModuleType: + """Import upstream's ``log_parsers`` module, cloning it on first use.""" + global _MODULE + if _MODULE is not None: + return _MODULE + + repo_dir = Path(cache_dir) / "SWE-rebench-V2" + _clone_locked(repo_dir) + parser_path = _parser_path(repo_dir) + if parser_path is None: + raise FileNotFoundError(f"SWE-rebench log_parsers.py not found under {repo_dir}; upstream layout changed") + + # The module does `from lib.agent...`, so the repo root has to be importable. + added = [p for p in (str(repo_dir), str(repo_dir / "lib")) if p not in sys.path] + sys.path[:0] = added + try: + spec = importlib.util.spec_from_file_location("_swe_rebench_log_parsers", str(parser_path)) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + finally: + for path in added: + try: + sys.path.remove(path) + except ValueError: + pass + _MODULE = module + return module + + +def resolve_parser(name: str, cache_dir: Path) -> Callable[[str], dict[str, str]]: + """Return the named parser. + + Raises rather than falling back to a default: a wrong parser produces a plausible-looking + empty result, which grades as "no tests passed" and is indistinguishable from a real + failure. + """ + module = load_parsers(cache_dir) + parser = (getattr(module, "NAME_TO_PARSER", {}) or {}).get(name) or getattr(module, name, None) + if parser is None: + available = sorted(getattr(module, "NAME_TO_PARSER", {}) or {}) + raise KeyError(f"unknown SWE-rebench log parser {name!r}; upstream exposes {len(available)}: {available[:8]}…") + return parser + + +def default_cache_dir() -> Path: + return Path(os.environ.get("NEMO_GYM_CACHE_DIR") or (Path.home() / ".cache" / "nemo_gym")) / "swe_rebench" diff --git a/resources_servers/swe_rebench/requirements.txt b/resources_servers/swe_rebench/requirements.txt new file mode 100644 index 00000000000..b34952e1093 --- /dev/null +++ b/resources_servers/swe_rebench/requirements.txt @@ -0,0 +1,3 @@ +-e nemo-gym[dev,sandbox] @ ../.. +# The upstream SWE-rebench log parsers are fetched at runtime (see log_parsers.py) and import +# only the standard library, so nothing extra is pinned here. diff --git a/resources_servers/swe_rebench/tests/__init__.py b/resources_servers/swe_rebench/tests/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/swe_rebench/tests/test_app.py b/resources_servers/swe_rebench/tests/test_app.py new file mode 100644 index 00000000000..ea441f5daba --- /dev/null +++ b/resources_servers/swe_rebench/tests/test_app.py @@ -0,0 +1,559 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tests for the SWE-rebench-V2 resources server's grading and script construction. + +These cover the parts that decide whether a task counts as resolved. The sandbox lifecycle +itself is exercised by the golden-patch run, which needs a live OpenSandbox endpoint. +""" + +from types import SimpleNamespace + +import pytest + +from resources_servers.swe_rebench.verification import ( + TEST_OUTPUT_BEGIN, + TEST_OUTPUT_END, + VerificationInputs, + as_command_list, + build_eval_script, + grade, + normalize_test_name, + repo_directory, + run_verification, + slice_test_output, + verification_files, +) + + +def _inputs(**overrides) -> VerificationInputs: + base = dict( + instance_id="elastic__synthetics-316", + repo="elastic/synthetics", + base_commit="f52f0bf", + patch="diff --git a/a b/a\n", + test_patch="diff --git a/t b/t\n", + install=["npm ci --quiet"], + test_cmd=["npm run test:unit"], + log_parser="parse_log_js_4", + fail_to_pass=["run journey - failed on beforeAll"], + pass_to_pass=["log to specified fd"], + ) + base.update(overrides) + return VerificationInputs(**base) + + +class TestRepoDirectory: + def test_uses_the_repo_name_not_the_owner(self) -> None: + # The images check out at /; using the owner would cd into a missing path + # and every task would fail identically. + assert repo_directory("elastic/synthetics") == "/synthetics" + + def test_tolerates_a_bare_repo_name(self) -> None: + assert repo_directory("synthetics") == "/synthetics" + + +class TestCommandList: + @pytest.mark.parametrize( + "value,expected", + [ + ("npm test", ["npm test"]), + (["a", "b"], ["a", "b"]), + (None, []), + ("", []), + ], + ) + def test_accepts_both_dataset_spellings(self, value, expected) -> None: + """install/test_cmd are a string in some rows and a list in others.""" + assert as_command_list(value) == expected + + +class TestNormalizeTestName: + @pytest.mark.parametrize( + "raw,expected", + [ + ("suite > case [123 ms]", "suite > case"), + ("suite > case (1.5 s)", "suite > case"), + ("test_thing in 2.0 sec", "test_thing"), + ("plain name", "plain name"), + ], + ) + def test_strips_per_run_timings(self, raw, expected) -> None: + """The expectation and the observed name otherwise differ only by a duration.""" + assert normalize_test_name(raw) == expected + + +class TestSliceTestOutput: + def test_keeps_only_the_graded_region(self) -> None: + log = f"installing deps\nFAILED bogus\n{TEST_OUTPUT_BEGIN}\nPASSED real\n{TEST_OUTPUT_END}\ncleanup" + sliced = slice_test_output(log) + assert "PASSED real" in sliced + # Install noise must not reach the parser: several parsers would read that FAILED line + # as a test result and grade a healthy run as broken. + assert "FAILED bogus" not in sliced + assert "cleanup" not in sliced + + def test_falls_back_to_the_whole_log_when_markers_are_absent(self) -> None: + assert slice_test_output("PASSED a") == "PASSED a" + + +class TestGrade: + def test_resolves_only_when_every_required_test_passes(self) -> None: + report = grade({"f2p": "PASSED", "p2p": "PASSED"}, ["f2p"], ["p2p"]) + assert report["resolved"] is True + + def test_a_failing_fail_to_pass_does_not_resolve(self) -> None: + report = grade({"f2p": "FAILED", "p2p": "PASSED"}, ["f2p"], ["p2p"]) + assert report["resolved"] is False + assert report["FAIL_TO_PASS"]["failure"] == ["f2p"] + + def test_a_regressed_pass_to_pass_does_not_resolve(self) -> None: + report = grade({"f2p": "PASSED", "p2p": "FAILED"}, ["f2p"], ["p2p"]) + assert report["resolved"] is False + + def test_a_missing_test_counts_as_not_passing(self) -> None: + """The important one: a broken test command reports nothing, and 'absent' must never + read as success or every such row scores as resolved.""" + report = grade({}, ["f2p"], ["p2p"]) + assert report["resolved"] is False + assert report["FAIL_TO_PASS"]["failure"] == ["f2p"] + assert report["tests_observed"] == 0 + + def test_timing_suffixes_do_not_break_matching(self) -> None: + report = grade({"case [12 ms]": "PASSED"}, ["case"], []) + assert report["resolved"] is True + + def test_skipped_is_not_passed(self) -> None: + assert grade({"f2p": "SKIPPED"}, ["f2p"], [])["resolved"] is False + + +class TestBuildEvalScript: + def test_runs_in_the_repo_directory_and_signals_a_missing_one(self) -> None: + script = build_eval_script(_inputs()) + # shlex.quote leaves a plain path bare, so assert the behaviour rather than the quoting. + assert "exit 97" in script + assert any(line.startswith("cd ") and "/synthetics" in line for line in script.splitlines()) + + def test_applies_both_patches_before_testing(self) -> None: + script = build_eval_script(_inputs()) + patch_at = script.index("nemo_gym_patch.diff") + test_patch_at = script.index("nemo_gym_test_patch.diff") + test_at = script.index("npm run test:unit") + assert patch_at < test_at and test_patch_at < test_at + + def test_omits_the_patch_step_when_there_is_no_patch(self) -> None: + """An empty model patch must not produce a `git apply` of a nonexistent file.""" + script = build_eval_script(_inputs(patch="")) + assert "nemo_gym_patch.diff" not in script + assert "nemo_gym_test_patch.diff" in script + + def test_brackets_the_test_command_with_markers(self) -> None: + script = build_eval_script(_inputs()) + assert script.index(TEST_OUTPUT_BEGIN) < script.index("npm run test:unit") < script.index(TEST_OUTPUT_END) + + def test_propagates_the_test_exit_code_not_the_install_one(self) -> None: + script = build_eval_script(_inputs()) + assert "__test_exit=$?" in script and "exit $__test_exit" in script + + +class TestVerificationFiles: + def test_ships_the_script_and_only_the_patches_that_exist(self) -> None: + files = verification_files(_inputs(patch="")) + assert "/tmp/nemo_gym_eval.sh" in files + assert "/tmp/nemo_gym_patch.diff" not in files + assert "/tmp/nemo_gym_test_patch.diff" in files + + +class _FakeSandbox: + def __init__(self, stdout: str, return_code: int = 0) -> None: + self._result = SimpleNamespace(stdout=stdout, stderr="", return_code=return_code) + self.commands: list[str] = [] + + async def exec(self, command: str, timeout_s=None): + self.commands.append(command) + return self._result + + +class TestRunVerification: + @pytest.mark.asyncio + async def test_grades_a_passing_run(self) -> None: + log = f"{TEST_OUTPUT_BEGIN}\nirrelevant\n{TEST_OUTPUT_END}" + sandbox = _FakeSandbox(log) + result = await run_verification( + sandbox=sandbox, + inputs=_inputs(fail_to_pass=["a"], pass_to_pass=[]), + parser=lambda _log: {"a": "PASSED"}, + ) + assert result.completed and result.resolved + assert sandbox.commands == ["bash /tmp/nemo_gym_eval.sh"] + + @pytest.mark.asyncio + async def test_missing_repo_directory_is_incomplete_not_a_zero(self) -> None: + """Exit 97 means the image lacks the checkout — an infrastructure fault. Reporting it + as a completed, unresolved run would make a broken image look like a hard task.""" + result = await run_verification( + sandbox=_FakeSandbox("", return_code=97), + inputs=_inputs(), + parser=lambda _log: {}, + ) + assert result.completed is False + assert result.resolved is False + assert "not present in the image" in result.error + + @pytest.mark.asyncio + async def test_a_parser_crash_is_reported_rather_than_scored_zero(self) -> None: + def boom(_log: str) -> dict[str, str]: + raise ValueError("bad log") + + result = await run_verification(sandbox=_FakeSandbox("x"), inputs=_inputs(), parser=boom) + assert result.completed is False + assert "raised" in result.error + + @pytest.mark.asyncio + async def test_only_the_marked_region_reaches_the_parser(self) -> None: + seen: list[str] = [] + + def capture(log: str) -> dict[str, str]: + seen.append(log) + return {} + + log = f"install FAILED noise\n{TEST_OUTPUT_BEGIN}\nreal output\n{TEST_OUTPUT_END}\ntrailing" + await run_verification(sandbox=_FakeSandbox(log), inputs=_inputs(), parser=capture) + assert "real output" in seen[0] + assert "install FAILED noise" not in seen[0] + + +class TestVerifyResponseShape: + """BaseVerifyResponse extends BaseVerifyRequest, so the request fields are REQUIRED on the + way out. Building the response from scratch drops them, and the resulting ValidationError + surfaces to the caller as a bare JSON string rather than a result object — which is how a + fully successful verification (reward 1.0, tests parsed) still failed the whole sweep.""" + + @staticmethod + def _body() -> dict: + return { + "instance_id": "elastic__synthetics-316", + "repo": "elastic/synthetics", + "base_commit": "f52f0bf", + "image_name": "docker.io/swerebenchv2/elastic-synthetics:316-f52f0bf", + "language": "ts", + "install_config": {"test_cmd": "npm test", "log_parser": "parse_log_js_4"}, + "FAIL_TO_PASS": [], + "PASS_TO_PASS": [], + "responses_create_params": {"input": []}, + "response": { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], + }, + } + + def test_spreading_the_request_body_satisfies_the_response_model(self) -> None: + from resources_servers.swe_rebench.app import SWERebenchVerifyResponse + + response = SWERebenchVerifyResponse.model_validate( + self._body() + | { + "reward": 1.0, + "evaluation_completed": True, + "resolved": True, + "patch_applied": True, + "test_results": {"resolved": True}, + "test_output": "", + "error": None, + "eval_sandbox_start_time_taken": 1.0, + "patch_verification_time_taken": 2.0, + } + ) + assert response.reward == 1.0 and response.resolved + + def test_omitting_the_request_fields_is_rejected(self) -> None: + """Pins the actual failure: without the echoed request fields, validation fails.""" + import pydantic + + from resources_servers.swe_rebench.app import SWERebenchVerifyResponse + + with pytest.raises(pydantic.ValidationError, match="responses_create_params|response"): + SWERebenchVerifyResponse.model_validate( + { + "reward": 1.0, + "evaluation_completed": True, + "resolved": True, + "patch_applied": True, + "instance_id": "i", + "language": "ts", + "test_results": None, + "test_output": "", + "error": None, + "eval_sandbox_start_time_taken": 0.0, + "patch_verification_time_taken": 0.0, + } + ) + + +class TestSandboxCpuCap: + """Build tools size their worker pools from the HOST core count, not the cgroup quota, so + without these caps a 4-CPU sandbox on a 96-core node runs ~96 compilers and CFS-throttles. + This set is the compile-heaviest in the repo, so it is the one that most needs them.""" + + def test_cpu_cap_env_is_derived_from_the_cpu_limit(self) -> None: + from nemo_gym.sandbox.utils import cpu_cap_env + + env = cpu_cap_env(4) + assert env["OMP_NUM_THREADS"] == "4" + assert env["GOMAXPROCS"] == "4" + assert env["CARGO_BUILD_JOBS"] == "4" + + def test_the_server_applies_them_and_explicit_env_still_wins(self) -> None: + from nemo_gym.sandbox.utils import cpu_cap_env + + # Mirrors the precedence in _create_sandbox: derived caps first, explicit env over them. + derived = cpu_cap_env(4) + explicit = {"GOMAXPROCS": "1", "MY_VAR": "x"} + merged = derived | explicit + assert merged["GOMAXPROCS"] == "1", "an explicit override must not be clobbered" + assert merged["OMP_NUM_THREADS"] == "4" + assert merged["MY_VAR"] == "x" + + def test_the_app_wires_cpu_cap_env_into_the_spec(self) -> None: + """Source pin: the call is easy to drop in a refactor and its absence is invisible — + tasks still pass, just far slower, which reads as 'these languages are slow'.""" + from pathlib import Path + + source = (Path(__file__).resolve().parent.parent / "app.py").read_text() + assert "cpu_cap_env(sandbox_resources.cpu)" in source + assert "env=env," in source, "the derived env must reach SandboxSpec" + + +class TestGoldenPatchAggregation: + """The 3x repeat only means something if 'failed once' and 'had no verdict once' are kept + apart: the first is a flaky test, the second is an image pull or provider fault that says + nothing about the row.""" + + @staticmethod + def _obs(completed: bool, resolved: bool) -> dict: + return {"evaluation_completed": completed, "resolved": resolved} + + def test_resolved_in_every_pass_is_supported(self) -> None: + from resources_servers.swe_rebench.aggregate_golden_patch import classify + + assert classify([self._obs(True, True)] * 3, 3) == "supported" + + def test_resolved_in_some_passes_is_flaky(self) -> None: + from resources_servers.swe_rebench.aggregate_golden_patch import classify + + observations = [self._obs(True, True), self._obs(True, False), self._obs(True, True)] + assert classify(observations, 3) == "flaky" + + def test_never_resolved_is_broken_not_flaky(self) -> None: + from resources_servers.swe_rebench.aggregate_golden_patch import classify + + assert classify([self._obs(True, False)] * 3, 3) == "broken" + + def test_a_missing_verdict_is_inconclusive_not_broken(self) -> None: + """The important one: an infrastructure fault must not delete a row that resolved + cleanly every time it was actually measured.""" + from resources_servers.swe_rebench.aggregate_golden_patch import classify + + observations = [self._obs(True, True), self._obs(True, True), self._obs(False, False)] + assert classify(observations, 3) == "inconclusive" + + def test_a_row_missing_a_pass_entirely_is_inconclusive(self) -> None: + from resources_servers.swe_rebench.aggregate_golden_patch import classify + + assert classify([self._obs(True, True), self._obs(True, True)], 3) == "inconclusive" + + +class TestMultiWorkerEntrypoint: + """num_workers > 1 makes uvicorn re-import this entrypoint by path in each forked child. + + Without a module-level `app` every child exits and uvicorn stops the parent, so the server + never binds. The symptom is not an ImportError but a flood of connection errors from clients + talking to a dead port -- which is exactly how it presented: 715k ClientOSError and zero rows. + """ + + @staticmethod + def _source() -> str: + from pathlib import Path + + return (Path(__file__).resolve().parent.parent / "app.py").read_text() + + def test_exposes_a_module_level_app_for_forked_workers(self) -> None: + source = self._source() + assert "is_nemo_gym_fastapi_entrypoint(__file__)" in source + assert "app = SWERebenchResourcesServer.run_webserver()" in source + + def test_the_config_that_needs_it_still_sets_num_workers(self) -> None: + """Pins the pair: if num_workers is configured, the entrypoint branch must exist.""" + from pathlib import Path + + import yaml + + config = yaml.safe_load((Path(__file__).resolve().parent.parent / "configs" / "swe_rebench.yaml").read_text()) + for name, block in config.items(): + workers = block["resources_servers"]["swe_rebench"].get("num_workers") + if workers and workers > 1: + assert "is_nemo_gym_fastapi_entrypoint(__file__)" in self._source(), ( + f"{name} sets num_workers={workers} but the entrypoint has no module-level app" + ) + + +class TestFailureDiagnosis: + """A resource failure and a broken row both end as resolved=False with a parsed log, so the + two are only separable by evidence in the output. Getting this wrong in either direction is + costly: miss it and good rows get marked broken; over-claim it and real failures get excused + by raising limits that were never the problem.""" + + def test_detects_an_oom_kill(self) -> None: + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("java.lang.OutOfMemoryError: Java heap space") == "oom" + assert classify_output("fatal error: runtime: out of memory") == "oom" + + def test_detects_a_full_disk(self) -> None: + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("write error: No space left on device") == "disk_full" + + def test_disk_is_reported_ahead_of_a_bare_kill(self) -> None: + """Ordering matters: a disk-full run often also prints 'Killed', and the actionable + cause is the disk, not the signal.""" + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("No space left on device\nKilled") == "disk_full" + + def test_an_ordinary_test_failure_is_not_a_resource_problem(self) -> None: + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("FAILED tests/test_x.py::test_y - AssertionError: 1 != 2") is None + + def test_network_faults_are_separated_from_row_failures(self) -> None: + """Sandboxes are network restricted, so a dependency fetch escaping the image is an + environment problem, not evidence that the golden patch is wrong.""" + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("npm ERR! could not resolve host registry.npmjs.org") == "network" + + +class TestMavenMirror: + """Every JVM failure in the 200-row pass was `repo.maven.apache.org ... Network is + unreachable`, while crates.io, proxy.golang.org, npmjs and packagist all fetched fine from + the same sandboxes. So egress works and Maven Central specifically does not; the fix is to + point Maven and Gradle at the Google-hosted read-through mirror.""" + + def test_mirror_configs_are_shipped_to_every_sandbox(self) -> None: + from resources_servers.swe_rebench.verification import ( + GRADLE_INIT_PATH, + MAVEN_SETTINGS_PATH, + verification_files, + ) + + files = verification_files(_inputs()) + assert MAVEN_SETTINGS_PATH in files, "Maven reads ~/.m2/settings.xml by default" + assert GRADLE_INIT_PATH in files, "Gradle auto-loads $GRADLE_USER_HOME/init.d/*.gradle" + assert "maven-central.storage-download.googleapis.com" in files[MAVEN_SETTINGS_PATH] + + def test_gradle_home_is_set_or_the_init_script_is_never_read(self) -> None: + """Shipping init.gradle is useless on its own: Gradle only scans init.d under + GRADLE_USER_HOME, so without this the file sits there unread.""" + from resources_servers.swe_rebench.app import JVM_MIRROR_ENV + from resources_servers.swe_rebench.verification import GRADLE_INIT_PATH + + assert JVM_MIRROR_ENV["GRADLE_USER_HOME"] == "/root/.gradle" + assert GRADLE_INIT_PATH.startswith(JVM_MIRROR_ENV["GRADLE_USER_HOME"] + "/init.d/") + + def test_the_mirror_only_redirects_central(self) -> None: + """mirrorOf must stay `central`, not `*`: a project's own snapshot or internal repos + have to keep resolving from their real URLs or unrelated rows start failing.""" + from resources_servers.swe_rebench.verification import MAVEN_SETTINGS_PATH, verification_files + + settings = verification_files(_inputs())[MAVEN_SETTINGS_PATH] + assert "central" in settings + assert "*" not in settings + + def test_explicit_config_env_still_wins(self) -> None: + from resources_servers.swe_rebench.app import JVM_MIRROR_ENV + + merged = JVM_MIRROR_ENV | {"GRADLE_USER_HOME": "/custom"} + assert merged["GRADLE_USER_HOME"] == "/custom" + + +class TestFailureDiagnosis: + """A resource failure and a broken row both end as resolved=False with a parsed log, so the + two are only separable by evidence in the output. Getting this wrong in either direction is + costly: miss it and good rows get marked broken; over-claim it and real failures get excused + by raising limits that were never the problem.""" + + def test_detects_an_oom_kill(self) -> None: + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("java.lang.OutOfMemoryError: Java heap space") == "oom" + assert classify_output("fatal error: runtime: out of memory") == "oom" + + def test_detects_a_full_disk(self) -> None: + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("write error: No space left on device") == "disk_full" + + def test_disk_is_reported_ahead_of_a_bare_kill(self) -> None: + """Ordering matters: a disk-full run often also prints 'Killed', and the actionable + cause is the disk, not the signal.""" + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("No space left on device\nKilled") == "disk_full" + + def test_an_ordinary_test_failure_is_not_a_resource_problem(self) -> None: + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("FAILED tests/test_x.py::test_y - AssertionError: 1 != 2") is None + + def test_network_faults_are_separated_from_row_failures(self) -> None: + """Sandboxes are network restricted, so a dependency fetch escaping the image is an + environment problem, not evidence that the golden patch is wrong.""" + from resources_servers.swe_rebench.diagnose_failures import classify_output + + assert classify_output("npm ERR! could not resolve host registry.npmjs.org") == "network" + + +class TestJvmNetworkWorkaround: + """The sandbox has working egress -- Go, npm and composer fetch fine in it. What fails is a + JVM on a dual-stack network preferring an IPv6 address with no route, so Maven and Gradle + dependency resolution dies with 'Network is unreachable'. Measured on a 200-row pass: 12 of + 13 network failures were JVM-family and every one showed that error.""" + + def test_the_flag_targets_the_build_tools(self) -> None: + from resources_servers.swe_rebench.app import JVM_IPV4_ENV + + assert set(JVM_IPV4_ENV) == {"MAVEN_OPTS", "GRADLE_OPTS", "SBT_OPTS"} + for value in JVM_IPV4_ENV.values(): + assert "preferIPv6Addresses=false" in value + + def test_it_avoids_java_options_which_pollutes_the_graded_log(self) -> None: + """_JAVA_OPTIONS would work but makes every JVM print 'Picked up _JAVA_OPTIONS: ...' to + stderr, which lands inside the marked test region and is fed to line-oriented parsers.""" + from resources_servers.swe_rebench.app import JVM_IPV4_ENV + + assert "_JAVA_OPTIONS" not in JVM_IPV4_ENV + + def test_explicit_config_env_still_wins(self) -> None: + from resources_servers.swe_rebench.app import JVM_IPV4_ENV + + merged = JVM_IPV4_ENV | {"MAVEN_OPTS": "-Xmx8g"} + assert merged["MAVEN_OPTS"] == "-Xmx8g" + assert "preferIPv6Addresses" in merged["GRADLE_OPTS"] diff --git a/resources_servers/swe_rebench/verification.py b/resources_servers/swe_rebench/verification.py new file mode 100644 index 00000000000..b99e1fc8b34 --- /dev/null +++ b/resources_servers/swe_rebench/verification.py @@ -0,0 +1,276 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Run one SWE-rebench instance's tests in a sandbox and grade the result. + +The dataset ships everything needed per row: a prebuilt image, the commands to install and to +test, and the name of the parser that reads the resulting log. So verification is: restore the +repo, apply the test patch and the candidate patch, install, test, parse, grade. +""" + +from __future__ import annotations + +import asyncio +import re +import shlex +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any, Callable, Iterable, Sequence + + +# The marker delimits the graded test output from the install noise that precedes it. Parsers +# are line-oriented and several will happily interpret dependency-resolver chatter as test +# results, so the log is sliced before parsing rather than handed over whole. +TEST_OUTPUT_BEGIN = "___NEMO_GYM_SWE_REBENCH_TEST_BEGIN___" +TEST_OUTPUT_END = "___NEMO_GYM_SWE_REBENCH_TEST_END___" + +PASSED = "PASSED" + +# Test names in several ecosystems carry per-run timings, so the recorded expectation and the +# observed name differ only by a duration. Stripping them is what makes the comparison stable. +# Kept identical to the swe_agents harness's normalization so both graders agree. +_TIMING_PATTERNS = ( + re.compile(r"\s*\[\s*\d+(?:\.\d+)?\s*(?:ms|s)\s*\]\s*$", re.IGNORECASE), + re.compile(r"\s+in\s+\d+(?:\.\d+)?\s+(?:msec|sec)\b", re.IGNORECASE), + re.compile(r"\s*\(\s*\d+(?:\.\d+)?\s*(?:ms|s)\s*\)\s*$", re.IGNORECASE), +) + + +def normalize_test_name(name: str) -> str: + for pattern in _TIMING_PATTERNS: + name = pattern.sub("", name) + return name.strip() + + +def as_command_list(value: Any) -> list[str]: + """``install`` and ``test_cmd`` are a string in some rows and a list in others.""" + if not value: + return [] + if isinstance(value, str): + return [value] + return [str(item) for item in value] + + +def repo_directory(repo: str) -> str: + """Where the image checks the repo out: ``/``, e.g. ``elastic/synthetics`` -> ``/synthetics``.""" + return "/" + (repo.split("/", 1)[1] if "/" in repo else repo) + + +@dataclass +class VerificationInputs: + instance_id: str + repo: str + base_commit: str + patch: str + test_patch: str = "" + install: Sequence[str] = field(default_factory=tuple) + test_cmd: Sequence[str] = field(default_factory=tuple) + log_parser: str = "" + fail_to_pass: Sequence[str] = field(default_factory=tuple) + pass_to_pass: Sequence[str] = field(default_factory=tuple) + + +@dataclass +class VerificationResult: + completed: bool + resolved: bool + patch_applied: bool + test_results: dict[str, Any] | None + test_output: str + error: str | None = None + + +def build_eval_script(inputs: VerificationInputs) -> str: + """The script run inside the sandbox. + + Patches are applied with the same tolerant flags the existing SWE-rebench harness uses. + ``|| true`` on the patch steps is deliberate: a partially applying patch must still reach + the test phase, because the tests are the actual verdict — refusing to run them here would + convert a recoverable patch into an unexplained infrastructure failure. + """ + work_dir = repo_directory(inputs.repo) + install_block = "\n".join(as_command_list(inputs.install)) + test_block = "\n".join(as_command_list(inputs.test_cmd)) + + apply_patch = "" + if inputs.patch.strip(): + apply_patch = ( + "git apply --reject --recount --ignore-space-change --whitespace=nowarn /tmp/nemo_gym_patch.diff || true" + ) + apply_test_patch = "" + if inputs.test_patch.strip(): + apply_test_patch = ( + "git apply --reject --recount --ignore-space-change --whitespace=nowarn " + "/tmp/nemo_gym_test_patch.diff || true" + ) + + return f"""#!/bin/bash +cd {shlex.quote(work_dir)} || exit 97 +git reset --hard HEAD >/dev/null 2>&1 || true +git checkout {shlex.quote(inputs.base_commit)} >/dev/null 2>&1 || true + +{apply_patch} +{apply_test_patch} + +# Install steps are advisory: several rows ship commands that fail harmlessly on an image that +# is already provisioned, and aborting there would mask an otherwise gradeable run. +set +e +{install_block} + +echo "{TEST_OUTPUT_BEGIN}" +{test_block} +__test_exit=$? +echo "{TEST_OUTPUT_END}" +exit $__test_exit +""" + + +def slice_test_output(log: str) -> str: + """Return only the region between the markers, or the whole log if they are absent.""" + start = log.find(TEST_OUTPUT_BEGIN) + if start == -1: + return log + start += len(TEST_OUTPUT_BEGIN) + end = log.find(TEST_OUTPUT_END, start) + return log[start:end] if end != -1 else log[start:] + + +def grade( + statuses: dict[str, str], + fail_to_pass: Iterable[str], + pass_to_pass: Iterable[str], +) -> dict[str, Any]: + """An instance resolves only when every required test is observed AND passing. + + A missing test counts as not passing. Treating "absent" as success is the classic way a + broken test command scores as a resolved instance. + """ + observed = {normalize_test_name(name): status for name, status in statuses.items()} + + def split(names: Iterable[str]) -> tuple[list[str], list[str]]: + passed, failed = [], [] + for raw in names: + name = normalize_test_name(raw) + (passed if observed.get(name) == PASSED else failed).append(raw) + return passed, failed + + f2p_passed, f2p_failed = split(fail_to_pass) + p2p_passed, p2p_failed = split(pass_to_pass) + return { + "FAIL_TO_PASS": {"success": f2p_passed, "failure": f2p_failed}, + "PASS_TO_PASS": {"success": p2p_passed, "failure": p2p_failed}, + "tests_observed": len(observed), + "resolved": not f2p_failed and not p2p_failed, + } + + +# Where Maven and Gradle look by default when running as root, which these images do. +MAVEN_SETTINGS_PATH = "/root/.m2/settings.xml" +GRADLE_INIT_PATH = "/root/.gradle/init.d/nemo_gym_mirror.gradle" + + +def _mirror_files() -> dict[str, str]: + """Redirect Maven Central to its Google-hosted mirror. + + Measured on a 200-row pass: every JVM row that failed did so on + ``repo.maven.apache.org ... Network is unreachable``, while crates.io, proxy.golang.org, + registry.npmjs.org and packagist all fetched successfully from the same sandboxes. So egress + works and Maven Central specifically does not. The mirror is a read-through copy on + googleapis.com, which the Go module proxy already demonstrates is reachable here. + + Reused verbatim from responses_api_agents/swe_agents/maven_mirror/, where it was added for + the same class of problem. + """ + mirror_dir = Path(__file__).resolve().parents[2] / "responses_api_agents" / "swe_agents" / "maven_mirror" + files: dict[str, str] = {} + settings = mirror_dir / "settings.xml" + init_gradle = mirror_dir / "init.gradle" + if settings.exists(): + files[MAVEN_SETTINGS_PATH] = settings.read_text() + if init_gradle.exists(): + files[GRADLE_INIT_PATH] = init_gradle.read_text() + return files + + +def verification_files(inputs: VerificationInputs) -> dict[str, str]: + """Files the sandbox must be created with. + + Delivered through ``SandboxSpec.files`` rather than written after start: the patches can be + large, and a create-time file is one provider round trip instead of several. + """ + files = {"/tmp/nemo_gym_eval.sh": build_eval_script(inputs)} + # Harmless for non-JVM rows, which never read them. + files.update(_mirror_files()) + if inputs.patch.strip(): + files["/tmp/nemo_gym_patch.diff"] = inputs.patch + if inputs.test_patch.strip(): + files["/tmp/nemo_gym_test_patch.diff"] = inputs.test_patch + return files + + +async def run_verification( + sandbox: Any, + inputs: VerificationInputs, + parser: Callable[[str], dict[str, str]], + timeout_s: float | None = None, + log_dir: Path | None = None, +) -> VerificationResult: + """Run the eval script in a sandbox already seeded with ``verification_files``.""" + result = await sandbox.exec("bash /tmp/nemo_gym_eval.sh", timeout_s=timeout_s) + output = (result.stdout or "") + (("\n" + result.stderr) if result.stderr else "") + + if log_dir is not None: + # Off the loop: this is a shared-filesystem write, and at high concurrency a few ms per + # task on the event loop becomes a stall for every other in-flight verification. + def _persist_log() -> None: + try: + log_dir.mkdir(parents=True, exist_ok=True) + (log_dir / "test_output.log").write_text(output, errors="replace") + except OSError: + pass + + await asyncio.to_thread(_persist_log) + + if result.return_code == 97: + return VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output=output, + error=f"repo directory {repo_directory(inputs.repo)} not present in the image", + ) + + try: + # Also off the loop. The parsers are regex passes over the whole test log, so they are + # CPU-bound; running them inline serialises every concurrent verification behind them. + statuses = await asyncio.to_thread(parser, slice_test_output(output)) + except Exception as exc: # a parser crash is a grading failure, never a silent zero + return VerificationResult( + completed=False, + resolved=False, + patch_applied=True, + test_results=None, + test_output=output, + error=f"log parser {inputs.log_parser!r} raised: {exc}", + ) + + report = grade(statuses, inputs.fail_to_pass, inputs.pass_to_pass) + return VerificationResult( + completed=True, + resolved=bool(report["resolved"]), + patch_applied=True, + test_results=report, + test_output=output, + ) From 62ed553185549b5b6425f8994c19768863a6875e Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Sun, 13 Sep 2026 09:23:45 -0700 Subject: [PATCH 03/29] feat: add rebench v2 training config Signed-off-by: Sugam Devare --- resources_servers/swe_rebench/README.md | 29 +++-- .../swe_rebench/apply_golden_patch.py | 12 +- resources_servers/swe_rebench/client.py | 4 +- .../configs/swe_rebench_opencode.yaml | 33 ++++++ resources_servers/swe_rebench/data/.gitignore | 3 + .../swe_rebench/prepare_swe_rebench.py | 109 ++++++++++++++++++ 6 files changed, 173 insertions(+), 17 deletions(-) create mode 100644 resources_servers/swe_rebench/configs/swe_rebench_opencode.yaml create mode 100644 resources_servers/swe_rebench/data/.gitignore create mode 100644 resources_servers/swe_rebench/prepare_swe_rebench.py diff --git a/resources_servers/swe_rebench/README.md b/resources_servers/swe_rebench/README.md index ffa2e5b0833..a760a05901d 100644 --- a/resources_servers/swe_rebench/README.md +++ b/resources_servers/swe_rebench/README.md @@ -35,10 +35,12 @@ indistinguishable from a real failure. ## Prepare the data +`prepare_swe_rebench.py` only writes rows already on `data/supported_instance_ids.txt` -- see +Golden-patch validation below for what that list is and why. It streams the Hub dataset rather +than loading the full ~2.5 GB split, since only about 70% of rows are kept. + ```bash -# The whole set, or a subset: -SWE_REBENCH_LANGUAGES=python,go SWE_REBENCH_LIMIT=200 \ - python benchmarks/swe_rebench/prepare.py +SWE_REBENCH_LIMIT=200 python resources_servers/swe_rebench/prepare_swe_rebench.py ``` ## Golden-patch validation @@ -52,7 +54,7 @@ gym env start \ --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml python resources_servers/swe_rebench/apply_golden_patch.py \ - +benchmark_jsonl=benchmarks/swe_rebench/data/swe_rebench_benchmark.jsonl \ + +training_jsonl=resources_servers/swe_rebench/data/swe_rebench_training.jsonl \ +limit=40 +concurrency=8 ``` @@ -66,16 +68,25 @@ the workload needs no GPU, since the containers run remotely. supported / flaky / broken / inconclusive buckets, keeping an infra fault (no verdict) separate from a genuinely nondeterministic test so neither silently corrupts the other's label. `data/supported_instance_ids.txt` is the result of one such sweep over the full set: 22,684 of -32,079 instances whose golden patch resolved in all three passes -- a separate -artifact for training use, not consumed by `prepare.py` or the eval benchmark. The other 9,395 -are excluded from that list because none can be scored either way: 6,813 never resolve +32,079 instances whose golden patch resolved in all three passes. `prepare_swe_rebench.py` reads +this list and writes only those rows -- the training jsonl is the supported set, not the full +Hub dataset. The other 9,395 are excluded from that list because none can be scored either way: +6,813 never resolve (concentrated in the compiled-language rows -- java, kotlin, scala, cpp), 2,376 resolve inconsistently across passes (flaky tests), and 206 never produced a verdict in any pass (image pull / setup failures, not row failures -- see `diagnose_failures.py`). ## Running an agent -`benchmarks/swe_rebench/opencode.yaml` wires this server to the opencode sandboxed agent, in the -same shape as the swebench verified/pro/multilingual benchmarks. +`configs/swe_rebench_opencode.yaml` wires the opencode sandboxed agent to +`swe_rebench_resources_server`, pointed at `data/swe_rebench_training.jsonl`. It lives in a +separate file rather than folded into `swe_rebench.yaml` so golden-patch validation (which never +touches an agent) doesn't need to pull in the agent's much larger sandbox/permission config. + +```bash +gym env start \ + --config resources_servers/swe_rebench/configs/swe_rebench_opencode.yaml \ + --config responses_api_models/vllm_model/configs/vllm_model.yaml +``` Upstream SWE-rebench code is MIT licensed. This adapter is Apache-2.0. diff --git a/resources_servers/swe_rebench/apply_golden_patch.py b/resources_servers/swe_rebench/apply_golden_patch.py index ffd44f18a46..7a388a582a9 100644 --- a/resources_servers/swe_rebench/apply_golden_patch.py +++ b/resources_servers/swe_rebench/apply_golden_patch.py @@ -22,7 +22,7 @@ --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml python resources_servers/swe_rebench/apply_golden_patch.py \ - +benchmark_jsonl=benchmarks/swe_rebench/data/swe_rebench_benchmark.jsonl \ + +training_jsonl=resources_servers/swe_rebench/data/swe_rebench_training.jsonl \ +output_jsonl=results/swe_rebench_golden_patch.jsonl \ +concurrency=32 +limit=100 """ @@ -59,8 +59,8 @@ def _stream_examples(path: Path, limit: int): feed a bounded worker pool wastes that memory for the whole run, and the peak lands hours in when results have also accumulated. """ - with open(path, encoding="utf-8") as benchmark: - for index, line in enumerate(benchmark): + with open(path, encoding="utf-8") as training: + for index, line in enumerate(training): if limit and index >= limit: return line = line.strip() @@ -72,10 +72,10 @@ async def main() -> None: config = get_global_config_dict() limit = int(config.get("limit") or 0) concurrency = int(config.get("concurrency") or 16) - benchmark_fpath = Path(config["benchmark_jsonl"]) + training_fpath = Path(config["training_jsonl"]) output_fpath = Path(config.get("output_jsonl") or "results/swe_rebench_golden_patch.jsonl") - total = sum(1 for _ in _stream_examples(benchmark_fpath, limit)) + total = sum(1 for _ in _stream_examples(training_fpath, limit)) client = ServerClient.load_from_global_config() # Bounded: the queue holds at most one row per worker, so resident rows track concurrency @@ -144,7 +144,7 @@ async def worker() -> None: queue.task_done() workers = [asyncio.create_task(worker()) for _ in range(concurrency)] - for example in _stream_examples(benchmark_fpath, limit): + for example in _stream_examples(training_fpath, limit): await queue.put(example) for _ in workers: await queue.put(None) diff --git a/resources_servers/swe_rebench/client.py b/resources_servers/swe_rebench/client.py index 39c7b10224f..f31abd3b5ca 100644 --- a/resources_servers/swe_rebench/client.py +++ b/resources_servers/swe_rebench/client.py @@ -35,8 +35,8 @@ async def main() -> None: config = get_global_config_dict() - with open(config["benchmark_jsonl"], encoding="utf-8") as benchmark: - example = json.loads(next(benchmark)) + with open(config["training_jsonl"], encoding="utf-8") as training: + example = json.loads(next(training)) example |= {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} client = ServerClient.load_from_global_config() diff --git a/resources_servers/swe_rebench/configs/swe_rebench_opencode.yaml b/resources_servers/swe_rebench/configs/swe_rebench_opencode.yaml new file mode 100644 index 00000000000..76eced499d5 --- /dev/null +++ b/resources_servers/swe_rebench/configs/swe_rebench_opencode.yaml @@ -0,0 +1,33 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Wires the opencode sandboxed agent to swe_rebench_resources_server for a training run -- +# `swe_rebench.yaml` alone only defines the resources server, which is enough for golden-patch +# validation (apply_golden_patch.py talks to it directly, no agent involved) but not enough to +# actually run an agent against the dataset. This is a separate file, not folded into +# swe_rebench.yaml, so golden-patch validation keeps working without pulling in the agent's +# (much larger) opencode/sandbox config. +# +# This is training data (data/swe_rebench_training.jsonl, only the 22,684 already-supported +# instances -- see the README), not a fixed eval benchmark. +# +# gym env start --config resources_servers/swe_rebench/configs/swe_rebench_opencode.yaml + +config_paths: + - responses_api_agents/opencode_sandboxed_agent/configs/opencode_sandboxed_agent.yaml + - resources_servers/swe_rebench/configs/swe_rebench.yaml + +swe_rebench_opencode_sandboxed_agent: + _inherit_from: opencode_sandboxed_agent + responses_api_agents: + opencode_sandboxed_agent: + resources_server: + type: resources_servers + name: swe_rebench_resources_server + datasets: + - name: swe_rebench_v2 + type: train + jsonl_fpath: resources_servers/swe_rebench/data/swe_rebench_training.jsonl + num_repeats: 1 + # nebius/SWE-rebench-V2's own Hub metadata license (cc-by-4.0). + license: Creative Commons Attribution 4.0 International diff --git a/resources_servers/swe_rebench/data/.gitignore b/resources_servers/swe_rebench/data/.gitignore new file mode 100644 index 00000000000..a04fc1f3f39 --- /dev/null +++ b/resources_servers/swe_rebench/data/.gitignore @@ -0,0 +1,3 @@ +# Prepared training JSONL is a ~1.8 GB filtered slice of the Hub dataset (patch/test_patch +# content for every supported instance). Regenerate with prepare_swe_rebench.py. +*.jsonl diff --git a/resources_servers/swe_rebench/prepare_swe_rebench.py b/resources_servers/swe_rebench/prepare_swe_rebench.py new file mode 100644 index 00000000000..041fae23580 --- /dev/null +++ b/resources_servers/swe_rebench/prepare_swe_rebench.py @@ -0,0 +1,109 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Prepare nebius/SWE-rebench-V2 training data for NeMo Gym, from the Hub. + +This is a training dataset, not an eval benchmark -- there is no fixed/frozen reference split, +and the output is meant to feed a training run, not to be scored against as a leaderboard. + +Writes only the rows already known to be usable: `data/supported_instance_ids.txt` (22,684 of +the Hub's 32,079 instances) is the result of a full-set 3x golden-patch sweep -- a row not on +that list either never resolves, never produced a verdict, or resolves inconsistently across +passes (see `aggregate_golden_patch.py` and the README), so it is not worth carrying into the +training jsonl at all rather than shipping a row no agent run could usefully score. + +Streams the Hub dataset and filters row-by-row rather than loading it fully: at ~2.5 GB the full +train split is not worth materialising in memory just to keep 70% of it. + + SWE_REBENCH_LIMIT=200 python resources_servers/swe_rebench/prepare_swe_rebench.py +""" + +import json +import os +from pathlib import Path + + +DATASET_NAME = "nebius/SWE-rebench-V2" +SUPPORTED_IDS_FPATH = Path(__file__).parent / "data" / "supported_instance_ids.txt" +OUTPUT_FPATH = Path(__file__).parent / "data" / "swe_rebench_training.jsonl" + +# Matches this server's own `allowed_agents` (see configs/swe_rebench.yaml) -- the same +# convention other resources servers' training jsonls use to say which agent a row runs under. +AGENT_REF = {"type": "responses_api_agents", "name": "opencode_sandboxed_agent"} + +# The Hub row's own sentinel for "this task adds no new interface" -- confirmed exact and stable +# (no near-duplicate phrasing) across a 5,000-row sample of the dataset. +NO_NEW_INTERFACE_SENTINEL = "No new interfaces are introduced." + +# The Hub row's own fields this server's request model reads (see app.py's +# SWERebenchInstanceRequest) -- extras like `pr_description`/`meta`/`license` are dropped rather +# than carried through unused. +ROW_FIELDS = ( + "instance_id", + "repo", + "base_commit", + "patch", + "test_patch", + "problem_statement", + "language", + "image_name", + "install_config", + "FAIL_TO_PASS", + "PASS_TO_PASS", +) + + +def _load_supported_ids(fpath: Path) -> set[str]: + return {line.strip() for line in fpath.read_text(encoding="utf-8").splitlines() if line.strip()} + + +def prepare(supported_ids: set[str], limit: int = 0) -> Path: + from datasets import load_dataset + + OUTPUT_FPATH.parent.mkdir(parents=True, exist_ok=True) + dataset = load_dataset(DATASET_NAME, split="train", streaming=True) + + written = 0 + with OUTPUT_FPATH.open("w", encoding="utf-8") as fout: + for example in dataset: + if limit and written >= limit: + break + if example["instance_id"] not in supported_ids: + continue + + row = {field: example[field] for field in ROW_FIELDS} + + content = row["problem_statement"] + interface = (example.get("interface") or "").strip() + if interface and interface != NO_NEW_INTERFACE_SENTINEL: + content = f"{content}\n\n## New interfaces to add:\n{interface}" + + row["responses_create_params"] = {"input": [{"role": "user", "content": content}]} + row["agent_ref"] = AGENT_REF + + fout.write(json.dumps(row) + "\n") + written += 1 + + print(f"Wrote {written} SWE-rebench-V2 problems to {OUTPUT_FPATH}") + missing = len(supported_ids) - written + if missing: + print(f" {missing} supported id(s) from {SUPPORTED_IDS_FPATH.name} were not found in the Hub dataset") + return OUTPUT_FPATH + + +if __name__ == "__main__": + prepare( + _load_supported_ids(SUPPORTED_IDS_FPATH), + int(os.environ.get("SWE_REBENCH_LIMIT") or 0), + ) From 8504e2d2723bd79008680ae2b1d4ff1a28df1c12 Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Sun, 13 Sep 2026 09:28:11 -0700 Subject: [PATCH 04/29] feat: update prepare file Signed-off-by: Sugam Devare --- .../swe_rebench/prepare_swe_rebench.py | 49 ++++++++++++------- 1 file changed, 30 insertions(+), 19 deletions(-) diff --git a/resources_servers/swe_rebench/prepare_swe_rebench.py b/resources_servers/swe_rebench/prepare_swe_rebench.py index 041fae23580..61e71ec3ac2 100644 --- a/resources_servers/swe_rebench/prepare_swe_rebench.py +++ b/resources_servers/swe_rebench/prepare_swe_rebench.py @@ -23,17 +23,24 @@ passes (see `aggregate_golden_patch.py` and the README), so it is not worth carrying into the training jsonl at all rather than shipping a row no agent run could usefully score. -Streams the Hub dataset and filters row-by-row rather than loading it fully: at ~2.5 GB the full -train split is not worth materialising in memory just to keep 70% of it. +Streams the Hub dataset and filters row-by-row rather than loading the full ~2.5 GB split just +to keep 70% of it -- but the *kept* rows are still buffered and shuffled (fixed seed, so re-runs +are reproducible) before writing, since the Hub's own row order is grouped by repo/creation time, +not randomised, and training on that order as-is would bias early steps toward whichever repos +happen to sort first. SWE_REBENCH_LIMIT=200 python resources_servers/swe_rebench/prepare_swe_rebench.py """ import json import os +import random from pathlib import Path +SHUFFLE_SEED = 0 + + DATASET_NAME = "nebius/SWE-rebench-V2" SUPPORTED_IDS_FPATH = Path(__file__).parent / "data" / "supported_instance_ids.txt" OUTPUT_FPATH = Path(__file__).parent / "data" / "swe_rebench_training.jsonl" @@ -74,29 +81,33 @@ def prepare(supported_ids: set[str], limit: int = 0) -> Path: OUTPUT_FPATH.parent.mkdir(parents=True, exist_ok=True) dataset = load_dataset(DATASET_NAME, split="train", streaming=True) - written = 0 - with OUTPUT_FPATH.open("w", encoding="utf-8") as fout: - for example in dataset: - if limit and written >= limit: - break - if example["instance_id"] not in supported_ids: - continue + rows = [] + for example in dataset: + if limit and len(rows) >= limit: + break + if example["instance_id"] not in supported_ids: + continue - row = {field: example[field] for field in ROW_FIELDS} + row = {field: example[field] for field in ROW_FIELDS} - content = row["problem_statement"] - interface = (example.get("interface") or "").strip() - if interface and interface != NO_NEW_INTERFACE_SENTINEL: - content = f"{content}\n\n## New interfaces to add:\n{interface}" + content = row["problem_statement"] + interface = (example.get("interface") or "").strip() + if interface and interface != NO_NEW_INTERFACE_SENTINEL: + content = f"{content}\n\n## New interfaces to add:\n{interface}" - row["responses_create_params"] = {"input": [{"role": "user", "content": content}]} - row["agent_ref"] = AGENT_REF + row["responses_create_params"] = {"input": [{"role": "user", "content": content}]} + row["agent_ref"] = AGENT_REF + rows.append(row) + + random.Random(SHUFFLE_SEED).shuffle(rows) + + with OUTPUT_FPATH.open("w", encoding="utf-8") as fout: + for row in rows: fout.write(json.dumps(row) + "\n") - written += 1 - print(f"Wrote {written} SWE-rebench-V2 problems to {OUTPUT_FPATH}") - missing = len(supported_ids) - written + print(f"Wrote {len(rows)} SWE-rebench-V2 problems to {OUTPUT_FPATH} (shuffled, seed={SHUFFLE_SEED})") + missing = len(supported_ids) - len(rows) if missing: print(f" {missing} supported id(s) from {SUPPORTED_IDS_FPATH.name} were not found in the Hub dataset") return OUTPUT_FPATH From 91b3a66d2781187a0c1283249571a702216f63ab Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Sun, 13 Sep 2026 09:40:16 -0700 Subject: [PATCH 05/29] feat: add scaleswe trainier and fix agent ref in jsonl Signed-off-by: Sugam Devare --- resources_servers/scale_swe/README.md | 32 +++-- .../scale_swe/apply_golden_patch.py | 14 +-- resources_servers/scale_swe/client.py | 4 +- .../scale_swe/configs/scale_swe_opencode.yaml | 34 ++++++ resources_servers/scale_swe/data/.gitignore | 3 + .../scale_swe/prepare_scale_swe.py | 110 ++++++++++++++++++ .../swe_rebench/prepare_swe_rebench.py | 4 +- 7 files changed, 177 insertions(+), 24 deletions(-) create mode 100644 resources_servers/scale_swe/configs/scale_swe_opencode.yaml create mode 100644 resources_servers/scale_swe/data/.gitignore create mode 100644 resources_servers/scale_swe/prepare_scale_swe.py diff --git a/resources_servers/scale_swe/README.md b/resources_servers/scale_swe/README.md index 602cfe9abff..94ef416b762 100644 --- a/resources_servers/scale_swe/README.md +++ b/resources_servers/scale_swe/README.md @@ -42,18 +42,18 @@ The graded region of the log is delimited by markers, so setup-time noise (pip i ## Prepare the data +`prepare_scale_swe.py` only writes rows already on `data/supported_instance_ids.txt` -- the +17,696 instances (of 20,181) whose golden patch resolved in all three passes of a full-set 3x +sweep (see Golden-patch validation below). The other 2,485 are excluded because none can be +scored either way: 1,671 never resolve, 709 never produced a verdict (image pull / setup +failures, not row failures), and 105 resolve inconsistently across passes. It streams the Hub +dataset rather than loading the full split, and shuffles the kept rows (fixed seed, reproducible) +before writing, since the Hub's own row order is grouped by repo. + ```bash -# The whole set, or a bounded trial: -SCALE_SWE_LIMIT=200 python benchmarks/scale_swe/prepare.py +SCALE_SWE_LIMIT=200 python resources_servers/scale_swe/prepare_scale_swe.py ``` -`prepare.py` writes the full 20,181-row set, unfiltered. `data/supported_instance_ids.txt` is a -separate artifact for training use: the 17,696 instances (of 20,181) whose golden patch resolved -in all three passes of a full-set 3x sweep (see Golden-patch validation below). The other 2,485 -are excluded from that list because none can be scored either way: 1,671 never resolve, 709 never -produced a verdict (image pull / setup failures, not row failures), and 105 resolve -inconsistently across passes. - ## Golden-patch validation Grades each task with the dataset's own patch, which measures the dataset rather than a model. @@ -65,7 +65,7 @@ gym env start \ --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml python resources_servers/scale_swe/apply_golden_patch.py \ - +benchmark_jsonl=benchmarks/scale_swe/data/scale_swe_benchmark.jsonl \ + +training_jsonl=resources_servers/scale_swe/data/scale_swe_training.jsonl \ +limit=40 +concurrency=8 ``` @@ -82,5 +82,13 @@ from a genuinely nondeterministic test so neither silently corrupts the other's ## Running an agent -`benchmarks/scale_swe/opencode.yaml` wires this server to the opencode sandboxed agent, in the -same shape as the swebench verified/pro/multilingual and swe_rebench benchmarks. +`configs/scale_swe_opencode.yaml` wires the opencode sandboxed agent to +`scale_swe_resources_server`, pointed at `data/scale_swe_training.jsonl`. It lives in a separate +file rather than folded into `scale_swe.yaml` so golden-patch validation (which never touches an +agent) doesn't need to pull in the agent's much larger sandbox/permission config. + +```bash +gym env start \ + --config resources_servers/scale_swe/configs/scale_swe_opencode.yaml \ + --config responses_api_models/vllm_model/configs/vllm_model.yaml +``` diff --git a/resources_servers/scale_swe/apply_golden_patch.py b/resources_servers/scale_swe/apply_golden_patch.py index 347baf1b5a0..0378c1b0e5e 100644 --- a/resources_servers/scale_swe/apply_golden_patch.py +++ b/resources_servers/scale_swe/apply_golden_patch.py @@ -22,7 +22,7 @@ --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml python resources_servers/scale_swe/apply_golden_patch.py \ - +benchmark_jsonl=benchmarks/scale_swe/data/scale_swe_benchmark.jsonl \ + +training_jsonl=resources_servers/scale_swe/data/scale_swe_training.jsonl \ +output_jsonl=results/scale_swe_golden_patch.jsonl \ +concurrency=32 +limit=100 """ @@ -53,14 +53,14 @@ def _stream_examples(path: Path, limit: int): - """Yield rows lazily rather than materialising the whole benchmark file. + """Yield rows lazily rather than materialising the whole training file. Smaller than SWE-rebench (20,181 rows vs 32,079), but the same shape of problem: loading every row into memory just to feed a bounded worker pool wastes that memory for the whole run, and the peak lands hours in once results have also accumulated. """ - with open(path, encoding="utf-8") as benchmark: - for index, line in enumerate(benchmark): + with open(path, encoding="utf-8") as training: + for index, line in enumerate(training): if limit and index >= limit: return line = line.strip() @@ -72,10 +72,10 @@ async def main() -> None: config = get_global_config_dict() limit = int(config.get("limit") or 0) concurrency = int(config.get("concurrency") or 16) - benchmark_fpath = Path(config["benchmark_jsonl"]) + training_fpath = Path(config["training_jsonl"]) output_fpath = Path(config.get("output_jsonl") or "results/scale_swe_golden_patch.jsonl") - total = sum(1 for _ in _stream_examples(benchmark_fpath, limit)) + total = sum(1 for _ in _stream_examples(training_fpath, limit)) client = ServerClient.load_from_global_config() # Bounded: the queue holds at most one row per worker, so resident rows track concurrency @@ -144,7 +144,7 @@ async def worker() -> None: queue.task_done() workers = [asyncio.create_task(worker()) for _ in range(concurrency)] - for example in _stream_examples(benchmark_fpath, limit): + for example in _stream_examples(training_fpath, limit): await queue.put(example) for _ in workers: await queue.put(None) diff --git a/resources_servers/scale_swe/client.py b/resources_servers/scale_swe/client.py index 44df8d51cfd..c2daa543491 100644 --- a/resources_servers/scale_swe/client.py +++ b/resources_servers/scale_swe/client.py @@ -35,8 +35,8 @@ async def main() -> None: config = get_global_config_dict() - with open(config["benchmark_jsonl"], encoding="utf-8") as benchmark: - example = json.loads(next(benchmark)) + with open(config["training_jsonl"], encoding="utf-8") as training: + example = json.loads(next(training)) example |= {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} client = ServerClient.load_from_global_config() diff --git a/resources_servers/scale_swe/configs/scale_swe_opencode.yaml b/resources_servers/scale_swe/configs/scale_swe_opencode.yaml new file mode 100644 index 00000000000..5893e14f70c --- /dev/null +++ b/resources_servers/scale_swe/configs/scale_swe_opencode.yaml @@ -0,0 +1,34 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Wires the opencode sandboxed agent to scale_swe_resources_server for a training run -- +# `scale_swe.yaml` alone only defines the resources server, which is enough for golden-patch +# validation (apply_golden_patch.py talks to it directly, no agent involved) but not enough to +# actually run an agent against the dataset. This is a separate file, not folded into +# scale_swe.yaml, so golden-patch validation keeps working without pulling in the agent's (much +# larger) opencode/sandbox config. +# +# This is training data (data/scale_swe_training.jsonl, only the 17,696 already-supported +# instances -- see the README), not a fixed eval benchmark. +# +# gym env start --config resources_servers/scale_swe/configs/scale_swe_opencode.yaml + +config_paths: + - responses_api_agents/opencode_sandboxed_agent/configs/opencode_sandboxed_agent.yaml + - resources_servers/scale_swe/configs/scale_swe.yaml + +scale_swe_opencode_sandboxed_agent: + _inherit_from: opencode_sandboxed_agent + responses_api_agents: + opencode_sandboxed_agent: + resources_server: + type: resources_servers + name: scale_swe_resources_server + datasets: + - name: scale_swe + type: train + jsonl_fpath: resources_servers/scale_swe/data/scale_swe_training.jsonl + num_repeats: 1 + # AweAI-Team/Scale-SWE has no declared license on the Hub (no license tag, empty card + # data) -- TBD rather than guessing one of the enum's real licenses. + license: TBD diff --git a/resources_servers/scale_swe/data/.gitignore b/resources_servers/scale_swe/data/.gitignore new file mode 100644 index 00000000000..275f02f7de9 --- /dev/null +++ b/resources_servers/scale_swe/data/.gitignore @@ -0,0 +1,3 @@ +# Prepared training JSONL is a large filtered slice of the Hub dataset (patch/test content for +# every supported instance). Regenerate with prepare_scale_swe.py. +*.jsonl diff --git a/resources_servers/scale_swe/prepare_scale_swe.py b/resources_servers/scale_swe/prepare_scale_swe.py new file mode 100644 index 00000000000..1cd7bdf41c4 --- /dev/null +++ b/resources_servers/scale_swe/prepare_scale_swe.py @@ -0,0 +1,110 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Prepare AweAI-Team/Scale-SWE training data for NeMo Gym, from the Hub. + +This is a training dataset, not an eval benchmark -- there is no fixed/frozen reference split, +and the output is meant to feed a training run, not to be scored against as a leaderboard. + +Writes only the rows already known to be usable: `data/supported_instance_ids.txt` (17,696 of +the Hub's 20,181 instances) is the result of a full-set 3x golden-patch sweep -- a row not on +that list either never resolves, never produced a verdict, or resolves inconsistently across +passes (see `aggregate_golden_patch.py` and the README), so it is not worth carrying into the +training jsonl at all rather than shipping a row no agent run could usefully score. + +Streams the Hub dataset and filters row-by-row rather than loading the full ~940 MB split just +to keep 88% of it -- but the *kept* rows are still buffered and shuffled (fixed seed, so re-runs +are reproducible) before writing, since the Hub's own row order is grouped by repo, not +randomised, and training on that order as-is would bias early steps toward whichever repos +happen to sort first. + + SCALE_SWE_LIMIT=200 python resources_servers/scale_swe/prepare_scale_swe.py +""" + +import json +import os +import random +from pathlib import Path + + +SHUFFLE_SEED = 0 + +DATASET_NAME = "AweAI-Team/Scale-SWE" +SUPPORTED_IDS_FPATH = Path(__file__).parent / "data" / "supported_instance_ids.txt" +OUTPUT_FPATH = Path(__file__).parent / "data" / "scale_swe_training.jsonl" + +AGENT_REF = {"type": "responses_api_agents", "name": "scale_swe_opencode_sandboxed_agent"} + +# The Hub row's own fields this server's request model reads (see app.py's +# ScaleSWEInstanceRequest) -- extras like `github_url`/`parent_commit`/`pr_commit`/`user` are +# dropped rather than carried through unused. FAIL_TO_PASS/PASS_TO_PASS arrive as JSON-encoded +# strings, not lists, in this dataset -- kept exactly as-received, matching the request model's +# `str | list[str]` type, rather than decoded and possibly round-tripped differently. +ROW_FIELDS = ( + "instance_id", + "repo", + "language", + "workdir", + "image_url", + "patch", + "pre_commands", + "problem_statement", + "f2p_patch", + "f2p_script", + "FAIL_TO_PASS", + "PASS_TO_PASS", +) + + +def _load_supported_ids(fpath: Path) -> set[str]: + return {line.strip() for line in fpath.read_text(encoding="utf-8").splitlines() if line.strip()} + + +def prepare(supported_ids: set[str], limit: int = 0) -> Path: + from datasets import load_dataset + + OUTPUT_FPATH.parent.mkdir(parents=True, exist_ok=True) + dataset = load_dataset(DATASET_NAME, split="train", streaming=True) + + rows = [] + for example in dataset: + if limit and len(rows) >= limit: + break + if example["instance_id"] not in supported_ids: + continue + + row = {field: example[field] for field in ROW_FIELDS} + row["responses_create_params"] = {"input": [{"role": "user", "content": row["problem_statement"]}]} + row["agent_ref"] = AGENT_REF + + rows.append(row) + + random.Random(SHUFFLE_SEED).shuffle(rows) + + with OUTPUT_FPATH.open("w", encoding="utf-8") as fout: + for row in rows: + fout.write(json.dumps(row) + "\n") + + print(f"Wrote {len(rows)} Scale-SWE problems to {OUTPUT_FPATH} (shuffled, seed={SHUFFLE_SEED})") + missing = len(supported_ids) - len(rows) + if missing: + print(f" {missing} supported id(s) from {SUPPORTED_IDS_FPATH.name} were not found in the Hub dataset") + return OUTPUT_FPATH + + +if __name__ == "__main__": + prepare( + _load_supported_ids(SUPPORTED_IDS_FPATH), + int(os.environ.get("SCALE_SWE_LIMIT") or 0), + ) diff --git a/resources_servers/swe_rebench/prepare_swe_rebench.py b/resources_servers/swe_rebench/prepare_swe_rebench.py index 61e71ec3ac2..49bfd443792 100644 --- a/resources_servers/swe_rebench/prepare_swe_rebench.py +++ b/resources_servers/swe_rebench/prepare_swe_rebench.py @@ -45,9 +45,7 @@ SUPPORTED_IDS_FPATH = Path(__file__).parent / "data" / "supported_instance_ids.txt" OUTPUT_FPATH = Path(__file__).parent / "data" / "swe_rebench_training.jsonl" -# Matches this server's own `allowed_agents` (see configs/swe_rebench.yaml) -- the same -# convention other resources servers' training jsonls use to say which agent a row runs under. -AGENT_REF = {"type": "responses_api_agents", "name": "opencode_sandboxed_agent"} +AGENT_REF = {"type": "responses_api_agents", "name": "swe_rebench_opencode_sandboxed_agent"} # The Hub row's own sentinel for "this task adds no new interface" -- confirmed exact and stable # (no near-duplicate phrasing) across a 5,000-row sample of the dataset. From 60820723525f562ecb9bc0600eaff3523a833e60 Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Sun, 13 Sep 2026 10:58:14 -0700 Subject: [PATCH 06/29] feat: add verifier for swerebenchv2 Signed-off-by: Sugam Devare --- resources_servers/swe_rebench/app.py | 48 ++++++++++++++++++- resources_servers/swe_rebench/verification.py | 44 +++++++++++++++++ 2 files changed, 90 insertions(+), 2 deletions(-) diff --git a/resources_servers/swe_rebench/app.py b/resources_servers/swe_rebench/app.py index 1a397ca5d15..48c9866ee03 100644 --- a/resources_servers/swe_rebench/app.py +++ b/resources_servers/swe_rebench/app.py @@ -25,6 +25,7 @@ import sys from pathlib import Path +from shlex import quote from time import time from traceback import format_exc from typing import Any @@ -50,6 +51,7 @@ VerificationInputs, VerificationResult, as_command_list, + drop_patch_sections, repo_directory, run_verification, verification_files, @@ -131,6 +133,7 @@ class SWERebenchResourcesServer(SimpleResourcesServer): def model_post_init(self, context: Any, /) -> None: super().model_post_init(context) self._session_id_to_sandbox: dict[str, AsyncSandbox] = {} + self._session_id_to_pristine_untracked: dict[str, frozenset[str]] = {} @property def _parser_cache_dir(self) -> Path: @@ -202,21 +205,62 @@ async def _stop_sandbox(self, sandbox: AsyncSandbox | None) -> None: except Exception: print("Failed to stop SWE-rebench sandbox", format_exc(), file=sys.stderr) + async def _pristine_untracked_files(self, sandbox: AsyncSandbox, workdir: str) -> frozenset[str]: + """List of files ``workdir`` holds untracked before the agent touches it.""" + try: + result = await sandbox.exec(f"git -C {quote(workdir)} ls-files --others --exclude-standard") + if result.return_code != 0: + print(f"Failed to list pristine untracked files: {result.stderr}", file=sys.stderr) + return frozenset() + return frozenset(line.strip() for line in (result.stdout or "").splitlines() if line.strip()) + except Exception: + print("Failed to list pristine untracked files", format_exc(), file=sys.stderr) + return frozenset() + + async def _extract_model_patch(self, session_id: str, workdir: str, base_commit: str) -> str: + """Diff the agent's own sandbox against ``base_commit``, then stop it. + + ``git add -N`` (intent-to-add) is what makes brand-new files show up in ``git diff`` too, + not just edits to already-tracked files -- without it, a task an agent solves entirely by + adding new files would extract as an empty patch. + """ + original_sandbox = self._session_id_to_sandbox.pop(session_id) + pristine_untracked = self._session_id_to_pristine_untracked.pop(session_id, frozenset()) + try: + result = await original_sandbox.exec( + f"git -C {quote(workdir)} add -N . && git -C {quote(workdir)} --no-pager diff {quote(base_commit)}" + ) + if result.return_code != 0: + raise RuntimeError(result.stderr or "git diff failed") + return drop_patch_sections(result.stdout or "", pristine_untracked) + finally: + await self._stop_sandbox(original_sandbox) + async def seed_session( self, request: Request, body: SWERebenchSeedSessionRequest ) -> SWERebenchSeedSessionResponse: """Start the instance's image so an agent can work in it.""" session_id = request.session[SESSION_ID_KEY] await self._stop_sandbox(self._session_id_to_sandbox.pop(session_id, None)) + self._session_id_to_pristine_untracked.pop(session_id, None) sandbox = await self._create_sandbox(body) + self._session_id_to_pristine_untracked[session_id] = await self._pristine_untracked_files( + sandbox, repo_directory(body.repo) + ) self._session_id_to_sandbox[session_id] = sandbox return SWERebenchSeedSessionResponse(sandbox_handle=str(sandbox.sandbox_id)) async def verify(self, request: Request, body: SWERebenchVerifyRequest) -> SWERebenchVerifyResponse: + session_id = request.session[SESSION_ID_KEY] + extraction_error = None if self.config.is_verifying_golden_patch: patch = body.patch else: - patch = str(getattr(body, "model_patch", "") or "") + try: + patch = await self._extract_model_patch(session_id, repo_directory(body.repo), body.base_commit) + except Exception as exc: + patch = "" + extraction_error = f"Failed to extract model patch: {exc}" inputs = self._inputs(body, patch) log_dir = Path(__file__).parent / "logs" / body.instance_id @@ -308,7 +352,7 @@ async def verify(self, request: Request, body: SWERebenchVerifyRequest) -> SWERe "language": body.language, "test_results": result.test_results, "test_output": result.test_output[-100_000:], - "error": result.error, + "error": extraction_error or result.error, "eval_sandbox_start_time_taken": start_time_taken, "patch_verification_time_taken": verification_time_taken, } diff --git a/resources_servers/swe_rebench/verification.py b/resources_servers/swe_rebench/verification.py index b99e1fc8b34..01d3c71cb02 100644 --- a/resources_servers/swe_rebench/verification.py +++ b/resources_servers/swe_rebench/verification.py @@ -67,6 +67,50 @@ def repo_directory(repo: str) -> str: return "/" + (repo.split("/", 1)[1] if "/" in repo else repo) +def patch_section_path(section: str) -> str | None: + """Return the repository-relative path one ``diff --git`` section targets.""" + a_path: str | None = None + b_path: str | None = None + for line in section.splitlines(): + if line.startswith("@@"): + break + if line.startswith("--- ") and a_path is None: + value = line[4:].strip() + a_path = None if value == "/dev/null" else value.removeprefix("a/") + elif line.startswith("+++ ") and b_path is None: + value = line[4:].strip() + b_path = None if value == "/dev/null" else value.removeprefix("b/") + + if b_path or a_path: + return b_path or a_path + + header = re.match(r"^diff --git a/(.+?) b/(.+)$", section.splitlines()[0] if section else "") + return header.group(2) if header else None + + +def drop_patch_sections(patch: str, paths: Iterable[str]) -> str: + """Drop the diff sections targeting ``paths``. + + ``git add -N . && git diff`` picks up every untracked file, including ones that were already + untracked before the agent touched anything (build artifacts, caches). Excluding those paths + keeps the extracted patch to what the agent actually changed. + """ + dropped = set(paths) + if not patch or not dropped: + return patch + + kept: list[str] = [] + for section in re.split(r"(?=^diff --git )", patch, flags=re.MULTILINE): + if not section.strip(): + continue + path = patch_section_path(section) + if path is not None and path in dropped: + continue + kept.append(section) + + return "".join(kept) + + @dataclass class VerificationInputs: instance_id: str From 4e04e911243305ec2c6ae421ea556dd3b1eee360 Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Sun, 13 Sep 2026 12:17:30 -0700 Subject: [PATCH 07/29] feat: update scale swe verifier Signed-off-by: Sugam Devare --- resources_servers/scale_swe/app.py | 77 ++++++++++++++++++++- resources_servers/scale_swe/verification.py | 49 ++++++++++++- 2 files changed, 121 insertions(+), 5 deletions(-) diff --git a/resources_servers/scale_swe/app.py b/resources_servers/scale_swe/app.py index b10242f064e..8f24c15d585 100644 --- a/resources_servers/scale_swe/app.py +++ b/resources_servers/scale_swe/app.py @@ -28,6 +28,7 @@ the dataset-health check: a row whose golden patch does not resolve is a broken row. """ +import shlex import sys from pathlib import Path from time import time @@ -54,6 +55,8 @@ VerificationInputs, VerificationResult, as_id_list, + clean_commands, + drop_patch_sections, run_verification, verification_files, ) @@ -121,6 +124,8 @@ class ScaleSWEResourcesServer(SimpleResourcesServer): def model_post_init(self, context: Any, /) -> None: super().model_post_init(context) self._session_id_to_sandbox: dict[str, AsyncSandbox] = {} + self._session_id_to_pristine_untracked: dict[str, frozenset[str]] = {} + self._session_id_to_base_commit: dict[str, str] = {} def _inputs(self, body: ScaleSWEInstanceRequest, patch: str) -> VerificationInputs: return VerificationInputs( @@ -180,19 +185,85 @@ async def _stop_sandbox(self, sandbox: AsyncSandbox | None) -> None: except Exception: print("Failed to stop Scale-SWE sandbox", format_exc(), file=sys.stderr) + async def _pristine_untracked_files(self, sandbox: AsyncSandbox, workdir: str) -> frozenset[str]: + """List of files ``workdir`` holds untracked before the agent touches it.""" + try: + result = await sandbox.exec(f"git -C {shlex.quote(workdir)} ls-files --others --exclude-standard") + if result.return_code != 0: + print(f"Failed to list pristine untracked files: {result.stderr}", file=sys.stderr) + return frozenset() + return frozenset(line.strip() for line in (result.stdout or "").splitlines() if line.strip()) + except Exception: + print("Failed to list pristine untracked files", format_exc(), file=sys.stderr) + return frozenset() + + async def _extract_model_patch(self, session_id: str, workdir: str, base_commit: str) -> str: + """Diff the agent's own sandbox against ``base_commit``, then stop it. + + ``git add -N`` (intent-to-add) is what makes brand-new files show up in ``git diff`` too, + not just edits to already-tracked files. + """ + original_sandbox = self._session_id_to_sandbox.pop(session_id) + pristine_untracked = self._session_id_to_pristine_untracked.pop(session_id, frozenset()) + try: + result = await original_sandbox.exec( + f"git -C {shlex.quote(workdir)} add -N . " + f"&& git -C {shlex.quote(workdir)} --no-pager diff {shlex.quote(base_commit)}" + ) + if result.return_code != 0: + raise RuntimeError(result.stderr or "git diff failed") + return drop_patch_sections(result.stdout or "", pristine_untracked) + finally: + await self._stop_sandbox(original_sandbox) + async def seed_session(self, request: Request, body: ScaleSWESeedSessionRequest) -> ScaleSWESeedSessionResponse: - """Start the instance's image so an agent can work in it.""" + """Start the instance's image, then run ``pre_commands`` so the agent sees the prepared + checkout (parent_commit, fix-commit history scrubbed) rather than the image's raw, + unprepared state -- ``pre_commands`` used to only run inside the eval script at /verify + time, which left an agent's own working session never actually checked out to the right + commit at all. + """ session_id = request.session[SESSION_ID_KEY] await self._stop_sandbox(self._session_id_to_sandbox.pop(session_id, None)) + self._session_id_to_pristine_untracked.pop(session_id, None) + self._session_id_to_base_commit.pop(session_id, None) + sandbox = await self._create_sandbox(body) + + pre = clean_commands(body.pre_commands) + if pre: + result = await sandbox.exec(f"cd {shlex.quote(body.workdir)} && {pre}") + if result.return_code != 0: + print( + f"[scale_swe] {body.instance_id}: pre_commands failed during seed_session " + f"(non-fatal, matching build_eval_script's own tolerance): {result.stderr}", + file=sys.stderr, + ) + + head_result = await sandbox.exec(f"git -C {shlex.quote(body.workdir)} rev-parse HEAD") + self._session_id_to_base_commit[session_id] = (head_result.stdout or "").strip() + self._session_id_to_pristine_untracked[session_id] = await self._pristine_untracked_files( + sandbox, body.workdir + ) self._session_id_to_sandbox[session_id] = sandbox return ScaleSWESeedSessionResponse(sandbox_handle=str(sandbox.sandbox_id)) async def verify(self, request: Request, body: ScaleSWEVerifyRequest) -> ScaleSWEVerifyResponse: + session_id = request.session[SESSION_ID_KEY] + extraction_error = None if self.config.is_verifying_golden_patch: patch = body.patch else: - patch = str(getattr(body, "model_patch", "") or "") + base_commit = self._session_id_to_base_commit.pop(session_id, "") + if not base_commit: + patch = "" + extraction_error = "Failed to extract model patch: no base commit recorded (seed_session did not run for this session)" + else: + try: + patch = await self._extract_model_patch(session_id, body.workdir, base_commit) + except Exception as exc: + patch = "" + extraction_error = f"Failed to extract model patch: {exc}" inputs = self._inputs(body, patch) log_dir = Path(__file__).parent / "logs" / body.instance_id @@ -258,7 +329,7 @@ async def verify(self, request: Request, body: ScaleSWEVerifyRequest) -> ScaleSW "language": body.language, "test_results": result.test_results, "test_output": result.test_output[-100_000:], - "error": result.error, + "error": extraction_error or result.error, "eval_sandbox_start_time_taken": start_time_taken, "patch_verification_time_taken": verification_time_taken, } diff --git a/resources_servers/scale_swe/verification.py b/resources_servers/scale_swe/verification.py index 6e5f8ae444a..7295bfbf586 100644 --- a/resources_servers/scale_swe/verification.py +++ b/resources_servers/scale_swe/verification.py @@ -27,6 +27,7 @@ import asyncio import json +import re import shlex from dataclasses import dataclass, field from pathlib import Path @@ -137,11 +138,55 @@ class VerificationResult: error: str | None = None -def _clean_commands(value: str) -> str: +def clean_commands(value: str) -> str: """``pre_commands`` ends with a literal backslash-n in the published data.""" return value.replace("\\n", "\n").strip() +def patch_section_path(section: str) -> str | None: + """Return the repository-relative path one ``diff --git`` section targets.""" + a_path: str | None = None + b_path: str | None = None + for line in section.splitlines(): + if line.startswith("@@"): + break + if line.startswith("--- ") and a_path is None: + value = line[4:].strip() + a_path = None if value == "/dev/null" else value.removeprefix("a/") + elif line.startswith("+++ ") and b_path is None: + value = line[4:].strip() + b_path = None if value == "/dev/null" else value.removeprefix("b/") + + if b_path or a_path: + return b_path or a_path + + header = re.match(r"^diff --git a/(.+?) b/(.+)$", section.splitlines()[0] if section else "") + return header.group(2) if header else None + + +def drop_patch_sections(patch: str, paths: Iterable[str]) -> str: + """Drop the diff sections targeting ``paths``. + + ``git add -N . && git diff`` picks up every untracked file, including ones that were already + untracked before the agent touched anything. Excluding those paths keeps the extracted patch + to what the agent actually changed. + """ + dropped = set(paths) + if not patch or not dropped: + return patch + + kept: list[str] = [] + for section in re.split(r"(?=^diff --git )", patch, flags=re.MULTILINE): + if not section.strip(): + continue + path = patch_section_path(section) + if path is not None and path in dropped: + continue + kept.append(section) + + return "".join(kept) + + def build_eval_script(inputs: VerificationInputs) -> str: """The script run inside the sandbox. @@ -151,7 +196,7 @@ def build_eval_script(inputs: VerificationInputs) -> str: files = unique_test_files(list(inputs.fail_to_pass) + list(inputs.pass_to_pass)) pytest_targets = " ".join(shlex.quote(path) for path in files) - pre = _clean_commands(inputs.pre_commands) + pre = clean_commands(inputs.pre_commands) apply_patch = ( "git apply --reject --recount --ignore-space-change --whitespace=nowarn /tmp/nemo_gym_patch.diff || true" if inputs.patch.strip() From fae4e4b6d16cb4dab43e593514c429c1d4ca191f Mon Sep 17 00:00:00 2001 From: Sugam Devare Date: Sun, 13 Sep 2026 12:21:51 -0700 Subject: [PATCH 08/29] feat: add swemerv2 Signed-off-by: Sugam Devare --- resources_servers/swemer_v2/.gitignore | 2 + resources_servers/swemer_v2/README.md | 199 ++++++ resources_servers/swemer_v2/__init__.py | 0 .../swemer_v2/aggregate_golden_patch.py | 136 ++++ resources_servers/swemer_v2/app.py | 328 +++++++++ .../swemer_v2/apply_golden_patch.py | 160 +++++ resources_servers/swemer_v2/client.py | 52 ++ .../swemer_v2/configs/swemer_v2.yaml | 69 ++ .../swemer_v2/configs/swemer_v2_opencode.yaml | 33 + resources_servers/swemer_v2/data/.gitignore | 3 + .../swemer_v2/diagnose_failures.py | 234 +++++++ resources_servers/swemer_v2/requirements.txt | 1 + resources_servers/swemer_v2/tests/__init__.py | 0 .../swemer_v2/tests/fixtures/go_output.txt | 301 ++++++++ .../swemer_v2/tests/fixtures/jest_output.txt | 322 +++++++++ .../swemer_v2/tests/fixtures/manifest.json | 450 ++++++++++++ .../swemer_v2/tests/fixtures/mocha_output.txt | 61 ++ .../tests/fixtures/pytest_output.txt | 222 ++++++ .../tests/fixtures/vitest_output.txt | 2 + resources_servers/swemer_v2/tests/test_app.py | 637 +++++++++++++++++ resources_servers/swemer_v2/verification.py | 644 ++++++++++++++++++ 21 files changed, 3856 insertions(+) create mode 100644 resources_servers/swemer_v2/.gitignore create mode 100644 resources_servers/swemer_v2/README.md create mode 100644 resources_servers/swemer_v2/__init__.py create mode 100644 resources_servers/swemer_v2/aggregate_golden_patch.py create mode 100644 resources_servers/swemer_v2/app.py create mode 100644 resources_servers/swemer_v2/apply_golden_patch.py create mode 100644 resources_servers/swemer_v2/client.py create mode 100644 resources_servers/swemer_v2/configs/swemer_v2.yaml create mode 100644 resources_servers/swemer_v2/configs/swemer_v2_opencode.yaml create mode 100644 resources_servers/swemer_v2/data/.gitignore create mode 100644 resources_servers/swemer_v2/diagnose_failures.py create mode 100644 resources_servers/swemer_v2/requirements.txt create mode 100644 resources_servers/swemer_v2/tests/__init__.py create mode 100644 resources_servers/swemer_v2/tests/fixtures/go_output.txt create mode 100644 resources_servers/swemer_v2/tests/fixtures/jest_output.txt create mode 100644 resources_servers/swemer_v2/tests/fixtures/manifest.json create mode 100644 resources_servers/swemer_v2/tests/fixtures/mocha_output.txt create mode 100644 resources_servers/swemer_v2/tests/fixtures/pytest_output.txt create mode 100644 resources_servers/swemer_v2/tests/fixtures/vitest_output.txt create mode 100644 resources_servers/swemer_v2/tests/test_app.py create mode 100644 resources_servers/swemer_v2/verification.py diff --git a/resources_servers/swemer_v2/.gitignore b/resources_servers/swemer_v2/.gitignore new file mode 100644 index 00000000000..c39f6d3d27c --- /dev/null +++ b/resources_servers/swemer_v2/.gitignore @@ -0,0 +1,2 @@ +# This is where verification logs are stored locally +logs diff --git a/resources_servers/swemer_v2/README.md b/resources_servers/swemer_v2/README.md new file mode 100644 index 00000000000..5053c3fef5b --- /dev/null +++ b/resources_servers/swemer_v2/README.md @@ -0,0 +1,199 @@ +# Swemer Agentic-v2 resources server + +Verification for Swemer's Agentic-v2 SWE task packages: real GitHub PRs turned into +software-engineering tasks, each with its own prebuilt image, held-out tests, and a golden +patch. + +Unlike the other SWE resources servers, this dataset is **not on the Hub**: it is internal, and +images are pinned to a private per-task ECR tag rather than a public registry. There is no +prepare script here and no reference to any internal filesystem path -- `data/swemer_v2_training.jsonl` +is a fixed, self-contained row-per-task JSONL distributed offline. Each row carries `image_ref`, +`patch`/`test_patch`, `test_framework`/`test_command`, FAIL_TO_PASS/PASS_TO_PASS, +`responses_create_params`, and `agent_ref`, and only holds instances whose golden patch resolved +in all three passes of a full-set 3x sweep (see Golden-patch validation below). + +Sandboxes come from `nemo_gym.sandbox`, so the same server runs on OpenSandbox or any other +configured provider. Images pull directly from ECR (`SandboxImageSpec`/auth is not needed here — +the cluster's OpenSandbox pods have pull access to the private registry). + +## Grading is framework-specific, not just language-specific + +Every row ships its own hand-authored `test_command` — there is no per-language template like +Scale-SWE/SWE-rebench have. The dataset authors ran the actual suite once and recorded +FAIL_TO_PASS/PASS_TO_PASS ids in whatever format that specific invocation happened to print, so +the id format is framework-specific and sometimes inconsistent even within one framework (see +`verification.py`'s module docstring for the exact shapes observed for pytest/go/jest/mocha/ +vitest). + +`test_command` frequently does not already request structured output — only about half of +jest/go rows do, and mocha/vitest are mostly plain text. `inject_output_flags` forces it on +(`-rA`, `-json`, `--json`, `--reporter json`, `--reporter=json`) rather than trusting each task's +author to have set it, appending rather than inserting: every sampled command runs the test +tool as the last step in its `&&` chain, and all four CLIs here take the last occurrence of a +repeated flag. + +Each of the five parsers was written and pinned against real captured output — one task per +framework, golden patch applied, run for real inside a live OpenSandbox pod against the task's +actual image — not against assumptions about a tool's JSON schema. The fixtures live in +`tests/fixtures/` (`{framework}_output.txt` + `manifest.json` for the FAIL_TO_PASS/PASS_TO_PASS +ids) and `TestFrameworkParsersAgainstRealCapturedOutput` in `tests/test_app.py` asserts each one +grades as `resolved` (a golden patch is expected to pass), which is an end-to-end check that the +flag injection and the parser agree with what actually happened. Two non-obvious things the real +captures caught that synthetic fixtures would not have: + +- jest/vitest print their normal human-readable console report BEFORE the `--json`/ + `--reporter=json` blob, not instead of it, and that report can contain a bare `{` from source + code inside a test title — so `_extract_json_object` cannot just take the first (or first + parseable) `{`; it requires the parsed object to carry one of the report's own top-level keys + (`testResults` for jest/vitest, `passes`/`failures`/`pending` for mocha). +- `npx`/`npm` print an update-notice banner AFTER the real JSON on the same stream, so a plain + `json.loads` over the whole captured region fails on genuinely valid output. + +A 25-row golden-patch pilot through the live resources server (not just isolated parser calls — +real sandboxes, real `verify()` responses) caught three more bugs the five single-task fixtures +above did not, because none of those five happened to exercise the shape that broke: + +- **pytest class-qualified ids.** The dataset's id (`tests.pkg.mod.TestFoo::test_x`) can't be + turned into a real node id by a fixed dots-to-slashes rule — there's no way to tell a + module-path dot from a class-name dot in the dotted string alone. Fixed by matching the other + direction: real node ids out of the output are flattened into the dataset's own convention + and compared, never the reverse. 8 of 12 pytest pilot rows were false negatives from this. +- **Old pytest, no `-rA` support.** `-rA`'s `A` (all) category was only added in pytest 3.6 + (2018); a task pinned to pytest 3.3.2 silently swallowed the flag and never printed the + summary section this parser relied on — 198/198 real passes read as 0 observed. Fixed by also + matching plain `-v`'s inline ` STATUS [ NN%]` lines whenever the summary shape doesn't + match, not as an explicit fallback mode. +- **mocha's third id shape.** A real file-path prefix (`/workspace/repo/.../Swap.js::title`, + distinct from both the empty-prefix `::title` and bare `title` shapes already handled) fell + through unmatched. + +Pilot resolve rate after these fixes: 22/25 (88%) — pytest 10/12, go 6/6, jest 4/4, mocha 2/3. +2 of the 3 that didn't resolve turned out to still be a parser bug, not a dataset issue as first +assessed: a `FAIL_TO_PASS` id prefix relative to a WIDER root than the real node id pytest prints +(e.g. `cd tests && pytest test_x.py`, real id `test_x.py::...`, dataset id assumes +`tests.test_x::...`) — see "More bugs, found only by full-set runs" below for the fix. +1 mocha-labeled row actually runs via Karma (a browser test runner wrapping mocha, not the mocha +CLI `inject_output_flags` targets), correctly surfaces as `evaluation_completed: false` with a +clear parse-failure `error` rather than being silently mis-graded either way — this one is a +genuine dataset/framework-label mismatch, not fixable by a parser change. + +## More bugs, found only by full-set runs + +Three full 2,738-row sweeps (not the 25-row pilot, and not the five single-task fixtures) found +five more real bugs — each confirmed against live full-set evidence before shipping, and each +validated offline against every affected row (not just a handful) to rule out regressions before +the next rerun: + +- **pytest suffix-matching was one-directional.** The pilot's fix (matching a real node id's + suffix against the dataset's dotted id) only handled the dataset id being SHORTER than the real + path (a missing leading package directory). It missed the opposite: `test_command` doing + `cd .../master && pytest ...` means the real node id never contains `master`, but the + dataset's own id does (`master.buildbot....TestConnection::test_x`) — a dataset id LONGER than + any real path could confirm. Fixed by matching on the longest common SUFFIX regardless of which + side is longer, rather than requiring one side to fit inside the other. +- **A pytest teardown `ERROR` silently downgraded a real pass.** All 5 `getsentry-sentry-*` rows + in one delivery printed every target id as both `PASSED ` (the test's own body ran + correctly) and, later in the same `-rA` summary, `ERROR ` from an unrelated teardown-phase + fixture (a file-descriptor-count assertion, consistent with a sandbox artifact, not anything + the golden patch touched). Plain last-line-wins graded all of these fully-passing golden + patches as fully unresolved. Fixed narrowly: `ERROR` never downgrades an already-recorded + `PASSED` for the same id, but a genuine rerun `FAILED` still does (a real verdict on the test, + unlike `ERROR`). +- **A trailing `)` corrupts a command the same way a trailing bare `exit` does.** + `getsentry-sentry-javascript-11564-agentic-v2`'s command chains several `(cd pkg && ...)` + subshells with `;`; appending `--json` after the last `)` is a bash syntax error regardless of + what preceded it. Folded into the same trailing-shape guard as the bare-`exit` case. +- **`go test` appearing more than once in one command only got `-json` on the first occurrence.** + `erigontech-erigon-14994-agentic-v2` runs `go test -v` twice (`;`-separated, one per package); + `str.replace(..., count=1)` left the second invocation — where this row's own FAIL_TO_PASS ids + actually lived — as plain text `_parse_go` could never match. Fixed by replacing every + occurrence, validated safe across all 15 multi-invocation go rows in the dataset (the other 14 + already resolved via their first invocation alone, so this is purely additive for them). +- **`--outputFile=` writes the JSON report to a file, not stdout.** Several vitest/jest rows + already request `--outputFile=`; the harness only captures stdout, so the report was never + visible to the parser regardless of which reporter flag was requested. 5 of 8 vitest rows using + `--outputFile=` in one full-set run had no JSON anywhere in captured output for exactly this + reason. Fixed by appending `; cat 2>/dev/null || true`, safe to add unconditionally + (including for rows whose own script already reads the file back some other way, since a + redundant `cat` of the same content changes nothing for the parser). + +The mocha fix is larger than a one-line parser change: roughly a third of mocha rows' +`test_command` wraps mocha inside the project's own runner script (`ts-node`, `jake`, a custom +`npm` script) rather than invoking the mocha CLI directly, so the appended `--reporter json` +lands on the wrapper's argv, not mocha's, and the run falls back to mocha's default `spec` text +reporter. 29 of 49 non-karma mocha rows with no JSON output in one full-set run were exactly +this: a real, fully-passing run with unambiguous per-test checkmarks. `_parse_mocha` now falls +back to scanning `✔`/`✓` checkmark lines when no JSON reporter object exists at all. Only passing +tests are extracted this way — a target id absent from the text already grades as failing, which +is correct for a title mocha never printed, so there was no need to (and no real captured +failing-block example to) parse mocha's numbered failure blocks. + +## Phase 1: 5 of ~20 frameworks + +The tree spans roughly 20 `test_framework` values. Only `pytest`, `go`, `jest`, `mocha`, and +`vitest` are supported (`verification.SUPPORTED_FRAMEWORKS`) — about 73% of the ~3,800 locally +available tasks. These were chosen because each has either a built-in structured-output flag or +a parser with a well-understood id format. The rest are excluded because grading them correctly +is a real open problem, not a parser someone hasn't gotten around to writing yet: + +- **maven/junit** (~558 tasks): `FAIL_TO_PASS` ids are often opaque surrogate tokens like + `"fe-core::test_7"` that do not correspond to any Maven/Gradle/JUnit-native identifier. +- **cargo** (~253 tasks): default `nextest` text output, parseable but not yet implemented. +- **gtest/ctest/cppunit and a long tail** (~220 tasks): many `test_command`s are ad hoc one-off + scripts, not a real test-framework invocation — one example just greps the source file for a + function name and prints `OK`/`FAIL`. + +Unsupported-framework tasks are dropped before `data/swemer_v2_training.jsonl` is built, so this +server never has to grade them. + +## The data + +`data/swemer_v2_training.jsonl` is a fixed, self-contained row-per-task JSONL, distributed +offline (not generated by any script in this repo, and gitignored -- see `data/.gitignore`: rows +embed patch and test content from an internal dataset, which is exactly what cannot be committed +here). This is training data, not a fixed eval benchmark -- there is no frozen reference split, +and it only holds the instances whose golden patch resolved in all three passes of a full-set 3x +sweep (see Golden-patch validation below) -- the same 2,538 instance ids as +`data/supported_instance_ids.txt`. + +## Golden-patch validation + +Grades each task with the dataset's own patch, which measures the dataset rather than a model. +A row whose golden patch does not resolve cannot be used for evaluation or training. + +```bash +gym env start \ + --config resources_servers/swemer_v2/configs/swemer_v2.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml + +python resources_servers/swemer_v2/apply_golden_patch.py \ + +training_jsonl=resources_servers/swemer_v2/data/swemer_v2_training.jsonl \ + +limit=40 +concurrency=8 +``` + +It prints a resolved rate overall and per framework, and writes one row per task. +`diagnose_failures.py` separates environment failures (OOM, disk, network, timeout, no-verdict, +zero-tests-collected) from genuine row failures. `aggregate_golden_patch.py` joins repeated +golden-patch passes (e.g. a 3x sweep) into supported / flaky / broken / inconclusive buckets, +keeping an infra fault (no verdict) separate from a genuinely nondeterministic test so neither +silently corrupts the other's label. + +`data/supported_instance_ids.txt` is the result of one such sweep over the full Phase 1 set: +2,538 of 2,738 instances whose golden patch resolved in all three passes of a concurrency=1024 +3x sweep. `data/swemer_v2_training.jsonl` holds exactly those rows. The other 200 are excluded +because none can be scored either way: 137 never resolve, 35 never produced a verdict in any pass +(image pull / setup failures, concentrated in mocha and jest/typescript rows), and 28 resolve +inconsistently across passes (flaky tests, concentrated in go). + +## Running an agent + +`configs/swemer_v2_opencode.yaml` wires the opencode sandboxed agent to +`swemer_v2_resources_server`, pointed at `data/swemer_v2_training.jsonl`. It lives in a separate +file rather than folded into `swemer_v2.yaml` so golden-patch validation (which never touches an +agent) doesn't need to pull in the agent's much larger sandbox/permission config. + +```bash +gym env start \ + --config resources_servers/swemer_v2/configs/swemer_v2_opencode.yaml \ + --config responses_api_models/vllm_model/configs/vllm_model.yaml +``` diff --git a/resources_servers/swemer_v2/__init__.py b/resources_servers/swemer_v2/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/swemer_v2/aggregate_golden_patch.py b/resources_servers/swemer_v2/aggregate_golden_patch.py new file mode 100644 index 00000000000..e95aaea7415 --- /dev/null +++ b/resources_servers/swemer_v2/aggregate_golden_patch.py @@ -0,0 +1,136 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Join repeated golden-patch passes into the set of rows that are actually usable. + +A row is SUPPORTED when its golden patch resolved in every pass. That is the point of +repeating: a row that resolves only sometimes has a nondeterministic test, and its reward is +noise whether it is used for evaluation or for training. + +The one distinction that matters, and the reason this is not a single boolean: a pass can fail +to produce a verdict at all (image pull, timeout, provider fault). That is evidence about the +infrastructure, not about the row. Collapsing the two would discard good tasks for an unrelated +hiccup, so incomplete passes are counted separately and those rows are reported as needing more +evidence rather than as broken. + + python resources_servers/swemer_v2/aggregate_golden_patch.py \ + +runs=results/swemer_v2_golden_patch_full \ + +output_jsonl=results/swemer_v2_supported.jsonl +""" + +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + +from nemo_gym.global_config import get_global_config_dict + + +def _rows(path: Path): + with path.open(encoding="utf-8") as handle: + for line in handle: + line = line.strip() + if line: + try: + yield json.loads(line) + except json.JSONDecodeError: + continue + + +def classify(observations: list[dict[str, Any]], expected_passes: int) -> str: + """Bucket one row from its per-pass observations.""" + completed = [o for o in observations if o.get("evaluation_completed")] + resolved = sum(1 for o in completed if o.get("resolved")) + + if len(completed) < expected_passes: + # Not enough verdicts to judge the row. Distinguished from a genuine failure so an + # image-pull fault does not quietly delete a usable task. + return "inconclusive" + if resolved == len(completed): + return "supported" + if resolved == 0: + return "broken" + return "flaky" + + +def main() -> None: + config = get_global_config_dict() + runs_dir = Path(config["runs"]) + output_fpath = Path(config.get("output_jsonl") or "results/swemer_v2_supported.jsonl") + + pass_files = sorted(p for p in runs_dir.glob("*.jsonl") if p.is_file()) + if not pass_files: + raise SystemExit(f"no pass jsonl files under {runs_dir}") + + by_instance: dict[str, list[dict[str, Any]]] = defaultdict(list) + language: dict[str, str] = {} + for pass_file in pass_files: + for row in _rows(pass_file): + instance_id = row.get("instance_id") + if not instance_id or instance_id == "?": + continue + by_instance[instance_id].append(row) + if row.get("language"): + language[instance_id] = row["language"] + + expected = len(pass_files) + buckets: Counter[str] = Counter() + per_language: dict[str, Counter[str]] = defaultdict(Counter) + + output_fpath.parent.mkdir(parents=True, exist_ok=True) + with output_fpath.open("w", encoding="utf-8") as out: + for instance_id, observations in sorted(by_instance.items()): + verdict = classify(observations, expected) + buckets[verdict] += 1 + per_language[language.get(instance_id, "unknown")][verdict] += 1 + out.write( + json.dumps( + { + "instance_id": instance_id, + "language": language.get(instance_id, ""), + "verdict": verdict, + "passes_observed": len(observations), + "passes_completed": sum(1 for o in observations if o.get("evaluation_completed")), + "passes_resolved": sum(1 for o in observations if o.get("resolved")), + "expected_passes": expected, + } + ) + + "\n" + ) + + total = sum(buckets.values()) + print(f"golden-patch aggregation over {total} row(s) from {expected} pass(es)\n") + for verdict, description in ( + ("supported", "resolved in every pass - usable"), + ("flaky", "resolved in some passes only - nondeterministic test"), + ("broken", "never resolved - golden patch does not work"), + ("inconclusive", "too few verdicts - re-run before judging"), + ): + count = buckets.get(verdict, 0) + print(f" {verdict:<13} {count:>6} ({100 * count / max(total, 1):5.1f}%) {description}") + + print("\n by language (supported / total):") + for lang, counts in sorted(per_language.items(), key=lambda kv: -sum(kv[1].values())): + rows_total = sum(counts.values()) + supported = counts.get("supported", 0) + print( + f" {lang:<10} {supported:>5} / {rows_total:<6} ({100 * supported / rows_total:5.1f}%)" + f" flaky={counts.get('flaky', 0)} broken={counts.get('broken', 0)}" + f" inconclusive={counts.get('inconclusive', 0)}" + ) + print(f"\nper-row verdicts: {output_fpath}") + + +if __name__ == "__main__": + main() diff --git a/resources_servers/swemer_v2/app.py b/resources_servers/swemer_v2/app.py new file mode 100644 index 00000000000..4abb66707be --- /dev/null +++ b/resources_servers/swemer_v2/app.py @@ -0,0 +1,328 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Resources server for Swemer's Agentic-v2 SWE task packages. + +Unlike SWE-rebench/Scale-SWE, the dataset is not on the Hub: it is internal, and images are +pinned by a delivery-specific ECR tag rather than a public registry. There is no prepare script +here -- ``data/swemer_v2_training.jsonl`` is distributed offline (see the README). + +Every task carries its own prebuilt image with ``/workspace/repo`` checked out at the task's +base commit. Verification: apply the candidate patch and the dataset's held-out ``test_patch``, +run the row's own ``test_command`` (adjusted to force machine-parseable output where the +framework allows it -- see ``verification.inject_output_flags``), and grade FAIL_TO_PASS / +PASS_TO_PASS from the parsed output. ``test_framework`` selects the parser; unsupported +frameworks are rejected at prepare time rather than silently mis-graded (see +``verification.SUPPORTED_FRAMEWORKS``). + +Set ``is_verifying_golden_patch: true`` to grade the dataset's own patch instead of an agent's, +the dataset-health check: a row whose golden patch does not resolve is a broken row. +""" + +import shlex +import sys +from pathlib import Path +from time import time +from traceback import format_exc +from typing import Any + +from fastapi import Request +from pydantic import BaseModel, ConfigDict + +from nemo_gym.base_resources_server import ( + BaseResourcesServerConfig, + BaseSeedSessionRequest, + BaseSeedSessionResponse, + BaseVerifyRequest, + BaseVerifyResponse, + SimpleResourcesServer, +) +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.sandbox import AsyncSandbox, SandboxResources, SandboxSpec +from nemo_gym.sandbox.config import resolve_provider_config, resolve_provider_metadata +from nemo_gym.sandbox.utils import cpu_cap_env +from nemo_gym.server_utils import SESSION_ID_KEY, is_nemo_gym_fastapi_entrypoint +from resources_servers.swemer_v2.verification import ( + VerificationInputs, + VerificationResult, + drop_patch_sections, + run_verification, + verification_files, +) + + +class SwemerV2ResourcesServerConfig(BaseResourcesServerConfig): + is_verifying_golden_patch: bool = False + evaluation_timeout: int | None = 1200 + # A verdict-less run is retried on a fresh sandbox: an image pull or a flaky provider start + # is not evidence about the patch. + inconclusive_verification_retries: int = 1 + sandbox_provider: str + sandbox_config: dict[str, Any] + + +class SwemerV2InstanceRequest(BaseModel): + """One row of ``data/swemer_v2_training.jsonl``, a Swemer Agentic-v2 task package.""" + + model_config = ConfigDict(extra="allow") + + instance_id: str + delivery: str = "" + language: str = "" + workdir: str = "/workspace/repo" + image_ref: str + patch: str = "" + test_patch: str = "" + problem_statement: str = "" + test_framework: str + test_command: str + FAIL_TO_PASS: list[str] = [] + PASS_TO_PASS: list[str] = [] + + +class SwemerV2SeedSessionRequest(SwemerV2InstanceRequest, BaseSeedSessionRequest): + sandbox_spec: dict[str, Any] | None = None + + +class SwemerV2SeedSessionResponse(BaseSeedSessionResponse): + sandbox_handle: str + + +class SwemerV2VerifyRequest(SwemerV2InstanceRequest, BaseVerifyRequest): + pass + + +class SwemerV2VerifyResponse(BaseVerifyResponse): + evaluation_completed: bool + resolved: bool + patch_applied: bool + instance_id: str + language: str + test_framework: str + test_results: dict[str, Any] | None + test_output: str + error: str | None + eval_sandbox_start_time_taken: float + patch_verification_time_taken: float + + +class SwemerV2ResourcesServer(SimpleResourcesServer): + config: SwemerV2ResourcesServerConfig + + def model_post_init(self, context: Any, /) -> None: + super().model_post_init(context) + self._session_id_to_sandbox: dict[str, AsyncSandbox] = {} + self._session_id_to_pristine_untracked: dict[str, frozenset[str]] = {} + self._session_id_to_base_commit: dict[str, str] = {} + + def _inputs(self, body: SwemerV2InstanceRequest, patch: str) -> VerificationInputs: + return VerificationInputs( + instance_id=body.instance_id, + workdir=body.workdir, + patch=patch, + test_patch=body.test_patch, + test_framework=body.test_framework, + test_command=body.test_command, + fail_to_pass=list(body.FAIL_TO_PASS), + pass_to_pass=list(body.PASS_TO_PASS), + ) + + async def _create_sandbox( + self, body: SwemerV2InstanceRequest, files: dict[str, str] | None = None + ) -> AsyncSandbox: + global_config_dict = get_global_config_dict() + provider_config = resolve_provider_config(self.config.sandbox_provider, global_config_dict) + provider_metadata = resolve_provider_metadata(self.config.sandbox_provider, global_config_dict) + + # Several frameworks in scope (go test, cargo, mvn/gradle) spawn their own worker pools + # sized off the visible core count, which is the HOST count, not the cgroup quota. + sandbox_resources = SandboxResources.from_mapping(self.config.sandbox_config.get("resources", {})) + env = dict(self.config.sandbox_config.get("env", {})) + if self.config.sandbox_config.get("derive_cpu_env", True): + env = cpu_cap_env(sandbox_resources.cpu) | env + + spec = SandboxSpec( + # The row names its own image; there is no repository template to apply. + image=body.image_ref, + ttl_s=self.config.sandbox_config.get("ttl_s"), + ready_timeout_s=self.config.sandbox_config.get("ready_timeout_s"), + workdir=body.workdir, + env=env, + files=files or {}, + metadata=provider_metadata + | self.config.sandbox_config.get("metadata", {}) + | { + "nemo_gym_agent": self.config.name, + "instance_id": body.instance_id[:63], + }, + resources=sandbox_resources, + provider_options=self.config.sandbox_config.get("provider_options", {}), + ) + sandbox = AsyncSandbox(provider_config) + await sandbox.start(spec) + return sandbox + + async def _stop_sandbox(self, sandbox: AsyncSandbox | None) -> None: + if sandbox is None: + return + try: + await sandbox.stop() + except Exception: + print("Failed to stop Swemer-v2 sandbox", format_exc(), file=sys.stderr) + + async def _pristine_untracked_files(self, sandbox: AsyncSandbox, workdir: str) -> frozenset[str]: + """List of files ``workdir`` holds untracked before the agent touches it.""" + try: + result = await sandbox.exec(f"git -C {shlex.quote(workdir)} ls-files --others --exclude-standard") + if result.return_code != 0: + print(f"Failed to list pristine untracked files: {result.stderr}", file=sys.stderr) + return frozenset() + return frozenset(line.strip() for line in (result.stdout or "").splitlines() if line.strip()) + except Exception: + print("Failed to list pristine untracked files", format_exc(), file=sys.stderr) + return frozenset() + + async def _extract_model_patch(self, session_id: str, workdir: str, base_commit: str) -> str: + """Diff the agent's own sandbox against ``base_commit``, then stop it. + + ``git add -N`` (intent-to-add) is what makes brand-new files show up in ``git diff`` too, + not just edits to already-tracked files. + """ + original_sandbox = self._session_id_to_sandbox.pop(session_id) + pristine_untracked = self._session_id_to_pristine_untracked.pop(session_id, frozenset()) + try: + result = await original_sandbox.exec( + f"git -C {shlex.quote(workdir)} add -N . " + f"&& git -C {shlex.quote(workdir)} --no-pager diff {shlex.quote(base_commit)}" + ) + if result.return_code != 0: + raise RuntimeError(result.stderr or "git diff failed") + return drop_patch_sections(result.stdout or "", pristine_untracked) + finally: + await self._stop_sandbox(original_sandbox) + + async def seed_session(self, request: Request, body: SwemerV2SeedSessionRequest) -> SwemerV2SeedSessionResponse: + """Start the instance's image so an agent can work in it.""" + session_id = request.session[SESSION_ID_KEY] + await self._stop_sandbox(self._session_id_to_sandbox.pop(session_id, None)) + self._session_id_to_pristine_untracked.pop(session_id, None) + self._session_id_to_base_commit.pop(session_id, None) + + sandbox = await self._create_sandbox(body) + + head_result = await sandbox.exec(f"git -C {shlex.quote(body.workdir)} rev-parse HEAD") + self._session_id_to_base_commit[session_id] = (head_result.stdout or "").strip() + self._session_id_to_pristine_untracked[session_id] = await self._pristine_untracked_files( + sandbox, body.workdir + ) + self._session_id_to_sandbox[session_id] = sandbox + return SwemerV2SeedSessionResponse(sandbox_handle=str(sandbox.sandbox_id)) + + async def verify(self, request: Request, body: SwemerV2VerifyRequest) -> SwemerV2VerifyResponse: + session_id = request.session[SESSION_ID_KEY] + extraction_error = None + if self.config.is_verifying_golden_patch: + patch = body.patch + else: + base_commit = self._session_id_to_base_commit.pop(session_id, "") + if not base_commit: + patch = "" + extraction_error = "Failed to extract model patch: no base commit recorded (seed_session did not run for this session)" + else: + try: + patch = await self._extract_model_patch(session_id, body.workdir, base_commit) + except Exception as exc: + patch = "" + extraction_error = f"Failed to extract model patch: {exc}" + + inputs = self._inputs(body, patch) + log_dir = Path(__file__).parent / "logs" / body.instance_id + + files = verification_files(inputs) + attempts = 1 + max(self.config.inconclusive_verification_retries, 0) + start_time_taken = 0.0 + verification_time_taken = 0.0 + result = VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output="", + error="unattempted", + ) + for attempt in range(1, attempts + 1): + sandbox: AsyncSandbox | None = None + started = time() + try: + sandbox = await self._create_sandbox(body, files=files) + start_time_taken = time() - started + verification_started = time() + result = await run_verification( + sandbox=sandbox, + inputs=inputs, + timeout_s=self.config.evaluation_timeout, + log_dir=log_dir, + ) + verification_time_taken = time() - verification_started + except Exception as exc: + start_time_taken = time() - started + verification_time_taken = 0.0 + result = VerificationResult( + completed=False, + resolved=False, + patch_applied=False, + test_results=None, + test_output="", + error=f"Verification failed: {exc}", + ) + finally: + await self._stop_sandbox(sandbox) + if result.completed: + break + if attempt < attempts: + print( + f"[swemer_v2] {body.instance_id}: inconclusive ({result.error}); " + f"retrying on a fresh sandbox ({attempt}/{attempts - 1})", + flush=True, + ) + + return SwemerV2VerifyResponse.model_validate( + body.model_dump() + | { + # An unresolved-but-completed run is a real 0. An incomplete run is also 0, but + # evaluation_completed distinguishes them so a broken row is not read as a hard task. + "reward": 1.0 if result.resolved else 0.0, + "evaluation_completed": result.completed, + "resolved": result.resolved, + "patch_applied": result.patch_applied, + "instance_id": body.instance_id, + "language": body.language, + "test_framework": body.test_framework, + "test_results": result.test_results, + "test_output": result.test_output[-100_000:], + "error": extraction_error or result.error, + "eval_sandbox_start_time_taken": start_time_taken, + "patch_verification_time_taken": verification_time_taken, + } + ) + + +if __name__ == "__main__": + SwemerV2ResourcesServer.run_webserver() +elif is_nemo_gym_fastapi_entrypoint(__file__): + # Required whenever num_workers > 1. Multi-worker uvicorn re-imports this entrypoint BY PATH + # in each forked child and expects a module-level `app`; without it every child exits, and + # uvicorn responds by stopping the parent. The server then never binds, so the symptom is not + # an import error but a flood of connection failures from clients talking to a dead port. + app = SwemerV2ResourcesServer.run_webserver() # noqa: F401 diff --git a/resources_servers/swemer_v2/apply_golden_patch.py b/resources_servers/swemer_v2/apply_golden_patch.py new file mode 100644 index 00000000000..07345a0e31c --- /dev/null +++ b/resources_servers/swemer_v2/apply_golden_patch.py @@ -0,0 +1,160 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Grade every task with the dataset's own golden patch. + +This measures the dataset, not a model. A row whose golden patch does not make FAIL_TO_PASS +pass is unusable for evaluation or training, so this is the check to run before trusting any +score from Swemer-v2. + + gym env start --config resources_servers/swemer_v2/configs/swemer_v2.yaml \ + --config nemo_gym/sandbox/providers/opensandbox/configs/opensandbox.yaml + + python resources_servers/swemer_v2/apply_golden_patch.py \ + +training_jsonl=resources_servers/swemer_v2/data/swemer_v2_training.jsonl \ + +output_jsonl=results/swemer_v2_golden_patch.jsonl \ + +concurrency=32 +limit=100 +""" + +import asyncio +import json +from collections import Counter +from pathlib import Path + +from tqdm.auto import tqdm + +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.server_utils import ServerClient + + +EMPTY_RESPONSE = { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], +} + +SERVER_NAME = "swemer_v2_golden_patch_resources_server" + + +def _stream_examples(path: Path, limit: int): + """Yield rows lazily rather than materialising the whole training file.""" + with open(path, encoding="utf-8") as training: + for index, line in enumerate(training): + if limit and index >= limit: + return + line = line.strip() + if line: + yield json.loads(line) + + +async def main() -> None: + config = get_global_config_dict() + limit = int(config.get("limit") or 0) + concurrency = int(config.get("concurrency") or 16) + training_fpath = Path(config["training_jsonl"]) + output_fpath = Path(config.get("output_jsonl") or "results/swemer_v2_golden_patch.jsonl") + + total = sum(1 for _ in _stream_examples(training_fpath, limit)) + client = ServerClient.load_from_global_config() + + # Bounded: the queue holds at most one row per worker, so resident rows track concurrency + # rather than dataset size. + queue: asyncio.Queue = asyncio.Queue(maxsize=concurrency) + resolved = 0 + incomplete = 0 + by_framework: Counter[str] = Counter() + resolved_by_framework: Counter[str] = Counter() + finished = 0 + + output_fpath.parent.mkdir(parents=True, exist_ok=True) + progress = tqdm(total=total, desc="golden patch") + + with output_fpath.open("w", encoding="utf-8") as output: + + async def worker() -> None: + nonlocal resolved, incomplete, finished + while True: + example = await queue.get() + if example is None: + queue.task_done() + return + try: + payload = example | {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} + try: + response = await client.post(server_name=SERVER_NAME, url_path="/verify", json=payload) + result = await response.json() + except Exception as exc: + # One unreachable task must not abandon the sweep; record it and carry on. + result = { + "instance_id": example.get("instance_id", "?"), + "test_framework": example.get("test_framework", ""), + "resolved": False, + "evaluation_completed": False, + "error": f"request failed: {exc}", + } + if not isinstance(result, dict): + # Gym middleware returns repr(exc) as a bare JSON string when a handler + # raises, so a server-side fault arrives as a str. + result = { + "instance_id": example.get("instance_id", "?"), + "test_framework": example.get("test_framework", ""), + "resolved": False, + "evaluation_completed": False, + "error": f"server returned a non-object response: {str(result)[:300]}", + } + + framework = str(result.get("test_framework") or example.get("test_framework") or "unknown") + by_framework[framework] += 1 + if result.get("resolved"): + resolved += 1 + resolved_by_framework[framework] += 1 + if not result.get("evaluation_completed", False): + incomplete += 1 + output.write(json.dumps(result) + "\n") + finished += 1 + if finished % 50 == 0: + output.flush() # a multi-hour run must leave usable rows if it is cut short + progress.update(1) + progress.set_description( + f"resolved {resolved}/{finished} ({100 * resolved / max(finished, 1):.1f}%) " + f"incomplete={incomplete}" + ) + finally: + queue.task_done() + + workers = [asyncio.create_task(worker()) for _ in range(concurrency)] + for example in _stream_examples(training_fpath, limit): + await queue.put(example) + for _ in workers: + await queue.put(None) + await asyncio.gather(*workers) + + progress.close() + print(f"\ngolden-patch validation over {total} task(s)") + print(f" resolved: {resolved}/{total} ({100 * resolved / max(total, 1):.1f}%)") + print(f" incomplete: {incomplete}/{total} (no verdict: image pull, timeout, or setup failure)") + print("\n by framework (resolved / total):") + for framework, count in by_framework.most_common(): + got = resolved_by_framework[framework] + print(f" {framework:<10} {got:>5} / {count:<6} ({100 * got / count:5.1f}%)") + print(f"\nper-task rows: {output_fpath}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/resources_servers/swemer_v2/client.py b/resources_servers/swemer_v2/client.py new file mode 100644 index 00000000000..e83fe43ab91 --- /dev/null +++ b/resources_servers/swemer_v2/client.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Verify a single Swemer-v2 row, for a quick smoke test of the server.""" + +import asyncio +import json + +from nemo_gym.global_config import get_global_config_dict +from nemo_gym.server_utils import ServerClient + + +EMPTY_RESPONSE = { + "output": [], + "id": "", + "created_at": 0, + "model": "", + "object": "response", + "parallel_tool_calls": False, + "tool_choice": "auto", + "tools": [], +} + + +async def main() -> None: + config = get_global_config_dict() + with open(config["training_jsonl"], encoding="utf-8") as training: + example = json.loads(next(training)) + example |= {"responses_create_params": {"input": []}, "response": EMPTY_RESPONSE} + + client = ServerClient.load_from_global_config() + result = await client.post( + server_name=config.get("resources_server_name", "swemer_v2_golden_patch_resources_server"), + url_path="/verify", + json=example, + ) + print(json.dumps(await result.json(), indent=4)) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/resources_servers/swemer_v2/configs/swemer_v2.yaml b/resources_servers/swemer_v2/configs/swemer_v2.yaml new file mode 100644 index 00000000000..a9ff676e853 --- /dev/null +++ b/resources_servers/swemer_v2/configs/swemer_v2.yaml @@ -0,0 +1,69 @@ +# Resources server for Swemer's Agentic-v2 SWE task packages. +# +# Unlike the other SWE resources servers, rows are NOT prepared from a public dataset: this is an +# internal dataset, distributed offline as data/swemer_v2_training.jsonl. See the README. +# +# Phase 1 covers 5 of ~20 test_framework values seen in the tree -- pytest, go, jest, mocha, +# vitest (~73% of locally available tasks) -- chosen because each has either a built-in +# structured-output flag (go -json, jest/mocha/vitest --json-style reporters) or a proven parser +# (pytest, via the same -rA strategy as Scale-SWE). The rest (maven/junit, cargo, the C/C++ +# family, and a long tail of one-off frameworks) have either opaque surrogate test ids or ad hoc +# per-task verification scripts and are rejected at prepare time rather than silently mis-graded +# -- see verification.SUPPORTED_FRAMEWORKS. +swemer_v2_resources_server: + resources_servers: + swemer_v2: + allowed_agents: [opencode_sandboxed_agent] + entrypoint: app.py + domain: coding + verified: false + + evaluation_timeout: 1800 + is_verifying_golden_patch: false + + sandbox_provider: sandbox + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + # Phase 1 spans Go builds and npm-installed JS/TS suites (jest/mocha/vitest), which are + # install/compile-bound like SWE-rebench's non-Python rows -- same sizing as that server. + resources: + cpu: 8 + memory_mib: 30720 + disk_gib: 30 + provider_options: + resource_requests: + cpu: 1 + memory_mib: 4096 + disk_gib: 30 + metadata: + benchmark: swemer-v2 + +# Golden-patch validation: grade the dataset's own patch instead of an agent's. A row whose +# golden patch does not resolve is a broken row, and scoring an agent against it measures noise. +# Run it with resources_servers/swemer_v2/apply_golden_patch.py. +swemer_v2_golden_patch_resources_server: + resources_servers: + swemer_v2: + entrypoint: app.py + domain: coding + verified: false + + evaluation_timeout: 1800 + is_verifying_golden_patch: true + + sandbox_provider: sandbox + sandbox_config: + ttl_s: 18000 + ready_timeout_s: 1200 + resources: + cpu: 8 + memory_mib: 30720 + disk_gib: 30 + provider_options: + resource_requests: + cpu: 1 + memory_mib: 4096 + disk_gib: 30 + metadata: + benchmark: swemer-v2-golden-patch diff --git a/resources_servers/swemer_v2/configs/swemer_v2_opencode.yaml b/resources_servers/swemer_v2/configs/swemer_v2_opencode.yaml new file mode 100644 index 00000000000..24cc1f6e994 --- /dev/null +++ b/resources_servers/swemer_v2/configs/swemer_v2_opencode.yaml @@ -0,0 +1,33 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Wires the opencode sandboxed agent to swemer_v2_resources_server for a training run -- +# `swemer_v2.yaml` alone only defines the resources server, which is enough for golden-patch +# validation (apply_golden_patch.py talks to it directly, no agent involved) but not enough to +# actually run an agent against the dataset. This is a separate file, not folded into +# swemer_v2.yaml, so golden-patch validation keeps working without pulling in the agent's (much +# larger) opencode/sandbox config. +# +# data/swemer_v2_training.jsonl is distributed offline (not generated by any script in this +# repo -- this is an internal dataset), and holds only the 2,538 instances whose golden patch +# resolved in all three passes of a full-set 3x sweep -- see the README. +# +# gym env start --config resources_servers/swemer_v2/configs/swemer_v2_opencode.yaml + +config_paths: + - responses_api_agents/opencode_sandboxed_agent/configs/opencode_sandboxed_agent.yaml + - resources_servers/swemer_v2/configs/swemer_v2.yaml + +swemer_v2_opencode_sandboxed_agent: + _inherit_from: opencode_sandboxed_agent + responses_api_agents: + opencode_sandboxed_agent: + resources_server: + type: resources_servers + name: swemer_v2_resources_server + datasets: + - name: swemer_v2 + type: train + jsonl_fpath: resources_servers/swemer_v2/data/swemer_v2_training.jsonl + num_repeats: 1 + license: NVIDIA Internal Use Only, Do Not Distribute diff --git a/resources_servers/swemer_v2/data/.gitignore b/resources_servers/swemer_v2/data/.gitignore new file mode 100644 index 00000000000..4c9a6226ffb --- /dev/null +++ b/resources_servers/swemer_v2/data/.gitignore @@ -0,0 +1,3 @@ +# Training JSONL embeds patch/test content from an internal dataset -- not ours to redistribute +# via this repo. Distributed offline; there is no prepare script for it here. +*.jsonl diff --git a/resources_servers/swemer_v2/diagnose_failures.py b/resources_servers/swemer_v2/diagnose_failures.py new file mode 100644 index 00000000000..59844dcb061 --- /dev/null +++ b/resources_servers/swemer_v2/diagnose_failures.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Separate golden-patch failures caused by the sandbox from failures of the row itself. + +This exists because `evaluation_completed` does not answer the question. A build that is +OOM-killed, or a test suite that runs out of disk, still produces a parsed log and a verdict -- +the tests simply failed. That grades identically to a genuinely broken golden patch, so raising +the memory limit would silently change the "supported" set. + +The signatures below are read out of the captured test output, so a failure is attributed to +resources only on direct evidence, never inferred from the fact that it failed. + + python resources_servers/swemer_v2/diagnose_failures.py results/.../pass1_job_X.jsonl +""" + +from __future__ import annotations + +import argparse +import json +import sys +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +# Ordered: the first match wins, so the most specific cause is reported. +RESOURCE_SIGNATURES: tuple[tuple[str, tuple[str, ...]], ...] = ( + ( + "disk_full", + ("no space left on device", "enospc", "disk quota exceeded", "write error: no space"), + ), + ( + "oom", + ( + "out of memory", + "outofmemoryerror", + "cannot allocate memory", + "oom-kill", + "oom killed", + "killed process", + "memoryerror", + "signal: killed", + "runtime: out of memory", + "fatal error: out of memory", + "std::bad_alloc", + "exit status 137", + "javaheapspace", + "java heap space", + "gc overhead limit exceeded", + ), + ), + ( + "process_killed", + # A bare SIGKILL with no allocator message. Usually the cgroup OOM killer, but the + # evidence is weaker, so it is reported separately rather than folded into `oom`. + ("killed", "sigkill", "terminated by signal 9"), + ), + ( + "too_many_files", + ("too many open files", "emfile"), + ), + ( + "network", + # NOT "the sandbox has no internet" -- it does; Go, npm and composer all fetch + # successfully in the same sandboxes. This is an egress fault for one toolchain, most + # often a JVM on a dual-stack network preferring an IPv6 address it has no route to. + # Either way it is an environment problem, not evidence that the golden patch is wrong. + ( + "could not resolve host", + "connection refused", + "network is unreachable", + "temporary failure in name resolution", + "etimedout", + "econnreset", + "proxyconnect", + ), + ), +) + + +def classify_output(text: str) -> str | None: + """Return the resource cause evidenced in the output, or None.""" + lowered = text.lower() + for label, needles in RESOURCE_SIGNATURES: + if any(needle in lowered for needle in needles): + return label + return None + + +def _rows(path: Path): + with path.open(encoding="utf-8") as handle: + for line in handle: + line = line.strip() + if line: + try: + yield json.loads(line) + except json.JSONDecodeError: + continue + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("rollouts_jsonl", type=Path) + parser.add_argument( + "--timeout-s", + type=float, + default=1200.0, + help="The configured evaluation timeout; runs within --near of it are treated as timing out.", + ) + parser.add_argument("--near", type=float, default=0.9, help="Fraction of the timeout that counts as 'near'.") + parser.add_argument("--show", type=int, default=4, help="Example instance ids to print per cause.") + args = parser.parse_args() + + if not args.rollouts_jsonl.exists(): + print(f"no such file: {args.rollouts_jsonl}", file=sys.stderr) + return 2 + + total = 0 + resolved = 0 + failures: list[dict[str, Any]] = [] + durations: list[float] = [] + + for row in _rows(args.rollouts_jsonl): + total += 1 + duration = float(row.get("patch_verification_time_taken") or 0.0) + durations.append(duration) + if row.get("resolved"): + resolved += 1 + continue + failures.append(row) + + if total == 0: + print("no rows", file=sys.stderr) + return 2 + + causes: Counter[str] = Counter() + examples: dict[str, list[str]] = defaultdict(list) + by_language: dict[str, Counter[str]] = defaultdict(Counter) + + for row in failures: + instance_id = str(row.get("instance_id") or "?") + language = str(row.get("language") or "unknown") + duration = float(row.get("patch_verification_time_taken") or 0.0) + output = str(row.get("test_output") or "") + error = str(row.get("error") or "") + + if not row.get("evaluation_completed", False): + cause = "no_verdict" + elif duration >= args.timeout_s * args.near: + # Ran to (or near) the ceiling. With CPU requests well below limits this is the + # shape CPU starvation takes: the work is not wrong, it just never finished. + cause = "timeout" + elif (row.get("test_results") or {}).get("tests_observed", 0) == 0 and (row.get("test_results") is not None): + # The parser saw zero tests, so nothing ran: the build or setup died before the + # suite started. Parser-agnostic, and a different thing from "the tests failed". + # Most often dependency drift -- an image pinned months ago resolving today's + # packages, e.g. cargo pulling a crate that needs a newer edition than its + # toolchain supports. The golden patch is not implicated either way. + cause = classify_output(output + "\n" + error) or "no_tests_ran" + else: + cause = classify_output(output + "\n" + error) or "row_failure" + + causes[cause] += 1 + by_language[language][cause] += 1 + if len(examples[cause]) < args.show: + examples[cause].append(f"{instance_id} ({language}, {duration:.0f}s)") + + # Causes that are about the environment rather than the row. `no_tests_ran` is included: + # a suite that never started says nothing about whether the golden patch is correct. + resource_causes = { + "oom", + "disk_full", + "process_killed", + "too_many_files", + "network", + "timeout", + "no_verdict", + "no_tests_ran", + } + resource_total = sum(count for cause, count in causes.items() if cause in resource_causes) + + print(f"rows: {total} resolved: {resolved} ({100 * resolved / total:.1f}%) failures: {len(failures)}") + if durations: + ordered = sorted(durations) + p50 = ordered[len(ordered) // 2] + p95 = ordered[min(len(ordered) - 1, int(len(ordered) * 0.95))] + print( + f"verification seconds: p50={p50:.0f} p95={p95:.0f} max={ordered[-1]:.0f} (timeout {args.timeout_s:.0f})" + ) + print() + print("failure attribution:") + for cause, count in causes.most_common(): + marker = "ENV" if cause in resource_causes else "row" + share = 100 * count / max(len(failures), 1) + print(f" {cause:<16} {count:>5} ({share:5.1f}% of failures) [{marker}]") + for example in examples[cause]: + print(f" e.g. {example}") + + print() + if not failures: + print("VERDICT: no failures to attribute") + elif resource_total == 0: + print("VERDICT: no failure shows resource evidence — these look like genuine row failures.") + print(" Raising sandbox limits would not change the supported set.") + else: + share = 100 * resource_total / len(failures) + print( + f"VERDICT: {resource_total}/{len(failures)} failures ({share:.1f}%) show resource or environment evidence." + ) + print(" Raise the relevant limit and re-measure before treating these rows as broken.") + + if by_language: + print("\n per-language failure causes:") + for language, counts in sorted(by_language.items(), key=lambda kv: -sum(kv[1].values())): + summary = " ".join(f"{cause}={count}" for cause, count in counts.most_common()) + print(f" {language:<10} {summary}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/resources_servers/swemer_v2/requirements.txt b/resources_servers/swemer_v2/requirements.txt new file mode 100644 index 00000000000..2c9ef83ea2a --- /dev/null +++ b/resources_servers/swemer_v2/requirements.txt @@ -0,0 +1 @@ +-e nemo-gym[dev,sandbox] @ ../.. diff --git a/resources_servers/swemer_v2/tests/__init__.py b/resources_servers/swemer_v2/tests/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/resources_servers/swemer_v2/tests/fixtures/go_output.txt b/resources_servers/swemer_v2/tests/fixtures/go_output.txt new file mode 100644 index 00000000000..a33613675de --- /dev/null +++ b/resources_servers/swemer_v2/tests/fixtures/go_output.txt @@ -0,0 +1,301 @@ + +{"Time":"2026-09-11T01:43:41.817166634Z","Action":"start","Package":"github.com/ogen-go/ogen/gen"} +{"Time":"2026-09-11T01:43:41.819776791Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific"} +{"Time":"2026-09-11T01:43:41.819794669Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific","Output":"=== RUN Test_filterMostSpecific\n"} +{"Time":"2026-09-11T01:43:41.819817833Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test1"} +{"Time":"2026-09-11T01:43:41.819819642Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test1","Output":"=== RUN Test_filterMostSpecific/Test1\n"} +{"Time":"2026-09-11T01:43:41.819831248Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test1","Output":"--- PASS: Test_filterMostSpecific/Test1 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819834759Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test1","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819846761Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test2"} +{"Time":"2026-09-11T01:43:41.819848836Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test2","Output":"=== RUN Test_filterMostSpecific/Test2\n"} +{"Time":"2026-09-11T01:43:41.819852213Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test2","Output":"--- PASS: Test_filterMostSpecific/Test2 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819854979Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test2","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819857701Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test3"} +{"Time":"2026-09-11T01:43:41.819859074Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test3","Output":"=== RUN Test_filterMostSpecific/Test3\n"} +{"Time":"2026-09-11T01:43:41.819868652Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test3","Output":"--- PASS: Test_filterMostSpecific/Test3 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819870904Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test3","Elapsed":0} +{"Time":"2026-09-11T01:43:41.81987325Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test4"} +{"Time":"2026-09-11T01:43:41.819874639Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test4","Output":"=== RUN Test_filterMostSpecific/Test4\n"} +{"Time":"2026-09-11T01:43:41.819883895Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test4","Output":"--- PASS: Test_filterMostSpecific/Test4 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819885824Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test4","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819888696Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test5"} +{"Time":"2026-09-11T01:43:41.819890104Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test5","Output":"=== RUN Test_filterMostSpecific/Test5\n"} +{"Time":"2026-09-11T01:43:41.819899814Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test5","Output":"--- PASS: Test_filterMostSpecific/Test5 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819901664Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test5","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819907641Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test6"} +{"Time":"2026-09-11T01:43:41.819910028Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test6","Output":"=== RUN Test_filterMostSpecific/Test6\n"} +{"Time":"2026-09-11T01:43:41.819912528Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test6","Output":"--- PASS: Test_filterMostSpecific/Test6 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819914929Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test6","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819916976Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test7"} +{"Time":"2026-09-11T01:43:41.819918429Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test7","Output":"=== RUN Test_filterMostSpecific/Test7\n"} +{"Time":"2026-09-11T01:43:41.819930078Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test7","Output":"--- PASS: Test_filterMostSpecific/Test7 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819931926Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test7","Elapsed":0} +{"Time":"2026-09-11T01:43:41.81993431Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test8"} +{"Time":"2026-09-11T01:43:41.819935672Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test8","Output":"=== RUN Test_filterMostSpecific/Test8\n"} +{"Time":"2026-09-11T01:43:41.819952016Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test8","Output":"--- PASS: Test_filterMostSpecific/Test8 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819953763Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test8","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819956655Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test9"} +{"Time":"2026-09-11T01:43:41.819957933Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test9","Output":"=== RUN Test_filterMostSpecific/Test9\n"} +{"Time":"2026-09-11T01:43:41.819967582Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test9","Output":"--- PASS: Test_filterMostSpecific/Test9 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819969343Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test9","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819971565Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test10"} +{"Time":"2026-09-11T01:43:41.819972823Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test10","Output":"=== RUN Test_filterMostSpecific/Test10\n"} +{"Time":"2026-09-11T01:43:41.819981722Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test10","Output":"--- PASS: Test_filterMostSpecific/Test10 (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819983452Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific/Test10","Elapsed":0} +{"Time":"2026-09-11T01:43:41.81998593Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific","Output":"--- PASS: Test_filterMostSpecific (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.819987474Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_filterMostSpecific","Elapsed":0} +{"Time":"2026-09-11T01:43:41.819989592Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetPathParametersUsed"} +{"Time":"2026-09-11T01:43:41.819990817Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetPathParametersUsed","Output":"=== RUN Test_vetPathParametersUsed\n"} +{"Time":"2026-09-11T01:43:41.820073596Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetPathParametersUsed","Output":" logger.go:146: 2026-09-11T01:43:41.819Z\tWARN\tPath parameter is not used\t{\"name\": \"not_used\"}\n"} +{"Time":"2026-09-11T01:43:41.820082589Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetPathParametersUsed","Output":"--- PASS: Test_vetPathParametersUsed (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.82008428Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetPathParametersUsed","Elapsed":0} +{"Time":"2026-09-11T01:43:41.820087327Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName"} +{"Time":"2026-09-11T01:43:41.820088565Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName","Output":"=== RUN Test_vetHeaderParameterName\n"} +{"Time":"2026-09-11T01:43:41.8201111Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName","Output":" logger.go:146: 2026-09-11T01:43:41.820Z\tWARN\tHeader name is not canonical, canonical name will be used\t{\"original_name\": \"content-type\", \"canonical_name\": \"Content-Type\"}\n"} +{"Time":"2026-09-11T01:43:41.820123261Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName","Output":" logger.go:146: 2026-09-11T01:43:41.820Z\tWARN\tContent-Type is described separately and will be ignored in this section\n"} +{"Time":"2026-09-11T01:43:41.82014187Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName","Output":" logger.go:146: 2026-09-11T01:43:41.820Z\tWARN\tHeader name is not canonical, canonical name will be used\t{\"original_name\": \"x-foo-bar\", \"canonical_name\": \"X-Foo-Bar\"}\n"} +{"Time":"2026-09-11T01:43:41.820144964Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName","Output":"--- PASS: Test_vetHeaderParameterName (0.00s)\n"} +{"Time":"2026-09-11T01:43:41.820148111Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_vetHeaderParameterName","Elapsed":0} +{"Time":"2026-09-11T01:43:41.820150261Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema"} +{"Time":"2026-09-11T01:43:41.820151641Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Output":"=== RUN TestGenerateSchema\n"} +{"Time":"2026-09-11T01:43:41.820415652Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/defs"} +{"Time":"2026-09-11T01:43:41.820417282Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/defs","Output":"=== RUN TestGenerateSchema/defs\n"} +{"Time":"2026-09-11T01:43:41.830433004Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/defs","Output":"--- PASS: TestGenerateSchema/defs (0.01s)\n"} +{"Time":"2026-09-11T01:43:41.83046526Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/defs","Elapsed":0.01} +{"Time":"2026-09-11T01:43:41.830612824Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/name"} +{"Time":"2026-09-11T01:43:41.830615009Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/name","Output":"=== RUN TestGenerateSchema/name\n"} +{"Time":"2026-09-11T01:43:41.836063058Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/name","Output":"--- PASS: TestGenerateSchema/name (0.01s)\n"} +{"Time":"2026-09-11T01:43:41.836067431Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/name","Elapsed":0.01} +{"Time":"2026-09-11T01:43:41.841366199Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/openapi30"} +{"Time":"2026-09-11T01:43:41.841372308Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/openapi30","Output":"=== RUN TestGenerateSchema/openapi30\n"} +{"Time":"2026-09-11T01:43:41.841483566Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Output":" logger.go:146: 2026-09-11T01:43:41.841Z\tINFO\tschemagen\tType is not defined, using any\t{\"at\": \"1192:31\", \"name\": \"SpecificationExtension\"}\n"} +{"Time":"2026-09-11T01:43:41.841821925Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Output":" logger.go:146: 2026-09-11T01:43:41.841Z\tINFO\tschemagen\tType is not defined, using any\t{\"at\": \"1190:12\", \"name\": \"Any\"}\n"} +{"Time":"2026-09-11T01:43:41.84198305Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Output":" logger.go:146: 2026-09-11T01:43:41.841Z\tINFO\tschemagen\tType is not defined, using any\t{\"at\": \"1195:20\", \"name\": \"DefaultType\"}\n"} +{"Time":"2026-09-11T01:43:41.999917272Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/openapi30","Output":"--- PASS: TestGenerateSchema/openapi30 (0.16s)\n"} +{"Time":"2026-09-11T01:43:41.999926132Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/openapi30","Elapsed":0.16} +{"Time":"2026-09-11T01:43:42.00086033Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/platform"} +{"Time":"2026-09-11T01:43:42.000862673Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/platform","Output":"=== RUN TestGenerateSchema/platform\n"} +{"Time":"2026-09-11T01:43:42.001006889Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Output":" logger.go:146: 2026-09-11T01:43:42.000Z\tINFO\tschemagen\tType is not defined, using any\t{\"at\": \"131:19\", \"name\": \"ConfigFileObjectItem\"}\n"} +{"Time":"2026-09-11T01:43:42.035181232Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/platform","Output":"--- PASS: TestGenerateSchema/platform (0.03s)\n"} +{"Time":"2026-09-11T01:43:42.035193375Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/platform","Elapsed":0.03} +{"Time":"2026-09-11T01:43:42.035382Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/recursive"} +{"Time":"2026-09-11T01:43:42.035384267Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/recursive","Output":"=== RUN TestGenerateSchema/recursive\n"} +{"Time":"2026-09-11T01:43:42.04309084Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/recursive","Output":"--- PASS: TestGenerateSchema/recursive (0.01s)\n"} +{"Time":"2026-09-11T01:43:42.043115127Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema/recursive","Elapsed":0.01} +{"Time":"2026-09-11T01:43:42.043120138Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Output":"--- PASS: TestGenerateSchema (0.22s)\n"} +{"Time":"2026-09-11T01:43:42.043122461Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSchema","Elapsed":0.22} +{"Time":"2026-09-11T01:43:42.04312686Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSecurities"} +{"Time":"2026-09-11T01:43:42.043128527Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSecurities","Output":"=== RUN TestGenerateSecurities\n"} +{"Time":"2026-09-11T01:43:42.043209232Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSecurities","Output":"--- PASS: TestGenerateSecurities (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043224563Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerateSecurities","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043227873Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNames"} +{"Time":"2026-09-11T01:43:42.043229884Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNames","Output":"=== RUN TestNames\n"} +{"Time":"2026-09-11T01:43:42.043233908Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNames","Output":"--- PASS: TestNames (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043239862Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNames","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043244108Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef"} +{"Time":"2026-09-11T01:43:42.043245565Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef","Output":"=== RUN Test_cleanRef\n"} +{"Time":"2026-09-11T01:43:42.043248055Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test0"} +{"Time":"2026-09-11T01:43:42.043249461Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test0","Output":"=== RUN Test_cleanRef/Test0\n"} +{"Time":"2026-09-11T01:43:42.043252127Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test0","Output":"--- PASS: Test_cleanRef/Test0 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043253841Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test0","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043255536Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test1"} +{"Time":"2026-09-11T01:43:42.043256818Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test1","Output":"=== RUN Test_cleanRef/Test1\n"} +{"Time":"2026-09-11T01:43:42.043259553Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test1","Output":"--- PASS: Test_cleanRef/Test1 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043261261Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test1","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043263542Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test2"} +{"Time":"2026-09-11T01:43:42.043264809Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test2","Output":"=== RUN Test_cleanRef/Test2\n"} +{"Time":"2026-09-11T01:43:42.043267945Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test2","Output":"--- PASS: Test_cleanRef/Test2 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043272596Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test2","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043274848Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test3"} +{"Time":"2026-09-11T01:43:42.043276162Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test3","Output":"=== RUN Test_cleanRef/Test3\n"} +{"Time":"2026-09-11T01:43:42.04328705Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test3","Output":"--- PASS: Test_cleanRef/Test3 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043288675Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test3","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043290831Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test4"} +{"Time":"2026-09-11T01:43:42.043292435Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test4","Output":"=== RUN Test_cleanRef/Test4\n"} +{"Time":"2026-09-11T01:43:42.043299998Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test4","Output":"--- PASS: Test_cleanRef/Test4 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043301736Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test4","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043303955Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test5"} +{"Time":"2026-09-11T01:43:42.043305302Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test5","Output":"=== RUN Test_cleanRef/Test5\n"} +{"Time":"2026-09-11T01:43:42.043311565Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test5","Output":"--- PASS: Test_cleanRef/Test5 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043315218Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test5","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043316803Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test6"} +{"Time":"2026-09-11T01:43:42.043318045Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test6","Output":"=== RUN Test_cleanRef/Test6\n"} +{"Time":"2026-09-11T01:43:42.043322037Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test6","Output":"--- PASS: Test_cleanRef/Test6 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043325085Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test6","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043327257Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test7"} +{"Time":"2026-09-11T01:43:42.043328565Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test7","Output":"=== RUN Test_cleanRef/Test7\n"} +{"Time":"2026-09-11T01:43:42.043337211Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test7","Output":"--- PASS: Test_cleanRef/Test7 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043340482Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test7","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043342005Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test8"} +{"Time":"2026-09-11T01:43:42.04334337Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test8","Output":"=== RUN Test_cleanRef/Test8\n"} +{"Time":"2026-09-11T01:43:42.043351868Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test8","Output":"--- PASS: Test_cleanRef/Test8 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043353677Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef/Test8","Elapsed":0} +{"Time":"2026-09-11T01:43:42.04335605Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef","Output":"--- PASS: Test_cleanRef (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043358361Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_cleanRef","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043360471Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums"} +{"Time":"2026-09-11T01:43:42.043361787Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums","Output":"=== RUN Test_mergeEnums\n"} +{"Time":"2026-09-11T01:43:42.043372375Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test1"} +{"Time":"2026-09-11T01:43:42.043374311Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test1","Output":"=== RUN Test_mergeEnums/Test1\n"} +{"Time":"2026-09-11T01:43:42.043383157Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test1","Output":"--- PASS: Test_mergeEnums/Test1 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043385536Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test1","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043387194Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test2"} +{"Time":"2026-09-11T01:43:42.043388514Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test2","Output":"=== RUN Test_mergeEnums/Test2\n"} +{"Time":"2026-09-11T01:43:42.043397794Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test2","Output":"--- PASS: Test_mergeEnums/Test2 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043400192Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test2","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043401724Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test3"} +{"Time":"2026-09-11T01:43:42.043403015Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test3","Output":"=== RUN Test_mergeEnums/Test3\n"} +{"Time":"2026-09-11T01:43:42.043413369Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test3","Output":"--- PASS: Test_mergeEnums/Test3 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043415694Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test3","Elapsed":0} +{"Time":"2026-09-11T01:43:42.04341714Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test4"} +{"Time":"2026-09-11T01:43:42.043418444Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test4","Output":"=== RUN Test_mergeEnums/Test4\n"} +{"Time":"2026-09-11T01:43:42.043427069Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test4","Output":"--- PASS: Test_mergeEnums/Test4 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043429503Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test4","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043432514Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test5"} +{"Time":"2026-09-11T01:43:42.043433824Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test5","Output":"=== RUN Test_mergeEnums/Test5\n"} +{"Time":"2026-09-11T01:43:42.043448077Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test5","Output":"--- PASS: Test_mergeEnums/Test5 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043450348Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test5","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043451832Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test6"} +{"Time":"2026-09-11T01:43:42.04345313Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test6","Output":"=== RUN Test_mergeEnums/Test6\n"} +{"Time":"2026-09-11T01:43:42.043464967Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test6","Output":"--- PASS: Test_mergeEnums/Test6 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043467609Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test6","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043469794Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test7"} +{"Time":"2026-09-11T01:43:42.043471058Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test7","Output":"=== RUN Test_mergeEnums/Test7\n"} +{"Time":"2026-09-11T01:43:42.043479015Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test7","Output":"--- PASS: Test_mergeEnums/Test7 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043481376Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums/Test7","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043483009Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums","Output":"--- PASS: Test_mergeEnums (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043485061Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"Test_mergeEnums","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043488088Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestSchemaGenAnyWarn"} +{"Time":"2026-09-11T01:43:42.043489414Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestSchemaGenAnyWarn","Output":"=== RUN TestSchemaGenAnyWarn\n"} +{"Time":"2026-09-11T01:43:42.043525937Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestSchemaGenAnyWarn","Output":"--- PASS: TestSchemaGenAnyWarn (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.043527738Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestSchemaGenAnyWarn","Elapsed":0} +{"Time":"2026-09-11T01:43:42.043530068Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate"} +{"Time":"2026-09-11T01:43:42.043531272Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate","Output":"=== RUN TestGenerate\n"} +{"Time":"2026-09-11T01:43:42.043539373Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate/Test_fieldTag"} +{"Time":"2026-09-11T01:43:42.043540964Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate/Test_fieldTag","Output":"=== RUN TestGenerate/Test_fieldTag\n"} +{"Time":"2026-09-11T01:43:42.045033925Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate/Test_fieldTag","Output":"--- PASS: TestGenerate/Test_fieldTag (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045036955Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate/Test_fieldTag","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045039522Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate","Output":"--- PASS: TestGenerate (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.04504094Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestGenerate","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045042322Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf"} +{"Time":"2026-09-11T01:43:42.045043577Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf","Output":"=== RUN TestSingleOneOf\n"} +{"Time":"2026-09-11T01:43:42.045052045Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf/single_oneOf_unwraps"} +{"Time":"2026-09-11T01:43:42.045053509Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf/single_oneOf_unwraps","Output":"=== RUN TestSingleOneOf/single_oneOf_unwraps\n"} +{"Time":"2026-09-11T01:43:42.04507448Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf/single_oneOf_unwraps","Output":"--- PASS: TestSingleOneOf/single_oneOf_unwraps (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045077467Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf/single_oneOf_unwraps","Elapsed":0} +{"Time":"2026-09-11T01:43:42.04507913Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf","Output":"--- PASS: TestSingleOneOf (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045081544Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestSingleOneOf","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045083804Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives"} +{"Time":"2026-09-11T01:43:42.045085131Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives","Output":"=== RUN TestNullableOneOf_BasicPrimitives\n"} +{"Time":"2026-09-11T01:43:42.045093049Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/string"} +{"Time":"2026-09-11T01:43:42.04509459Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/string","Output":"=== RUN TestNullableOneOf_BasicPrimitives/string\n"} +{"Time":"2026-09-11T01:43:42.045120765Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/string","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/string (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045122915Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/string","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045125437Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/integer"} +{"Time":"2026-09-11T01:43:42.045126977Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/integer","Output":"=== RUN TestNullableOneOf_BasicPrimitives/integer\n"} +{"Time":"2026-09-11T01:43:42.045145523Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/integer","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/integer (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045148304Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/integer","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045152098Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int32"} +{"Time":"2026-09-11T01:43:42.04515356Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int32","Output":"=== RUN TestNullableOneOf_BasicPrimitives/int32\n"} +{"Time":"2026-09-11T01:43:42.045175979Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int32","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/int32 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045178844Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int32","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045181003Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int64"} +{"Time":"2026-09-11T01:43:42.045182291Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int64","Output":"=== RUN TestNullableOneOf_BasicPrimitives/int64\n"} +{"Time":"2026-09-11T01:43:42.045202484Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int64","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/int64 (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045204359Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/int64","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045206516Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/number"} +{"Time":"2026-09-11T01:43:42.045207803Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/number","Output":"=== RUN TestNullableOneOf_BasicPrimitives/number\n"} +{"Time":"2026-09-11T01:43:42.045226326Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/number","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/number (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.04523021Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/number","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045231767Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/float"} +{"Time":"2026-09-11T01:43:42.045233008Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/float","Output":"=== RUN TestNullableOneOf_BasicPrimitives/float\n"} +{"Time":"2026-09-11T01:43:42.045253123Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/float","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/float (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045255527Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/float","Elapsed":0} +{"Time":"2026-09-11T01:43:42.04525704Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/double"} +{"Time":"2026-09-11T01:43:42.045258346Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/double","Output":"=== RUN TestNullableOneOf_BasicPrimitives/double\n"} +{"Time":"2026-09-11T01:43:42.045277505Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/double","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/double (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045279224Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/double","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045281561Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/boolean"} +{"Time":"2026-09-11T01:43:42.045285752Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/boolean","Output":"=== RUN TestNullableOneOf_BasicPrimitives/boolean\n"} +{"Time":"2026-09-11T01:43:42.045302549Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/boolean","Output":"--- PASS: TestNullableOneOf_BasicPrimitives/boolean (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045306267Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives/boolean","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045307989Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives","Output":"--- PASS: TestNullableOneOf_BasicPrimitives (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045309575Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_BasicPrimitives","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045311778Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes"} +{"Time":"2026-09-11T01:43:42.045313116Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes","Output":"=== RUN TestNullableOneOf_SpecialTypes\n"} +{"Time":"2026-09-11T01:43:42.045317629Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes"} +{"Time":"2026-09-11T01:43:42.045319347Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes","Output":"=== RUN TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes\n"} +{"Time":"2026-09-11T01:43:42.045335453Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes","Output":"--- PASS: TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045337319Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045339439Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/array_becomes_nullable_array"} +{"Time":"2026-09-11T01:43:42.045340894Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/array_becomes_nullable_array","Output":"=== RUN TestNullableOneOf_SpecialTypes/array_becomes_nullable_array\n"} +{"Time":"2026-09-11T01:43:42.045359654Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/array_becomes_nullable_array","Output":"--- PASS: TestNullableOneOf_SpecialTypes/array_becomes_nullable_array (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045361502Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/array_becomes_nullable_array","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045362979Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/map_becomes_nullable_map"} +{"Time":"2026-09-11T01:43:42.04536454Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/map_becomes_nullable_map","Output":"=== RUN TestNullableOneOf_SpecialTypes/map_becomes_nullable_map\n"} +{"Time":"2026-09-11T01:43:42.045389421Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/map_becomes_nullable_map","Output":"--- PASS: TestNullableOneOf_SpecialTypes/map_becomes_nullable_map (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045391179Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes/map_becomes_nullable_map","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045393845Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes","Output":"--- PASS: TestNullableOneOf_SpecialTypes (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045395341Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_SpecialTypes","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045397337Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects"} +{"Time":"2026-09-11T01:43:42.04539974Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects","Output":"=== RUN TestNullableOneOf_Objects\n"} +{"Time":"2026-09-11T01:43:42.045401984Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/simple_object"} +{"Time":"2026-09-11T01:43:42.045403205Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/simple_object","Output":"=== RUN TestNullableOneOf_Objects/simple_object\n"} +{"Time":"2026-09-11T01:43:42.045433277Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/simple_object","Output":"--- PASS: TestNullableOneOf_Objects/simple_object (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045435154Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/simple_object","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045437225Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/nested_nullable_objects"} +{"Time":"2026-09-11T01:43:42.045438517Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/nested_nullable_objects","Output":"=== RUN TestNullableOneOf_Objects/nested_nullable_objects\n"} +{"Time":"2026-09-11T01:43:42.045474863Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/nested_nullable_objects","Output":"--- PASS: TestNullableOneOf_Objects/nested_nullable_objects (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045476555Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects/nested_nullable_objects","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045478809Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects","Output":"--- PASS: TestNullableOneOf_Objects (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.04548037Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Objects","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045482566Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References"} +{"Time":"2026-09-11T01:43:42.045483936Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References","Output":"=== RUN TestNullableOneOf_References\n"} +{"Time":"2026-09-11T01:43:42.045485975Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/single_reference"} +{"Time":"2026-09-11T01:43:42.045487247Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/single_reference","Output":"=== RUN TestNullableOneOf_References/single_reference\n"} +{"Time":"2026-09-11T01:43:42.045502964Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/single_reference","Output":"--- PASS: TestNullableOneOf_References/single_reference (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045504665Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/single_reference","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045506796Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/multiple_references_fail_with_discriminator_error"} +{"Time":"2026-09-11T01:43:42.045508146Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/multiple_references_fail_with_discriminator_error","Output":"=== RUN TestNullableOneOf_References/multiple_references_fail_with_discriminator_error\n"} +{"Time":"2026-09-11T01:43:42.045543806Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/multiple_references_fail_with_discriminator_error","Output":"--- PASS: TestNullableOneOf_References/multiple_references_fail_with_discriminator_error (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045545739Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/multiple_references_fail_with_discriminator_error","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045549798Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/shared_reference"} +{"Time":"2026-09-11T01:43:42.045551068Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/shared_reference","Output":"=== RUN TestNullableOneOf_References/shared_reference\n"} +{"Time":"2026-09-11T01:43:42.045584449Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/shared_reference","Output":"--- PASS: TestNullableOneOf_References/shared_reference (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045586858Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References/shared_reference","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045588438Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References","Output":"--- PASS: TestNullableOneOf_References (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045590555Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_References","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045592621Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality"} +{"Time":"2026-09-11T01:43:42.045593869Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality","Output":"=== RUN TestNullableOneOf_Optionality\n"} +{"Time":"2026-09-11T01:43:42.045602161Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/required_vs_optional_nullable_fields"} +{"Time":"2026-09-11T01:43:42.045603661Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/required_vs_optional_nullable_fields","Output":"=== RUN TestNullableOneOf_Optionality/required_vs_optional_nullable_fields\n"} +{"Time":"2026-09-11T01:43:42.045640932Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/required_vs_optional_nullable_fields","Output":"--- PASS: TestNullableOneOf_Optionality/required_vs_optional_nullable_fields (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045642683Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/required_vs_optional_nullable_fields","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045644817Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/field_in_optional_object"} +{"Time":"2026-09-11T01:43:42.045646216Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/field_in_optional_object","Output":"=== RUN TestNullableOneOf_Optionality/field_in_optional_object\n"} +{"Time":"2026-09-11T01:43:42.045676172Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/field_in_optional_object","Output":"--- PASS: TestNullableOneOf_Optionality/field_in_optional_object (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045677935Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality/field_in_optional_object","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045680276Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality","Output":"--- PASS: TestNullableOneOf_Optionality (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.04568185Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_Optionality","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045683208Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns"} +{"Time":"2026-09-11T01:43:42.045684486Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns","Output":"=== RUN TestNullableOneOf_NonNullablePatterns\n"} +{"Time":"2026-09-11T01:43:42.045686779Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type"} +{"Time":"2026-09-11T01:43:42.045688133Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type","Output":"=== RUN TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type\n"} +{"Time":"2026-09-11T01:43:42.045692346Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer"} +{"Time":"2026-09-11T01:43:42.045693738Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer","Output":"=== RUN TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer\n"} +{"Time":"2026-09-11T01:43:42.045718253Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer","Output":"--- PASS: TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045720121Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045722272Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null"} +{"Time":"2026-09-11T01:43:42.04572355Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null","Output":"=== RUN TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null\n"} +{"Time":"2026-09-11T01:43:42.045743992Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null","Output":"--- PASS: TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045746799Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045748911Z","Action":"run","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object"} +{"Time":"2026-09-11T01:43:42.045750196Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object","Output":"=== RUN TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object\n"} +{"Time":"2026-09-11T01:43:42.045779725Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object","Output":"--- PASS: TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045781506Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045784618Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type","Output":"--- PASS: TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045786191Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045789769Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns","Output":"--- PASS: TestNullableOneOf_NonNullablePatterns (0.00s)\n"} +{"Time":"2026-09-11T01:43:42.045791301Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Test":"TestNullableOneOf_NonNullablePatterns","Elapsed":0} +{"Time":"2026-09-11T01:43:42.045793427Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Output":"PASS\n"} +{"Time":"2026-09-11T01:43:42.04685169Z","Action":"output","Package":"github.com/ogen-go/ogen/gen","Output":"ok \tgithub.com/ogen-go/ogen/gen\t0.230s\n"} +{"Time":"2026-09-11T01:43:42.046864796Z","Action":"pass","Package":"github.com/ogen-go/ogen/gen","Elapsed":0.23} diff --git a/resources_servers/swemer_v2/tests/fixtures/jest_output.txt b/resources_servers/swemer_v2/tests/fixtures/jest_output.txt new file mode 100644 index 00000000000..13014320a5f --- /dev/null +++ b/resources_servers/swemer_v2/tests/fixtures/jest_output.txt @@ -0,0 +1,322 @@ + +jest-haste-map: duplicate manual mock found: useLearningActivities + The following files share their name; please delete one of them: + * /packages/kolibri-common/composables/__mocks__/useLearningActivities.js + * /kolibri/plugins/learn/assets/src/composables/__mocks__/useLearningActivities.js + +[baseline-browser-mapping] The data in this module is over two months old. To ensure accurate Baseline data, please update: `npm i baseline-browser-mapping@latest -D` +Browserslist: browsers data (caniuse-lite) is 10 months old. Please run: + npx update-browserslist-db@latest + Why you should do it regularly: https://github.com/browserslist/update-db#readme +PASS packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js (21.05 s) + no-undefined-translator-keys + valid + ✓ + const translator = createTranslator('NS', { validKey: 'msg' }); + const { validKey$ } = translator; + (29 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' }); + const { key1$, key2$, key3$ } = translator; + (3 ms) + ✓ + const translator = createTranslator('NS', { + key1: { message: 'msg', context: 'ctx' }, + key2: { message: 'msg2' } + }); + const { key1$, key2$ } = translator; + (3 ms) + ✓ + export const translator = createTranslator('NS', { validKey: 'msg', anotherKey: 'msg2' }); + const { validKey$ } = translator; + (3 ms) + ✓ + const translator = createTranslator('NS', { key: 'msg' }); + translator.$tr('key'); + (2 ms) + ✓ + const regularObj = { someKey$: () => {} }; + const { someKey$ } = regularObj; + (3 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' }); + const { key1$ } = translator; + const { key2$ } = translator; + (7 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a', key2: 'b' }); + const { key1$, ...rest } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', { validKey: 'msg' }); + const { validKey$: myLabel } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a', key2: 'b' }); + const { key1$ } = translator; + const { key2$ } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', { + userLabel: 'User', + adminLabel: 'Administrator', + coachLabel: 'Coach', + learnerLabel: 'Learner', + }); + const { userLabel$, adminLabel$, coachLabel$, learnerLabel$ } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', { + 'key-with-dash': 'msg', + }); + const { 'key-with-dash$': keyWithDash } = translator; + (1 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a' }); + const {} = translator; + (2 ms) + ✓ + const translator1 = createTranslator('NS1', { key1: 'a' }); + const translator2 = createTranslator('NS2', { key2: 'b' }); + const { key1$ } = translator1; + const { key2$ } = translator2; + (2 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a' }); + function useTranslator() { + const { key1$ } = translator; + } + (2 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { userLabel$ } = testStrings; + (3 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { userLabel$, adminLabel$, coachLabel$ } = testStrings; + (1 ms) + ✓ + import { anotherTranslator } from './fixtures/testStrings'; + const { saveAction$, cancelAction$ } = anotherTranslator; + (1 ms) + ✓ + import { testStrings, anotherTranslator } from './fixtures/testStrings'; + const { userLabel$ } = testStrings; + const { saveAction$ } = anotherTranslator; + (1 ms) + ✓ + import { objectFormatStrings } from './fixtures/testStrings'; + const { welcomeMessage$, errorTitle$ } = objectFormatStrings; + (1 ms) + ✓ + import { objectFormatStrings } from './fixtures/testStrings'; + const { welcomeMessage$, errorTitle$, successMessage$ } = objectFormatStrings; + (1 ms) + ✓ + import defaultStrings from './fixtures/defaultExport'; + const { defaultMessage$, anotherMessage$ } = defaultStrings; + (1 ms) + ✓ + import { reExportedStrings } from './fixtures/reExport'; + const { reExportedMessage$, anotherReExported$ } = reExportedStrings; + (2 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { userLabel$: myUserLabel } = testStrings; + (1 ms) + ✓ + const translators = { + completed: createTranslator('NS', { validKey: 'msg' }) + }; + const { validKey$ } = translators.completed; + (1 ms) + ✓ + const translators = { + completed: createTranslator('NS', { validKey: 'msg' }) + }; + const { completed } = translators; + const { validKey$ } = completed; + (1 ms) + ✓ + const progressTranslators = { + completed: createTranslator('NS1', { key1: 'a' }), + inProgress: createTranslator('NS2', { key2: 'b' }) + }; + const { key1$ } = progressTranslators.completed; + const { key2$ } = progressTranslators.inProgress; + (1 ms) + ✓ + const progressTranslators = { + completed: createTranslator('NS1', { key1: 'a' }), + inProgress: createTranslator('NS2', { key2: 'b' }) + }; + const { completed, inProgress } = progressTranslators; + const { key1$ } = completed; + const { key2$ } = inProgress; + (1 ms) + ✓ + const translators = { + main: createTranslator('NS', { validKey: 'msg' }) + }; + const { main: myTranslator } = translators; + const { validKey$ } = myTranslator; + (1 ms) + ✓ + import { nonExistent } from './fixtures/doesNotExist'; + const { anyKey$ } = nonExistent; + (1 ms) + ✓ + import { malformed } from './fixtures/malformed'; + const { anyKey$ } = malformed; + (1 ms) + invalid + ✓ + const translator = createTranslator('NS', { validKey: 'msg' }); + const { undefinedKey$ } = translator; + (3 ms) + ✓ + const translator = createTranslator('NS', { validKey: 'msg' }); + const { validKey$, undefinedKey$ } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', { userLabel: 'User' }); + const { usrLabel$ } = translator; + (1 ms) + ✓ + const translator = createTranslator('NS', { key: 'msg' }); + const { key } = translator; + (1 ms) + ✓ + const translator = createTranslator('NS', { myKey: 'msg' }); + const { MyKey$ } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', {}); + const { anyKey$ } = translator; + (1 ms) + ✓ + const translator = createTranslator('NS', { validKey: 'msg' }); + const { invalid1$, invalid2$, invalid3$ } = translator; + (1 ms) + ✓ + const translator = createTranslator('NS', { validKey: 'msg' }); + const { invalidKey$: myLabel } = translator; + (4 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a' }); + const { invalidKey$, ...rest } = translator; + (1 ms) + ✓ + const translator1 = createTranslator('NS1', { key1: 'a' }); + const translator2 = createTranslator('NS2', { key2: 'b' }); + const { key2$ } = translator1; + (1 ms) + ✓ + export const translator = createTranslator('NS', { validKey: 'msg' }); + const { invalidKey$ } = translator; + (2 ms) + ✓ + const translator = createTranslator('NS', { + userLabel: { message: 'User', context: 'Label for user' }, + adminLabel: { message: 'Admin' }, + }); + const { userLabel$, invalidLabel$ } = translator; + (1 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a' }); + function useTranslator() { + const { invalidKey$ } = translator; + } + (1 ms) + ✓ + const translator = createTranslator('NS', { key1: 'a', key2: 'b' }); + const { key1, key2$ } = translator; + (1 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { invalidKey$ } = testStrings; + (1 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { usrLabel$ } = testStrings; + (1 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { userLabel$, invalidLabel$ } = testStrings; + (1 ms) + ✓ + import { anotherTranslator } from './fixtures/testStrings'; + const { invalidAction$ } = anotherTranslator; + (1 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { userLabel } = testStrings; + (1 ms) + ✓ + import { objectFormatStrings } from './fixtures/testStrings'; + const { message$ } = objectFormatStrings; + (1 ms) + ✓ + import { objectFormatStrings } from './fixtures/testStrings'; + const { context$ } = objectFormatStrings; + (1 ms) + ✓ + import { objectFormatStrings } from './fixtures/testStrings'; + const { invalidKey$ } = objectFormatStrings; + (1 ms) + ✓ + import { objectFormatStrings } from './fixtures/testStrings'; + const { welcomeMessage$, message$ } = objectFormatStrings; + (1 ms) + ✓ + import defaultStrings from './fixtures/defaultExport'; + const { invalidKey$ } = defaultStrings; + (1 ms) + ✓ + import { reExportedStrings } from './fixtures/reExport'; + const { invalidKey$ } = reExportedStrings; + (1 ms) + ✓ + import { testStrings } from './fixtures/testStrings'; + const { invalidKey$: myLabel } = testStrings; + (1 ms) + ✓ + const translators = { + completed: createTranslator('NS', { validKey: 'msg' }) + }; + const { invalidKey$ } = translators.completed; + (1 ms) + ✓ + const translators = { + completed: createTranslator('NS', { validKey: 'msg' }) + }; + const { completed } = translators; + const { invalidKey$ } = completed; + (2 ms) + ✓ + const progressTranslators = { + completed: createTranslator('NS1', { key1: 'a' }), + inProgress: createTranslator('NS2', { key2: 'b' }) + }; + const { key2$ } = progressTranslators.completed; + (2 ms) + ✓ + const progressTranslators = { + completed: createTranslator('NS1', { key1: 'a' }), + inProgress: createTranslator('NS2', { key2: 'b' }) + }; + const { completed } = progressTranslators; + const { key2$ } = completed; + (1 ms) + +Test Suites: 1 passed, 1 total +Tests: 61 passed, 61 total +Snapshots: 0 total +Time: 40.963 s +Ran all test suites matching packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js. +{"numFailedTestSuites":0,"numFailedTests":0,"numPassedTestSuites":1,"numPassedTests":61,"numPendingTestSuites":0,"numPendingTests":0,"numRuntimeErrorTestSuites":0,"numTodoTests":0,"numTotalTestSuites":1,"numTotalTests":61,"openHandles":[],"snapshot":{"added":0,"didUpdate":false,"failure":false,"filesAdded":0,"filesRemoved":0,"filesRemovedList":[],"filesUnmatched":0,"filesUpdated":0,"matched":0,"total":0,"unchecked":0,"uncheckedKeysByFile":[],"unmatched":0,"updated":0},"startTime":1789091044061,"success":true,"testResults":[{"assertionResults":[{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":29,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084870,"status":"passed","title":"\n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":3,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' });\n const { key1$, key2$, key3$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084900,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' });\n const { key1$, key2$, key3$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":3,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', {\n key1: { message: 'msg', context: 'ctx' },\n key2: { message: 'msg2' }\n });\n const { key1$, key2$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084903,"status":"passed","title":"\n const translator = createTranslator('NS', {\n key1: { message: 'msg', context: 'ctx' },\n key2: { message: 'msg2' }\n });\n const { key1$, key2$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":3,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n export const translator = createTranslator('NS', { validKey: 'msg', anotherKey: 'msg2' });\n const { validKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084906,"status":"passed","title":"\n export const translator = createTranslator('NS', { validKey: 'msg', anotherKey: 'msg2' });\n const { validKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key: 'msg' });\n translator.$tr('key');\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084909,"status":"passed","title":"\n const translator = createTranslator('NS', { key: 'msg' });\n translator.$tr('key');\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":3,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const regularObj = { someKey$: () => {} };\n const { someKey$ } = regularObj;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084911,"status":"passed","title":"\n const regularObj = { someKey$: () => {} };\n const { someKey$ } = regularObj;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":7,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' });\n const { key1$ } = translator;\n const { key2$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084914,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' });\n const { key1$ } = translator;\n const { key2$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1$, ...rest } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084921,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1$, ...rest } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$: myLabel } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084923,"status":"passed","title":"\n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$: myLabel } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1$ } = translator;\n const { key2$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084925,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1$ } = translator;\n const { key2$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', {\n userLabel: 'User',\n adminLabel: 'Administrator',\n coachLabel: 'Coach',\n learnerLabel: 'Learner',\n });\n const { userLabel$, adminLabel$, coachLabel$, learnerLabel$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084927,"status":"passed","title":"\n const translator = createTranslator('NS', {\n userLabel: 'User',\n adminLabel: 'Administrator',\n coachLabel: 'Coach',\n learnerLabel: 'Learner',\n });\n const { userLabel$, adminLabel$, coachLabel$, learnerLabel$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', {\n 'key-with-dash': 'msg',\n });\n const { 'key-with-dash$': keyWithDash } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084930,"status":"passed","title":"\n const translator = createTranslator('NS', {\n 'key-with-dash': 'msg',\n });\n const { 'key-with-dash$': keyWithDash } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a' });\n const {} = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084931,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a' });\n const {} = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator1 = createTranslator('NS1', { key1: 'a' });\n const translator2 = createTranslator('NS2', { key2: 'b' });\n const { key1$ } = translator1;\n const { key2$ } = translator2;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084933,"status":"passed","title":"\n const translator1 = createTranslator('NS1', { key1: 'a' });\n const translator2 = createTranslator('NS2', { key2: 'b' });\n const { key1$ } = translator1;\n const { key2$ } = translator2;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a' });\n function useTranslator() {\n const { key1$ } = translator;\n }\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084935,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a' });\n function useTranslator() {\n const { key1$ } = translator;\n }\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":3,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$ } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084937,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { userLabel$ } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$, adminLabel$, coachLabel$ } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084940,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { userLabel$, adminLabel$, coachLabel$ } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { anotherTranslator } from './fixtures/testStrings';\n const { saveAction$, cancelAction$ } = anotherTranslator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084942,"status":"passed","title":"\n import { anotherTranslator } from './fixtures/testStrings';\n const { saveAction$, cancelAction$ } = anotherTranslator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { testStrings, anotherTranslator } from './fixtures/testStrings';\n const { userLabel$ } = testStrings;\n const { saveAction$ } = anotherTranslator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084943,"status":"passed","title":"\n import { testStrings, anotherTranslator } from './fixtures/testStrings';\n const { userLabel$ } = testStrings;\n const { saveAction$ } = anotherTranslator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, errorTitle$ } = objectFormatStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084945,"status":"passed","title":"\n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, errorTitle$ } = objectFormatStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, errorTitle$, successMessage$ } = objectFormatStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084946,"status":"passed","title":"\n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, errorTitle$, successMessage$ } = objectFormatStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import defaultStrings from './fixtures/defaultExport';\n const { defaultMessage$, anotherMessage$ } = defaultStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084948,"status":"passed","title":"\n import defaultStrings from './fixtures/defaultExport';\n const { defaultMessage$, anotherMessage$ } = defaultStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { reExportedStrings } from './fixtures/reExport';\n const { reExportedMessage$, anotherReExported$ } = reExportedStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084949,"status":"passed","title":"\n import { reExportedStrings } from './fixtures/reExport';\n const { reExportedMessage$, anotherReExported$ } = reExportedStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$: myUserLabel } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084951,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { userLabel$: myUserLabel } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { validKey$ } = translators.completed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084953,"status":"passed","title":"\n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { validKey$ } = translators.completed;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { completed } = translators;\n const { validKey$ } = completed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084954,"status":"passed","title":"\n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { completed } = translators;\n const { validKey$ } = completed;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { key1$ } = progressTranslators.completed;\n const { key2$ } = progressTranslators.inProgress;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084956,"status":"passed","title":"\n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { key1$ } = progressTranslators.completed;\n const { key2$ } = progressTranslators.inProgress;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { completed, inProgress } = progressTranslators;\n const { key1$ } = completed;\n const { key2$ } = inProgress;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084958,"status":"passed","title":"\n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { completed, inProgress } = progressTranslators;\n const { key1$ } = completed;\n const { key2$ } = inProgress;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n const translators = {\n main: createTranslator('NS', { validKey: 'msg' })\n };\n const { main: myTranslator } = translators;\n const { validKey$ } = myTranslator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084960,"status":"passed","title":"\n const translators = {\n main: createTranslator('NS', { validKey: 'msg' })\n };\n const { main: myTranslator } = translators;\n const { validKey$ } = myTranslator;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { nonExistent } from './fixtures/doesNotExist';\n const { anyKey$ } = nonExistent;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084961,"status":"passed","title":"\n import { nonExistent } from './fixtures/doesNotExist';\n const { anyKey$ } = nonExistent;\n "},{"ancestorTitles":["no-undefined-translator-keys","valid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys valid \n import { malformed } from './fixtures/malformed';\n const { anyKey$ } = malformed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084963,"status":"passed","title":"\n import { malformed } from './fixtures/malformed';\n const { anyKey$ } = malformed;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":3,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { undefinedKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084964,"status":"passed","title":"\n const translator = createTranslator('NS', { validKey: 'msg' });\n const { undefinedKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$, undefinedKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084967,"status":"passed","title":"\n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$, undefinedKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { userLabel: 'User' });\n const { usrLabel$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084969,"status":"passed","title":"\n const translator = createTranslator('NS', { userLabel: 'User' });\n const { usrLabel$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key: 'msg' });\n const { key } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084971,"status":"passed","title":"\n const translator = createTranslator('NS', { key: 'msg' });\n const { key } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { myKey: 'msg' });\n const { MyKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084972,"status":"passed","title":"\n const translator = createTranslator('NS', { myKey: 'msg' });\n const { MyKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', {});\n const { anyKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084974,"status":"passed","title":"\n const translator = createTranslator('NS', {});\n const { anyKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalid1$, invalid2$, invalid3$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084975,"status":"passed","title":"\n const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalid1$, invalid2$, invalid3$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":4,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalidKey$: myLabel } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084977,"status":"passed","title":"\n const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalidKey$: myLabel } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key1: 'a' });\n const { invalidKey$, ...rest } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084981,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a' });\n const { invalidKey$, ...rest } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator1 = createTranslator('NS1', { key1: 'a' });\n const translator2 = createTranslator('NS2', { key2: 'b' });\n const { key2$ } = translator1;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084983,"status":"passed","title":"\n const translator1 = createTranslator('NS1', { key1: 'a' });\n const translator2 = createTranslator('NS2', { key2: 'b' });\n const { key2$ } = translator1;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n export const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalidKey$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084984,"status":"passed","title":"\n export const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalidKey$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', {\n userLabel: { message: 'User', context: 'Label for user' },\n adminLabel: { message: 'Admin' },\n });\n const { userLabel$, invalidLabel$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084986,"status":"passed","title":"\n const translator = createTranslator('NS', {\n userLabel: { message: 'User', context: 'Label for user' },\n adminLabel: { message: 'Admin' },\n });\n const { userLabel$, invalidLabel$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key1: 'a' });\n function useTranslator() {\n const { invalidKey$ } = translator;\n }\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084988,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a' });\n function useTranslator() {\n const { invalidKey$ } = translator;\n }\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1, key2$ } = translator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084989,"status":"passed","title":"\n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1, key2$ } = translator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { invalidKey$ } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084991,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { invalidKey$ } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { usrLabel$ } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084992,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { usrLabel$ } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$, invalidLabel$ } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084993,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { userLabel$, invalidLabel$ } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { anotherTranslator } from './fixtures/testStrings';\n const { invalidAction$ } = anotherTranslator;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084995,"status":"passed","title":"\n import { anotherTranslator } from './fixtures/testStrings';\n const { invalidAction$ } = anotherTranslator;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084996,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { userLabel } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { message$ } = objectFormatStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084997,"status":"passed","title":"\n import { objectFormatStrings } from './fixtures/testStrings';\n const { message$ } = objectFormatStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { context$ } = objectFormatStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091084998,"status":"passed","title":"\n import { objectFormatStrings } from './fixtures/testStrings';\n const { context$ } = objectFormatStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { invalidKey$ } = objectFormatStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085000,"status":"passed","title":"\n import { objectFormatStrings } from './fixtures/testStrings';\n const { invalidKey$ } = objectFormatStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, message$ } = objectFormatStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085001,"status":"passed","title":"\n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, message$ } = objectFormatStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import defaultStrings from './fixtures/defaultExport';\n const { invalidKey$ } = defaultStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085002,"status":"passed","title":"\n import defaultStrings from './fixtures/defaultExport';\n const { invalidKey$ } = defaultStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { reExportedStrings } from './fixtures/reExport';\n const { invalidKey$ } = reExportedStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085004,"status":"passed","title":"\n import { reExportedStrings } from './fixtures/reExport';\n const { invalidKey$ } = reExportedStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { invalidKey$: myLabel } = testStrings;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085005,"status":"passed","title":"\n import { testStrings } from './fixtures/testStrings';\n const { invalidKey$: myLabel } = testStrings;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { invalidKey$ } = translators.completed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085006,"status":"passed","title":"\n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { invalidKey$ } = translators.completed;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { completed } = translators;\n const { invalidKey$ } = completed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085007,"status":"passed","title":"\n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { completed } = translators;\n const { invalidKey$ } = completed;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":2,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { key2$ } = progressTranslators.completed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085009,"status":"passed","title":"\n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { key2$ } = progressTranslators.completed;\n "},{"ancestorTitles":["no-undefined-translator-keys","invalid"],"duration":1,"failing":false,"failureDetails":[],"failureMessages":[],"fullName":"no-undefined-translator-keys invalid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { completed } = progressTranslators;\n const { key2$ } = completed;\n ","invocations":1,"location":null,"numPassingAsserts":0,"retryReasons":[],"startAt":1789091085011,"status":"passed","title":"\n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { completed } = progressTranslators;\n const { key2$ } = completed;\n "}],"endTime":1789091085014,"message":"","name":"/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js","startTime":1789091063964,"status":"passed","summary":""}],"wasInterrupted":false} +npm notice +npm notice New major version of npm available! 10.8.2 -> 12.0.2 +npm notice Changelog: https://github.com/npm/cli/releases/tag/v12.0.2 +npm notice To update run: npm install -g npm@12.0.2 +npm notice diff --git a/resources_servers/swemer_v2/tests/fixtures/manifest.json b/resources_servers/swemer_v2/tests/fixtures/manifest.json new file mode 100644 index 00000000000..4621d838d7d --- /dev/null +++ b/resources_servers/swemer_v2/tests/fixtures/manifest.json @@ -0,0 +1,450 @@ +{ + "pytest": { + "delivery": "delivery_08_20", + "task": "evo-company-hiku-184-agentic-v2", + "image_ref": "942195279341.dkr.ecr.us-east-2.amazonaws.com/ext-nvidia-agentic-v2:delivery_08_20__evo-company-hiku-184-agentic-v2", + "workdir": "/workspace/repo", + "test_command": "pytest /workspace/repo/tests/test_engine.py /workspace/repo/tests/test_validate_query.py -v", + "fail_to_pass": [ + "tests.test_engine::test_link_optional_option_input_ref[query_args0]", + "tests.test_engine::test_link_optional_option_input_ref[query_args1]", + "tests.test_validate_query::test_missing_options" + ], + "pass_to_pass": [ + "tests.test_engine::test_context", + "tests.test_engine::test_root_fields", + "tests.test_engine::test_node_fields", + "tests.test_engine::test_node_complex_fields", + "tests.test_engine::test_links", + "tests.test_engine::test_links_requires_list", + "tests.test_engine::test_links_requires_list_sa", + "tests.test_engine::test_field_option_valid[option0-args0-result0]", + "tests.test_engine::test_field_option_valid[option1-args1-result1]", + "tests.test_engine::test_field_option_valid[option2-args2-result2]", + "tests.test_engine::test_field_option_valid[option3-args3-result3]", + "tests.test_engine::test_field_option_valid[option4-args4-result4]", + "tests.test_engine::test_field_option_valid[option5-args5-result5]", + "tests.test_engine::test_field_option_unknown", + "tests.test_engine::test_field_option_missing", + "tests.test_engine::test_link_option_valid[option0-args0-result0]", + "tests.test_engine::test_link_option_valid[option1-args1-result1]", + "tests.test_engine::test_link_option_valid[option2-args2-result2]", + "tests.test_engine::test_link_option_valid[option3-args3-result3]", + "tests.test_engine::test_link_option_valid[option4-args4-result4]", + "tests.test_engine::test_link_option_valid[option5-args5-result5]", + "tests.test_engine::test_link_option_unknown", + "tests.test_engine::test_link_option_missing", + "tests.test_engine::test_link_option_type_ref", + "tests.test_engine::test_link_option_input_ref", + "tests.test_engine::test_pass_context_field", + "tests.test_engine::test_pass_context_link", + "tests.test_engine::test_node_link_without_requirements", + "tests.test_engine::test_root_field_func_result_validation[1]", + "tests.test_engine::test_root_field_func_result_validation[value1]", + "tests.test_engine::test_root_field_func_result_validation[value2]", + "tests.test_engine::test_node_field_func_result_validation[1]", + "tests.test_engine::test_node_field_func_result_validation[value1]", + "tests.test_engine::test_node_field_func_result_validation[value2]", + "tests.test_engine::test_node_field_func_result_validation[value3]", + "tests.test_engine::test_node_field_func_result_validation[value4]", + "tests.test_engine::test_node_field_func_result_validation[value5]", + "tests.test_engine::test_root_link_many_func_result_validation", + "tests.test_engine::test_node_link_one_func_result_validation[1]", + "tests.test_engine::test_node_link_one_func_result_validation[value1]", + "tests.test_engine::test_node_link_one_func_result_validation[value2]", + "tests.test_engine::test_node_link_many_func_result_validation[1]", + "tests.test_engine::test_node_link_many_func_result_validation[value1]", + "tests.test_engine::test_node_link_many_func_result_validation[value2]", + "tests.test_engine::test_node_link_many_func_result_validation[value3]", + "tests.test_engine::test_node_link_many_func_result_validation[value4]", + "tests.test_engine::test_root_field_alias", + "tests.test_engine::test_node_field_alias", + "tests.test_engine::test_root_link_alias", + "tests.test_engine::test_node_link_alias", + "tests.test_engine::test_conflicting_fields", + "tests.test_engine::test_conflicting_links", + "tests.test_engine::test_process_ordered_node", + "tests.test_engine::test_falsy_link_result", + "tests.test_engine::test_root_link_with_sequence_to_optional_type_ref", + "tests.test_engine::test_non_root_link_with_sequence_to_optional_type_ref", + "tests.test_engine::test_mutation_query_builder", + "tests.test_engine::test_merge_query__fragments", + "tests.test_engine::test_merge_query__interface_fragments[one level fragments]", + "tests.test_engine::test_merge_query__interface_fragments[nested fragments]", + "tests.test_engine::test_merge_query__interface_fragments[nested + neighbour fragments]", + "tests.test_engine::test_merge_query__union_fragments[one level fragments]", + "tests.test_engine::test_merge_query__union_fragments[nested fragments]", + "tests.test_engine::test_merge_query__union_fragments[nested + neighbour fragments]", + "tests.test_engine::test_merge_query__fields_and_nested_fragments", + "tests.test_engine::test_merge_query__only_nested_fragments", + "tests.test_engine::test_merge_query__complex_field_fragment", + "tests.test_engine::test_denormalize_introspection", + "tests.test_validate_query::test_field", + "tests.test_validate_query::test_field_complex[wounded]", + "tests.test_validate_query::test_field_complex[annuals]", + "tests.test_validate_query::test_field_complex[hialeah]", + "tests.test_validate_query::test_field_complex[val]", + "tests.test_validate_query::test_field_complex_with_typename", + "tests.test_validate_query::test_nested_records", + "tests.test_validate_query::test_non_field", + "tests.test_validate_query::test_field_options", + "tests.test_validate_query::test_link", + "tests.test_validate_query::test_link_options", + "tests.test_validate_query::test_scalar_option_type_errors", + "tests.test_validate_query::test_optional_option_type_errors", + "tests.test_validate_query::test_sequence_option_type_errors", + "tests.test_validate_query::test_mapping_option_type_errors", + "tests.test_validate_query::test_record_option_type_errors", + "tests.test_validate_query::test_distinct_by_name_fields", + "tests.test_validate_query::test_distinct_by_options_fields[only fields]", + "tests.test_validate_query::test_distinct_by_options_fields[only fields inside fragment]", + "tests.test_validate_query::test_distinct_by_options_fields[fields inside neighbour fragment]", + "tests.test_validate_query::test_distinct_by_options_fields[field + neighbour fragment]", + "tests.test_validate_query::test_distinct_by_options_fields[different level fragment, same link]", + "tests.test_validate_query::test_distinct_by_name_links", + "tests.test_validate_query::test_distinct_by_options_links", + "tests.test_validate_query::test_typeref_in_option", + "tests.test_validate_query::test_any_in_option", + "tests.test_validate_query::test_validate_query_fragment_on_unknown_type", + "tests.test_validate_query::test_input_ref_in_option" + ] + }, + "go": { + "delivery": "delivery_08_27", + "task": "ogen-go-ogen-1532-agentic-v2", + "image_ref": "942195279341.dkr.ecr.us-east-2.amazonaws.com/ext-nvidia-agentic-v2:delivery_08_27__ogen-go-ogen-1532-agentic-v2", + "workdir": "/workspace/repo", + "test_command": "go test -json ./gen -count=1", + "fail_to_pass": [ + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/string", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/integer", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/int32", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/int64", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/number", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/float", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/double", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives/boolean", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_BasicPrimitives", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_SpecialTypes/byte_string_becomes_nullable_bytes", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_SpecialTypes/array_becomes_nullable_array", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_SpecialTypes/map_becomes_nullable_map", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_SpecialTypes", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_Objects/simple_object", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_Objects/nested_nullable_objects", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_Objects", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_References/single_reference", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_References/shared_reference", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_References", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_Optionality/required_vs_optional_nullable_fields", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_Optionality/field_in_optional_object", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_Optionality" + ], + "pass_to_pass": [ + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test1", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test2", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test3", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test4", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test5", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test6", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test7", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test8", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test9", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific/Test10", + "github.com/ogen-go/ogen/gen::Test_filterMostSpecific", + "github.com/ogen-go/ogen/gen::Test_vetPathParametersUsed", + "github.com/ogen-go/ogen/gen::Test_vetHeaderParameterName", + "github.com/ogen-go/ogen/gen::TestGenerateSchema/defs", + "github.com/ogen-go/ogen/gen::TestGenerateSchema/name", + "github.com/ogen-go/ogen/gen::TestGenerateSchema/openapi30", + "github.com/ogen-go/ogen/gen::TestGenerateSchema/platform", + "github.com/ogen-go/ogen/gen::TestGenerateSchema/recursive", + "github.com/ogen-go/ogen/gen::TestGenerateSchema", + "github.com/ogen-go/ogen/gen::TestGenerateSecurities", + "github.com/ogen-go/ogen/gen::TestNames", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test0", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test1", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test2", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test3", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test4", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test5", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test6", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test7", + "github.com/ogen-go/ogen/gen::Test_cleanRef/Test8", + "github.com/ogen-go/ogen/gen::Test_cleanRef", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test1", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test2", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test3", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test4", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test5", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test6", + "github.com/ogen-go/ogen/gen::Test_mergeEnums/Test7", + "github.com/ogen-go/ogen/gen::Test_mergeEnums", + "github.com/ogen-go/ogen/gen::TestSchemaGenAnyWarn", + "github.com/ogen-go/ogen/gen::TestGenerate/Test_fieldTag", + "github.com/ogen-go/ogen/gen::TestGenerate", + "github.com/ogen-go/ogen/gen::TestSingleOneOf/single_oneOf_unwraps", + "github.com/ogen-go/ogen/gen::TestSingleOneOf", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_References/multiple_references_fail_with_discriminator_error", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string_or_integer", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_null", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type/string,_integer,_and_object", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_NonNullablePatterns/multiple_non-null_types_remain_sum_type", + "github.com/ogen-go/ogen/gen::TestNullableOneOf_NonNullablePatterns" + ] + }, + "jest": { + "delivery": "delivery_08_27", + "task": "learningequality-kolibri-13932-agentic-v2", + "image_ref": "942195279341.dkr.ecr.us-east-2.amazonaws.com/ext-nvidia-agentic-v2:delivery_08_27__learningequality-kolibri-13932-agentic-v2", + "workdir": "/workspace/repo", + "test_command": "cd /workspace/repo && npx jest --config ./jest.conf.js packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js --coverage=false --verbose --json", + "fail_to_pass": [ + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' });\n const { key1$, key2$, key3$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', {\n key1: { message: 'msg', context: 'ctx' },\n key2: { message: 'msg2' }\n });\n const { key1$, key2$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n export const translator = createTranslator('NS', { validKey: 'msg', anotherKey: 'msg2' });\n const { validKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key: 'msg' });\n translator.$tr('key');\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const regularObj = { someKey$: () => {} };\n const { someKey$ } = regularObj;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b', key3: 'c' });\n const { key1$ } = translator;\n const { key2$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1$, ...rest } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$: myLabel } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1$ } = translator;\n const { key2$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', {\n userLabel: 'User',\n adminLabel: 'Administrator',\n coachLabel: 'Coach',\n learnerLabel: 'Learner',\n });\n const { userLabel$, adminLabel$, coachLabel$, learnerLabel$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', {\n 'key-with-dash': 'msg',\n });\n const { 'key-with-dash$': keyWithDash } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a' });\n const {} = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator1 = createTranslator('NS1', { key1: 'a' });\n const translator2 = createTranslator('NS2', { key2: 'b' });\n const { key1$ } = translator1;\n const { key2$ } = translator2;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translator = createTranslator('NS', { key1: 'a' });\n function useTranslator() {\n const { key1$ } = translator;\n }\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$ } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$, adminLabel$, coachLabel$ } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { anotherTranslator } from './fixtures/testStrings';\n const { saveAction$, cancelAction$ } = anotherTranslator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { testStrings, anotherTranslator } from './fixtures/testStrings';\n const { userLabel$ } = testStrings;\n const { saveAction$ } = anotherTranslator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, errorTitle$ } = objectFormatStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, errorTitle$, successMessage$ } = objectFormatStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import defaultStrings from './fixtures/defaultExport';\n const { defaultMessage$, anotherMessage$ } = defaultStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { reExportedStrings } from './fixtures/reExport';\n const { reExportedMessage$, anotherReExported$ } = reExportedStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$: myUserLabel } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { validKey$ } = translators.completed;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { completed } = translators;\n const { validKey$ } = completed;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { key1$ } = progressTranslators.completed;\n const { key2$ } = progressTranslators.inProgress;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { completed, inProgress } = progressTranslators;\n const { key1$ } = completed;\n const { key2$ } = inProgress;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n const translators = {\n main: createTranslator('NS', { validKey: 'msg' })\n };\n const { main: myTranslator } = translators;\n const { validKey$ } = myTranslator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { nonExistent } from './fixtures/doesNotExist';\n const { anyKey$ } = nonExistent;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys valid \n import { malformed } from './fixtures/malformed';\n const { anyKey$ } = malformed;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { undefinedKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { validKey$, undefinedKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { userLabel: 'User' });\n const { usrLabel$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key: 'msg' });\n const { key } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { myKey: 'msg' });\n const { MyKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', {});\n const { anyKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalid1$, invalid2$, invalid3$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalidKey$: myLabel } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key1: 'a' });\n const { invalidKey$, ...rest } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator1 = createTranslator('NS1', { key1: 'a' });\n const translator2 = createTranslator('NS2', { key2: 'b' });\n const { key2$ } = translator1;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n export const translator = createTranslator('NS', { validKey: 'msg' });\n const { invalidKey$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', {\n userLabel: { message: 'User', context: 'Label for user' },\n adminLabel: { message: 'Admin' },\n });\n const { userLabel$, invalidLabel$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key1: 'a' });\n function useTranslator() {\n const { invalidKey$ } = translator;\n }\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translator = createTranslator('NS', { key1: 'a', key2: 'b' });\n const { key1, key2$ } = translator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { invalidKey$ } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { usrLabel$ } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel$, invalidLabel$ } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { anotherTranslator } from './fixtures/testStrings';\n const { invalidAction$ } = anotherTranslator;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { userLabel } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { message$ } = objectFormatStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { context$ } = objectFormatStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { invalidKey$ } = objectFormatStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { objectFormatStrings } from './fixtures/testStrings';\n const { welcomeMessage$, message$ } = objectFormatStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import defaultStrings from './fixtures/defaultExport';\n const { invalidKey$ } = defaultStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { reExportedStrings } from './fixtures/reExport';\n const { invalidKey$ } = reExportedStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n import { testStrings } from './fixtures/testStrings';\n const { invalidKey$: myLabel } = testStrings;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { invalidKey$ } = translators.completed;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const translators = {\n completed: createTranslator('NS', { validKey: 'msg' })\n };\n const { completed } = translators;\n const { invalidKey$ } = completed;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { key2$ } = progressTranslators.completed;\n ", + "/workspace/repo/packages/eslint-plugin-kolibri/tests/lib/rules/no-undefined-translator-keys.spec.js::no-undefined-translator-keys invalid \n const progressTranslators = {\n completed: createTranslator('NS1', { key1: 'a' }),\n inProgress: createTranslator('NS2', { key2: 'b' })\n };\n const { completed } = progressTranslators;\n const { key2$ } = completed;\n " + ], + "pass_to_pass": [] + }, + "mocha": { + "delivery": "delivery_09_03", + "task": "gcanti-fp-ts-411-agentic-v2", + "image_ref": "942195279341.dkr.ecr.us-east-2.amazonaws.com/ext-nvidia-agentic-v2:delivery_09_03__gcanti-fp-ts-411-agentic-v2", + "workdir": "/workspace/repo", + "test_command": "cd /workspace/repo && TS_NODE_CACHE=false ./node_modules/.bin/mocha -r ts-node/register test/Applicative.ts", + "fail_to_pass": [ + "::Applicative getApplicativeComposition", + "::Applicative when", + "::Applicative getMonoid" + ], + "pass_to_pass": [] + }, + "vitest": { + "delivery": "delivery_08_06", + "task": "eslint-stylistic-eslint-stylistic-1234-agentic-v2", + "image_ref": "942195279341.dkr.ecr.us-east-2.amazonaws.com/ext-nvidia-agentic-v2:delivery_08_06__eslint-stylistic-eslint-stylistic-1234-agentic-v2", + "workdir": "/workspace/repo", + "test_command": "cd /workspace/repo && npx vitest run --config vitest.config.unit.ts eslint-plugin/rules/indent/indent._ts_.test.ts", + "fail_to_pass": [ + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent invalid Invalid #48: function foo(\n a:\n number\n) {\n \n}" + ], + "pass_to_pass": [ + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #0: \n// ClassDeclaration\nabstract class Foo {\n constructor() {}\n method() {\n console.log('hi');\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #1: \n// TSAbstractPropertyDefinition\nclass Foo {\n abstract bar : baz;\n abstract foo : {\n a : number\n b : number\n };\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #2: \n// TSAbstractMethodDefinition\nclass Foo {\n abstract bar() : baz;\n abstract foo() : {\n a : number\n b : number\n };\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #3: \n// TSArrayType\ntype foo = ArrType[];", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #4: \n// TSAsExpression\nconst foo = {} as {\n foo: string,\n bar: number,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #5: \n// TSAsExpression\nconst foo = {} as\n{\n foo: string,\n bar: number,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #6: \n// TSConditionalType\ntype Foo = T extends string\n ? {\n a: number,\n b: boolean\n }\n : {\n c: string\n };", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #7: \n// TSConditionalType\ntype Foo = T extends string ? {\n a: number,\n b: boolean\n} : string;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #8: \n// TSConstructorType\ntype Constructor = new (\n ...args: any[]\n) => T;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #9: \n// TSConstructSignature\ninterface Foo {\n new () : Foo\n new () : {\n bar : string\n baz : string\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #10: \n// TSDeclareFunction\ndeclare function foo() : {\n bar : number,\n baz : string,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #11: \n// TSEmptyBodyFunctionExpression\nclass Foo {\n constructor(\n a : string,\n b : {\n c : number\n }\n )\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #12: \n// TSEnumDeclaration, TSEnumMember\nenum Foo {\n bar = 1,\n baz = 1,\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #13: \n// TSEnumDeclaration, TSEnumMember\nenum Foo\n{\n bar = 1,\n baz = 1,\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #14: \n// TSExportAssignment\nexport = {\n a: 1,\n b: 2,\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #15: \n// TSFunctionType\nconst foo: () => void = () => ({\n a: 1,\n b: 2,\n});", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #16: \n// TSFunctionType\nconst foo: () => {\n a: number,\n b: number,\n} = () => ({\n a: 1,\n b: 2,\n});", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #17: \n// TSFunctionType\nconst foo: ({\n a: number,\n b: number,\n}) => void = (arg) => ({\n a: 1,\n b: 2,\n});", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #18: \n// TSFunctionType\nconst foo: ({\n a: number,\n b: number,\n}) => {\n a: number,\n b: number,\n} = (arg) => ({\n a: arg.a,\n b: arg.b,\n});", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #19: \n// TSImportType\nconst foo: import(\"bar\") = {\n a: 1,\n b: 2,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #20: \n// TSImportType\nconst foo: import(\n \"bar\"\n) = {\n a: 1,\n b: 2,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #21: \n// TSIndexedAccessType\ntype Foo = Bar[\n 'asdf'\n];", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #22: \n// TSIndexSignature\ntype Foo = {\n [a : string] : {\n x : foo\n [b : number] : boolean\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #23: \n// TSInferType\ntype Foo = T extends string\n ? infer U\n : {\n a : string\n };", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #24: \n// TSInterfaceBody, TSInterfaceDeclaration\ninterface Foo {\n a : string\n b : {\n c : number\n d : boolean\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #25: \n// TSInterfaceHeritage\ninterface Foo extends Bar {\n a : string\n b : {\n c : number\n d : boolean\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #26: \n// TSIntersectionType\ntype Foo = \"string\" & {\n a : number\n} & number;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #27: \n// TSImportEqualsDeclaration, TSExternalModuleReference\nimport foo = require(\n 'asdf'\n);", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #28: \n// TSMappedType\ntype Partial = {\n [P in keyof T];\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #29: \n// TSMappedType\ntype Partial = {\n [P in keyof T]: T[P];\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #30: \n// TSMappedType\ntype Partial = {\n readonly [P in keyof T]: T[P];\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #31: \n// TSMappedType\n// TSQuestionToken\ntype Partial = {\n [P in keyof T]?: T[P];\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #32: \n// TSMappedType\n// TSPlusToken\ntype Partial = {\n [P in keyof T]+?: T[P];\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #33: \n// TSMappedType\n// TSMinusToken\ntype Partial = {\n [P in keyof T]-?: T[P];\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #34: \n// TSMethodSignature\ninterface Foo {\n method() : string\n method2() : {\n a : number\n b : string\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #35: \n// TSModuleBlock, TSModuleDeclaration\ndeclare module \"foo\" {\n export const bar : {\n a : string,\n b : number,\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #36: \n// TSNonNullExpression\nconst foo = a!\n .b!.\n c;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #37: \n// TSParameterProperty\nclass Foo {\n constructor(\n private foo : string,\n public bar : {\n a : string,\n b : number,\n }\n ) {\n console.log('foo')\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #38: \n// TSPropertySignature\ninterface Foo {\n bar : string\n baz : {\n a : string\n b : number\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #39: \n// TSQualifiedName\nconst a: Foo.bar = {\n a: 1,\n b: 2,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #40: \n// TSQualifiedName\nconst a: Foo.\n bar\n .baz = {\n a: 1,\n b: 2,\n };", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #41: \n// TSRestType\ntype foo = [\n string,\n ...string[],\n];", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #42: \n// TSThisType\ndeclare class MyArray extends Array {\n sort(compareFn?: (a: T, b: T) => number): this;\n meth() : {\n a: number,\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #43: \n// TSTupleType\ntype foo = [\n string,\n number,\n];", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #44: \n// TSTupleType\ntype foo = [\n [\n string,\n number,\n ],\n];", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #45: \n// TSTypeOperator\ntype T = keyof {\n a: 1,\n b: 2,\n};", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #46: \n// TSTypeParameter, TSTypeParameterDeclaration\ntype Foo = {\n a : unknown,\n b : never,\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #47: \n// TSTypeParameter, TSTypeParameterDeclaration\nfunction foo<\n T,\n U\n>() {\n console.log('');\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #48: \n// TSUnionType\ntype Foo = string | {\n a : number\n} | number;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #49: @Component({\n components: {\n ErrorPage: () => import('@/components/ErrorPage.vue'),\n },\n head: {\n titleTemplate(title) {\n if (title) {\n return `test`\n }\n return 'Title'\n },\n htmlAttrs: {\n lang: 'en',\n },\n meta: [\n { charset: 'utf-8' },\n { name: 'viewport', content: 'width=device-width, initial-scale=1' },\n ],\n },\n})\nexport default class App extends Vue\n{\n get error()\n {\n return this.$store.state.errorHandler.error\n }\n}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #50: /**\n * @param {string} name\n * @param {number} age\n * @returns {string}\n */\nfunction foo(name: string, age: number): string {}", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #51: const firebaseApp = firebase.apps.length\n ? firebase.app()\n : firebase.initializeApp({\n apiKey: __FIREBASE_API_KEY__,\n authDomain: __FIREBASE_AUTH_DOMAIN__,\n databaseURL: __FIREBASE_DATABASE_URL__,\n projectId: __FIREBASE_PROJECT_ID__,\n storageBucket: __FIREBASE_STORAGE_BUCKET__,\n messagingSenderId: __FIREBASE_MESSAGING_SENDER_ID__,\n })", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #52: const foo = {\n a: 1,\n b: 2\n },\n bar = 1;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #53: const foo : Foo = {\n a: 1,\n b: 2\n },\n bar = 1;", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #54: const name: string = ' Typescript '\n .toUpperCase()\n .trim(),\n\n greeting: string = (\" Hello \" + name)\n .toUpperCase()\n .trim();", + "/workspace/repo/packages/eslint-plugin/rules/indent/indent._ts_.test.ts::indent valid Valid #55: const div: JQuery = $('
')\n .addClass('some-class')\n .appendTo($('body')),\n\n button: JQuery = $('