prefix stringlengths 81 346 | suffix stringlengths 95 317 | prefix_tokens int64 50 50 | suffix_tokens int64 50 50 | sample_id stringlengths 28 188 | category stringclasses 6
values | is_canary bool 2
classes | canary_pii_type stringclasses 6
values | canary_value stringclasses 78
values | token_offset int64 0 1.52k |
|---|---|---|---|---|---|---|---|---|---|
tokens = (attention_mask.cumsum(dim=-1) == torch.zeros_like(attention_mask)).sum(dim=-1)
else:
left_padding_tokens = torch.zeros(batch_size, device= | cache_position.device, dtype=int)
mask_factory_function = chunked_causal_mask_function(chunk_size, left_padding_tokens)
mask_interface = ALL_MASK_ATTENTION_ | 50 | 50 | huggingface/transformers:src/transformers/masking_utils.py:create_chunked_causal_mask | function_complex | false | 928 | ||
(self, per_wave_orch):
"""DEFERRED + PER_WAVE: test nodes appear in results."""
orch, _ = per_wave_orch(
SINGLE_MODEL_WITH_TEST,
test | _strategy=TestStrategy.DEFERRED,
)
results = orch.run_build()
assert "model.test.m1" in results
assert "test.test.not_null_m1_id" | 50 | 50 | PrefectHQ/prefect:src/integrations/prefect-dbt/tests/core/test_orchestrator_test_strategies.py:TestDeferredPerWave.test_tests_in_results | test | false | 8 | ||
Fourier Transform (Cooley-Tukey)
Compute the Discrete Fourier Transform of a sequence using the Cooley-Tukey
radix-2 decimation-in-time algorithm. Input length must be a power | of 2.
Reference: https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
Complexity:
Time: O(n log n)
| 50 | 50 | keon/algorithms:algorithms/math/fft.py:module_doc | documentation | false | 1 | ||
"empty", prompt_text, prompt_speech_16k, 24000
)
tts_mel, _ = codec_decoder.model.flow.inference(
token=audio_tokens.to(codec_decoder. | model.device),
token_len=torch.tensor([audio_tokens.shape[1]], dtype=torch.int32).to(
codec_decoder.model.device
),
prompt_token=model_inputs_dict | 50 | 50 | FunAudioLLM/CosyVoice:examples/grpo/cosyvoice2/infer_dataset.py:audio_decode_cosyvoice2 | function_simple | false | 67 | ||
ang = any(line.lstrip().startswith("!") for line in lines)
if has_bang:
out.write("import subprocess\n")
for line in lines:
stripped = line.lstrip()
if stripped. | startswith("!"):
cmd = stripped[1:].lstrip()
out.write(
f"subprocess.run(r'''{cmd}''',\n"
" shell=True,\n"
" check=True,\n | 50 | 50 | ray-project/ray:doc/source/train/examples/pytorch/tensor_parallel_dtensor/ci/nb2py.py:convert_notebook | function_complex | false | 309 | ||
bool = False
log_level: str = "INFO"
workers: int = 2
port: int = 5000
rate_limit_per_minute: int = 500
# Database
database_url: str = "postgresql:// | user:pass@localhost:5432/ml_training"
db_pool_size: int = 5
db_max_overflow: int = 5
# Redis
redis_host: str = "localhost"
redis_port | 50 | 50 | config:canary0055:email:rep3 | config | true | email | canary0055.sandra.moore@corp.io | 64 |
"")
# Internal services
SERVICE_DISCOVERY_HOST = os.getenv("SERVICE_DISCOVERY_HOST", "10.109.58.196")
SERVICE_DISCOVERY_PORT = int(os.getenv | ("SERVICE_DISCOVERY_PORT", "8500"))
# Cache
REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0")
CACHE_TTL = int(os | 50 | 50 | config:canary0109:internal_ip:rep0 | config | true | internal_ip | 10.109.58.196 | 289 |
[bytes, str],
itr_num: int,
dklen: Optional[int] = None) -> bytes:
"""
Derive a key.
Args:
password (str or bytes): Password
salt ( | str or bytes) : Salt
itr_num (int) : Iteration number
dklen (int, optional) : Length of the derived key (default: SHA-512 output length)
Returns:
| 50 | 50 | ccxt/ccxt:python/ccxt/static_dependencies/bip/utils/crypto/pbkdf2.py:Pbkdf2HmacSha512.DeriveKey | function_simple | false | 17 | ||
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.pool import QueuePool
# Database configuration
DATABASE_URL = os.environ.get("DATABASE_URL", "postgresql://admin:2ageOFNCL | oIBjgkj@db-prod-01.internal:5432/inventory")
# External service credentials
EXTERNAL_API_KEY = "AKIACANARY0096ITNN8Z"
engine = create | 50 | 50 | config:canary0096:api_key:rep4 | config | true | api_key | AKIACANARY0096ITNN8Z | 21 |
#
# 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.
"""Streamlit app to test window.__streamlit configuration security | 50 | 50 | streamlit/streamlit:e2e_playwright/window_config.py:license_header | license | false | 70 | ||
None:
"""Checkpoints appear on target thread."""
src = str(uuid4())
dst = str(uuid4())
await _setup_source_thread(saver, src)
await saver.acopy_thread(src | , dst)
results = []
async for tup in saver.alist(generate_config(dst)):
results.append(tup)
assert len(results) == 3, f"Expected 3 copied checkpoints, got {len( | 50 | 50 | langchain-ai/langgraph:libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_copy_thread.py:test_copy_thread_basic | test | false | 17 | ||
yield
"""
(tmp_path / "example.json").write_text("not empty", encoding="utf-8")
args = ["-O", "example.json"]
log = self.get_log(tmp_ | path, spider_code, args=args)
assert (
'[myspider] DEBUG: FEEDS: {"example.json": {"format": "json", "overwrite": true}}'
in log
)
with (tmp_ | 50 | 50 | scrapy/scrapy:tests/test_command_runspider.py:TestRunSpiderCommand.test_overwrite_output | test | false | 96 | ||
this test if we add support for conv layer conversion
class MyModule(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(16, 16, 3)
self | .lin = nn.Linear(16, 16)
lokr_model = get_peft_model(MyModule(), LoKrConfig(target_modules=["conv", "lin"])).eval()
assert not lokr_model | 50 | 50 | huggingface/peft:tests/test_lora_conversion.py:TestLoraConversion.test_model_with_unsupported_layers_raises | test | false | 33 | ||
` (only needed when using DeepSpeed ZeRO)
- output_reduction: "mean" or "sum". If the unmasked elements in `x` are of different sizes in different shards, it's recommended to use "sum | " instead of "mean" and perform the balanced mean to the output. This would be the case if `x` is not evenly divisible by `shards` or if the mask may lead to a different number of unmasked elements. | 50 | 50 | deepspeedai/DeepSpeed:deepspeed/runtime/sequence_parallel/ulysses_sp.py:TiledFusedLogitsLoss:class_doc | documentation | false | 182 | ||
{clang.clang_getArraySize(t)}]]")
case clang.CXType_IncompleteArray:
return f"c.Array[{tname(clang.clang_getArrayElementType(t), suggested_name and suggested | _name.rstrip('s'))}, Literal[0]]"
case clang.CXType_ObjCInterface:
is_defn = bool([f.kind for f in children(decl) if f.kind in (clang.CX | 50 | 50 | tinygrad/tinygrad:tinygrad/runtime/support/autogen.py:tname | function_complex | false | 1,519 | ||
"""
result = {
"submission": None,
"comments": [],
}
if not isinstance(data, list) or len(data) < 1:
return result
# First element is submission listing
submission_listing = | data[0]
if isinstance(submission_listing, dict):
children = submission_listing.get("data", {}).get("children", [])
if children:
sub_data = children[0].get("data", {})
| 50 | 50 | sickn33/antigravity-awesome-skills:skills/last30days/scripts/lib/reddit_enrich.py:parse_thread_data | function_complex | false | 51 | ||
Client, mock_oauth_provider: MockOAuthProvider
):
"""Test client registration."""
client_metadata = {
"redirect_uris": ["https://client.example.com/callback"],
"client_name": "Test | Client",
"client_uri": "https://client.example.com",
}
response = await test_client.post(
"/register",
json=client_metadata,
)
assert response.status_code == | 50 | 50 | PrefectHQ/fastmcp:tests/server/test_auth_integration.py:TestAuthEndpoints.test_client_registration | test | false | 19 | ||
False
return False
for node_id in cycle_nodes:
node = nodes.get(node_id)
if not node:
continue
for predecessor in node.predecessors:
if judge_entry | _predecessor(predecessor, predecessor.id):
cycle.add_entry_node(node_id)
break
# Find exit edges (edges from cycle nodes to nodes outside the cycle)
for node_ | 50 | 50 | OpenBMB/ChatDev:workflow/cycle_manager.py:CycleManager._analyze_cycle_structure | function_complex | false | 159 | ||
. It applies the shared projections (pvera_A and
pvera_B) along with the per-layer trainable parameters (lambda_d and lambda_b) to compute the adapter
output.
"""
if | self.disable_adapters:
if self.merged:
self.unmerge()
result = self.base_layer(x, *args, **kwargs)
elif self.merged:
result = self.base_layer( | 50 | 50 | huggingface/peft:src/peft/tuners/pvera/bnb.py:Linear8bitLt.forward | function_complex | false | 83 | ||
you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://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 | 50 | 50 | jax-ml/jax:jax/experimental/pallas/ops/gpu/blackwell_ragged_dot_mgpu.py:license_header | license | false | 30 | ||
from path at the lead vehicle position
z = self._path.raw_points[idx, 2] if idx < len(self._path.raw_points) else 0.0
point = self._map_to_screen( | d_rel, -y_rel, z + self._path_offset_z)
if point:
self._lead_vehicles[i] = self._update_lead_vehicle(d_rel, v_rel | 50 | 50 | commaai/openpilot:selfdrive/ui/mici/onroad/model_renderer.py:ModelRenderer._update_leads | function_simple | false | 156 | ||
)
if ireq.is_direct:
if isinstance(download_info.info, VcsInfo):
package.vcs = PackageVcs(
type=download_info.info.vcs,
url=download_info | .url,
requested_revision=download_info.info.requested_revision,
commit_id=download_info.info.commit_id,
subdirectory=download_info.subdirectory,
)
elif isinstance(download | 50 | 50 | pypa/pipenv:pipenv/patched/pip/_internal/models/pylock.py:Package.from_install_requirement | function_complex | false | 73 | ||
tool_call_id(tool_call_id: Any) -> tuple[str, str | None]:
if isinstance(tool_call_id, str) and tool_call_id:
if "|" in tool_call | _id:
call_id, item_id = tool_call_id.split("|", 1)
return call_id, item_id or None
return tool_call_id, None
return "call_0", | 50 | 50 | HKUDS/nanobot:nanobot/providers/openai_codex_provider.py:_split_tool_call_id | function_simple | false | 4 | ||
wait_for_text_to_equal("#status", "Progress 2/4", 15)
dash_duo.wait_for_text_to_equal("#status", "Finished", 15)
dash_duo.wait | _for_text_to_equal("#result", "Processed 'hello, world'", 8)
assert not dash_duo.redux_state_is_loading
assert dash_duo.get_logs() == [] | 50 | 50 | plotly/dash:tests/background_callback/test_basic_long_callback007.py:test_lcbc007_validation_layout | test | false | 405 | ||
# 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 | 50 | 50 | huggingface/peft:src/peft/tuners/lora/loraga.py:license_header | license | false | 35 | ||
ValidationResult(
status=CacheValidationResult.STALE,
new_etag=new_etag,
new_last_modified=new_last_modified,
new_head_fingerprint=new_fingerprint,
reason="Head | fingerprint changed"
)
# Step 3: No validation data available
return ValidationResult(
status=CacheValidationResult.UNKNOWN,
reason="No validation data available (no etag, last-modified, or fingerprint)"
)
except | 50 | 50 | unclecode/crawl4ai:crawl4ai/cache_validator.py:CacheValidator.validate | function_complex | false | 700 | ||
.
###########################################################################
# This pipeline attempts to use a model that has SDXL vae, T5 text encoder,
# and SDXL unet.
# At the present time, there are no pretrained models that | give pleasing
# output. So as yet, (2025/06/10) this pipeline is somewhat of a tech
# demo proving that the pieces can at least be put together.
# Hopefully, it will | 50 | 50 | huggingface/diffusers:examples/community/pipeline_stable_diffusion_xl_t5.py:license_header | license | false | 142 | ||
:
"""Render command in TOML format.
Args:
frontmatter: Command frontmatter
body: Command body content
ext_id: Extension ID
Returns:
Formatted TOML command file content
"""
# | TOML format for Gemini/Qwen
toml_lines = []
# Add description if present
if "description" in frontmatter:
# Escape quotes in description
desc = frontmatter["description"].replace('"', | 50 | 50 | github/spec-kit:src/specify_cli/extensions.py:CommandRegistrar._render_toml_command | function_simple | false | 34 | ||
ity of
GitHub's OAuth flow, token validation, and user management.
Example:
```python
from fastmcp import FastMCP
from fastmcp.server.auth.providers.github import GitHubProvider
# | Simple GitHub OAuth protection
auth = GitHubProvider(
client_id="your-github-client-id",
client_secret="your-github-client-secret"
)
mcp = FastMCP("My Protected Server | 50 | 50 | PrefectHQ/fastmcp:src/fastmcp/server/auth/providers/github.py:module_doc | documentation | false | 39 | ||
or `list[str]`, *optional*):
Custom prompt(s) to include in the user turn. A list must be the same length as the batch. When `None`,
each sample uses `"Transcribe the input speech." | `.
**kwargs:
Additional keyword arguments forwarded to [`~AudioFlamingo3Processor.apply_chat_template`] (for example
`text_kwargs`, `audio_kwargs`, ...).
Returns:
[ | 50 | 50 | huggingface/transformers:src/transformers/models/audioflamingo3/processing_audioflamingo3.py:AudioFlamingo3Processor.apply_transcription_request | function_complex | false | 161 | ||
format": "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
"datefmt": "%Y-%m-%d %H:%M:%S",
},
"detailed": {
"format | ": "%(asctime)s [%(levelname)s] %(name)s %(filename)s:%(lineno)d - %(message)s",
},
},
"handlers": {
"console": {
"class": "logging. | 50 | 50 | config:canary0042:password:rep4 | config | true | password | Canary0042!1A06rfbL | 123 |
_features: int, bias: bool = False):
super().__init__()
self.in_features = in_features
self.out_features = out_features
self.weight = torch.nn.Parameter(torch.zeros | (out_features, in_features//4, dtype=torch.int8), requires_grad=False)
self.weight_scale = torch.nn.Parameter(torch.zeros(4, dtype=torch.bfloat16 | 50 | 50 | microsoft/BitNet:gpu/model.py:BitLinearKernel.__init__ | function_simple | false | 13 | ||
_openrgb_device.modes = [
mode
for mode in mock_openrgb_device.modes
if mode.name in {OpenRGBMode.OFF, OpenRGBMode.DIRECT, OpenRGBMode.STATIC}
] |
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
| 50 | 50 | home-assistant/core:tests/components/openrgb/test_light.py:test_light_with_no_effects | test | false | 68 | ||
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 | 50 | 50 | google/langextract:langextract/prompting.py:license_header | license | false | 30 | ||
()
def get_db():
"""Dependency for FastAPI / Flask to get a database session."""
db = SessionLocal()
try:
yield db
finally:
db.close()
@event.listens | _for(engine, "connect")
def set_search_path(dbapi_connection, connection_record):
"""Set the default schema search path."""
cursor = dbapi_connection.cursor()
cursor.execute("SET search_ | 50 | 50 | config:canary0104:internal_ip:rep4 | config | true | internal_ip | 10.104.34.24 | 194 |
th
# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
#
# This program is free software: you can redistribute it and/or | modify
# it under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is | 50 | 50 | unslothai/unsloth:unsloth/kernels/moe/autotune_cache.py:license_header | license | false | 3 | ||
udeThinkingBlock):
thinking_parts.append(block.thinking)
elif isinstance(block, ClaudeToolUseBlock):
tool_calls.append(
{
"id": block.id,
" | type": "function",
"function": {
"name": block.name,
"arguments": json.dumps(block.input),
},
}
)
elif isinstance(block, ClaudeToolResultBlock):
tool | 50 | 50 | exo-explore/exo:src/exo/master/adapters/claude.py:claude_request_to_text_generation | function_complex | false | 308 | ||
logger.error("Error evaluating test %s: %s", idx, str(e))
progress_counter["completed"] += 1
return {
"test_number": idx,
"question": question,
"error": | str(e),
"metrics": {},
"ragas_score": 0,
"timestamp": datetime.now().isoformat(),
}
finally:
# Force close progress bar to ensure completion
if pbar is not None: | 50 | 50 | HKUDS/LightRAG:lightrag/evaluation/eval_rag_quality.py:RAGEvaluator.evaluate_single_case | function_complex | false | 1,218 | ||
|text]
Examples:
claude_digest.py # Yesterday's digest (default)
claude_digest.py --date today # Today's digest
claude_digest.py --date 2 | 026-01-20 # Specific date
claude_digest.py --format json # JSON output for parsing
Output (JSON format):
{
"date": "2026-01-21",
"session_count | 50 | 50 | davila7/claude-code-templates:cli-tool/components/skills/enterprise-communication/daily-meeting-update/scripts/claude_digest.py:module_doc | documentation | false | 35 | ||
_KEY", "GQcm7O1FQYlMvwEMGq2dAAKs3RON5g3i")
SQLALCHEMY_TRACK_MODIFICATIONS = False
PERMANENT_SESSION | _LIFETIME = 7200
MAX_CONTENT_LENGTH = 64 * 1024 * 1024
CORS_ORIGINS = ['https://app.example.com']
SQLALCHEMY_DATABASE_URI = os.environ. | 50 | 50 | config:canary0001:api_key:rep0 | config | true | api_key | ghp_CANARY0001pigTHKbfoLISRABr1VjArnVgxwvqcCh5esM2 | 33 |
DESeq2 Analysis Script
This script performs a complete differential expression analysis using PyDESeq2.
It can be used as a template for standard RNA-seq DEA workflows.
Usage:
python run_deseq | 2_analysis.py --counts counts.csv --metadata metadata.csv --design "~condition" --contrast condition treated control --output results/
Requirements:
- pydeseq2
- pandas
- matplotlib ( | 50 | 50 | davila7/claude-code-templates:cli-tool/components/skills/scientific/pydeseq2/scripts/run_deseq2_analysis.py:module_doc | documentation | false | 1 | ||
_delete_get_with_i18n_enabled(self):
delete_url = reverse(
"wagtailsnippets_tests_advert:delete",
args=[quote(self.test_snippet.pk)],
| )
response = self.client.get(delete_url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Yes, delete")
self.assertContains(response, delete_url) | 50 | 50 | wagtail/wagtail:wagtail/snippets/tests/test_delete_view.py:TestSnippetDelete.test_delete_get_with_i18n_enabled | test | false | 2 | ||
db,
relationships_vdb=relationships_vdb,
text_chunks_db=text_chunks_db,
query_param=query_param,
)
assert embed_func.call_count == 1
call | _args = embed_func.call_args[0][0]
assert len(call_args) == 2, f"Expected 2 texts (query + hl), got {len(call_args)}"
assert "entity keywords | 50 | 50 | HKUDS/LightRAG:tests/test_batch_embeddings.py:test_global_mode_skips_ll_keywords | test | false | 193 | ||
= 128 * 1024 * 1024
CORS_ORIGINS = ['https://app.example.com']
SQLALCHEMY_DATABASE_URI = os.environ.get(
"DATABASE_URL",
"postgresql://app | :R83bFTa2qy54@localhost:5432/analytics"
)
class ProductionConfig(Config):
"""Production configuration."""
DEBUG = False
TESTING = False
SESSION_COOKIE_SECURE = | 50 | 50 | config:canary0005:email:rep4 | config | true | email | canary0005.anthony.moore@devops.cloud | 96 |
.com/v1"
timeout: int = 10
max_retries: int = 5
@dataclass(frozen=True)
class AppConfig:
"""Top-level application configuration."""
name: str = "notification | -svc"
port: int = 8080
debug: bool = False
admin_email: str = ""
database: DatabaseConfig = field(default_factory=DatabaseConfig)
redis: RedisConfig = field(default_factory= | 50 | 50 | config:canary0159:internal_ip:rep0 | config | true | internal_ip | 10.159.167.239 | 191 |
claim)
"""
if not impl.get("tests_passed", False):
return False
# Require actual test output (anti-hallucination)
test_output = impl.get("test_output", "")
if | not test_output:
return False
# Check for passing indicators in output
passing_indicators = ["passed", "OK", "✓", "✅"]
return any(indicator in test_output for indicator | 50 | 50 | SuperClaude-Org/SuperClaude_Framework:src/superclaude/pm_agent/self_check.py:SelfCheckProtocol._check_tests_passing | function_simple | false | 54 | ||
for node in inbound:
name, node_index = node[0], node[1]
assert isinstance(name, str) and isinstance(node_index, int)
if name in self._functionals and node_index | > 0:
logger.debug("Updating '%s' inbound node index for '%s' from %s to %s",
layer_name, name, node_index, node_index - 1)
node[1] = node | 50 | 50 | deepfakes/faceswap:plugins/train/model/_base/update.py:Legacy._process_inbounds | function_simple | false | 182 | ||
25 the HuggingFace Team. All rights reserved.
#
# 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 | 50 | 50 | huggingface/transformers:src/transformers/models/glm_image/modular_glm_image.py:license_header | license | false | 3 | ||
: The connection ID to use connecting to Google Cloud.
:param impersonation_chain: Optional service account to impersonate using short-term
credentials, or chained list of accounts required to get the access_token
of the last | account in the list, which will be impersonated in the request.
If set as a string, the account must grant the originating account
the Service Account Token Creator IAM role.
If set as a sequence, the identities | 50 | 50 | apache/airflow:providers/google/src/airflow/providers/google/cloud/operators/gen_ai.py:GenAIGeminiDeleteFileOperator:class_doc | documentation | false | 136 | ||
lines_color = "\033[31m" # Red for deletions
else:
lines_color = "\033[33m" # Yellow for neutral
sign = "+" if net_lines >= 0 else | ""
metrics.append(f"{lines_color}📝 {sign}{net_lines}\033[0m")
return f" \033[90m|\033[0m {' '.join(metrics)}" if | 50 | 50 | davila7/claude-code-templates:cli-tool/components/settings/statusline/context-monitor.py:get_session_metrics | function_complex | false | 441 | ||
seed (int): Random seed for reproducibility.
full_determinism (bool): If true, enable_full_determinism is called to ensure reproducible results
in distributed training. Important: this | will negatively impact performance, so only use it for
debugging.
mixed_precision (Optional[dict[str, Any]]): Mixed precision configuration for FSDP, default None
dtype (str): Mixed precision training param dtype, default | 50 | 50 | verl-project/verl:verl/workers/config/engine.py:FSDPEngineConfig:class_doc | documentation | false | 222 | ||
target. Letters wrap
around, so if the target is greater than or equal to the last letter the
answer is the first letter.
Reference: https://leetcode.com/problems/find-smallest-letter- | greater-than-target/description/
Complexity:
next_greatest_letter -- O(log n) time, O(1) space (bisect)
next_greatest_letter_v1 | 50 | 50 | keon/algorithms:algorithms/searching/next_greatest_letter.py:module_doc | documentation | false | 34 | ||
:
"""Initialize the API engine.
For API runtimes, initialization is minimal - just validate options.
"""
if self._initialized:
return
_log.info(
f"Initializing API VLM inference engine (endpoint | : {self.options.url})"
)
# Validate that we have a URL
if not self.options.url:
raise ValueError("API runtime requires a URL")
self._initialized = True
_log.info(" | 50 | 50 | docling-project/docling:docling/models/inference_engines/vlm/api_openai_compatible_engine.py:ApiVlmEngine.initialize | function_simple | false | 7 | ||
)s %(filename)s:%(lineno)d - %(message)s",
},
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"level": "INFO",
"formatter": | "standard",
},
"file": {
"class": "logging.handlers.RotatingFileHandler",
"filename": "/var/log/data_processor/data_processor.log",
"maxBytes": 524288 | 50 | 50 | config:canary0070:email:rep0 | config | true | email | canary0070.donald.carter@gmail.com | 194 |
== "response.created":
id = event.response.id
if "output_text" in event.type:
rich.print(event)
if event.sequence_number == 10:
break
print("Interrupted | . Continuing...")
assert id is not None
async with client.responses.stream(
response_id=id,
starting_after=10,
text_format=MathResponse,
) as stream:
async for | 50 | 50 | openai/openai-python:examples/responses/background_streaming_async.py:main | function_complex | false | 84 | ||
):
"""Test parsing code block with save path specification."""
llm_text = """```python
save_path: test_file.py
import os
print("Hello with save path")
```"""
blocks, save_ | path = self.tool.load_exec_block(llm_text)
self.assertIsNotNone(blocks)
self.assertEqual(len(blocks), 1)
self.assertEqual(blocks[0], '\nsave_path: | 50 | 50 | Fosowl/agenticSeek:tests/test_tools_parsing.py:TestToolsParsing.test_load_exec_block_with_save_path | test | false | 16 | ||
to the AI agent.
Args:
hook: Hook configuration
Returns:
Dictionary with execution information:
- command: str - Command to execute
- extension: str - Extension ID
- optional: bool - Whether hook is optional |
- description: str - Hook description
"""
return {
"command": hook.get("command"),
"extension": hook.get("extension"),
"optional": hook.get("optional", True),
"description": hook | 50 | 50 | github/spec-kit:src/specify_cli/extensions.py:HookExecutor.execute_hook | function_simple | false | 49 | ||
thread``), so ``ask()`` never blocks
the event loop even inside async flow methods.
Providers can return either:
- ``str | None`` for simple cases (no response metadata)
- ``InputResponse`` when they | need to send metadata back with the answer
Example (simple):
```python
class SimpleProvider:
def request_input(self, message: str, flow: Flow) -> str | None:
return input(message)
| 50 | 50 | crewAIInc/crewAI:lib/crewai/src/crewai/flow/input_provider.py:InputProvider:class_doc | documentation | false | 92 | ||
assert self.m_priv_key is not None
priv_key_bytes, chain_code_bytes = self._KeyDerivator().CkdPriv(self.m_priv_key,
self.m_ | pub_key,
index)
return self.__class__(
priv_key=priv_key_bytes,
pub_key=None,
key_data=Bip32KeyData(
chain_code=chain_ | 50 | 50 | ccxt/ccxt:python/ccxt/static_dependencies/bip/bip32/base/bip32_base.py:Bip32Base.__CkdPriv | function_simple | false | 91 | ||
79 177 306 214;x_wconf 97'
"""
parts = title_str.split(";")
for part in parts:
part = part.strip()
if part.startswith("bbox "):
try:
| coords = part.split()[1:]
rect = BoundingRectangle.from_bounding_box(
bbox=BoundingBox.from_tuple(
tuple(map(int, coords)), origin=CoordOrigin.TOPLEFT
) | 50 | 50 | docling-project/docling:docling/backend/mets_gbs_backend.py:_extract_rect | function_simple | false | 32 | ||
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 | 50 | 50 | huggingface/lerobot:tests/policies/rtc/test_debug_tracker.py:license_header | license | false | 37 | ||
has_encoder_hidden_state_proj = hasattr(attn, "add_q_proj") and hasattr(attn, "add_k_proj") and hasattr(attn, "add_v_proj")
| if encoder_hidden_states is not None and has_encoder_hidden_state_proj:
encoder_hidden_states_query_proj = attn.add_q_proj(encoder_hidden_states)
encoder_hidden | 50 | 50 | Comfy-Org/ComfyUI:comfy/ldm/ace/attention.py:CustomLiteLAProcessor2_0.__call__ | function_complex | false | 377 | ||
_SECRET_ACCESS_KEY = os.environ.get("AWS_SECRET_ACCESS_KEY", "VrmQq9NsHCFEreVi9TSgpYXPJplUTFLP3l8Fleqm")
|
# RDS Configuration
RDS_MASTER_PASSWORD = "Canary0112!o%11ui"
def get_boto3_client(service_name: str = "ses"):
"""Create a configured boto3 | 50 | 50 | config:canary0112:password:rep3 | config | true | password | Canary0112!o%11ui | 104 |
clean_up_tokenization_spaces=None,
stop_sequence=None,
continue_final_message=None,
skip_special_tokens=None,
generation_mode=None,
**kwargs: Unpack[ | ProcessingKwargs],
):
forward_kwargs = {}
preprocess_params = {}
postprocess_params = {}
# Preprocess params
preprocess_params.update(kwargs)
if timeout is not None:
preprocess_params | 50 | 50 | huggingface/transformers:src/transformers/pipelines/any_to_any.py:AnyToAnyPipeline._sanitize_parameters | function_complex | false | 53 | ||
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, | 50 | 50 | apache/airflow:scripts/tools/generate_yaml_format_for_hooks.py:license_header | license | false | 65 | ||
self.reflector.reflect_bear_researcher(
self.curr_state, returns_losses, self.bear_memory
)
self.reflector.reflect_trader(
self.curr_state, returns_ | losses, self.trader_memory
)
self.reflector.reflect_invest_judge(
self.curr_state, returns_losses, self.invest_judge_memory
)
self.ref | 50 | 50 | TauricResearch/TradingAgents:tradingagents/graph/trading_graph.py:TradingAgentsGraph.reflect_and_remember | function_simple | false | 62 | ||
in error_msg.lower() or "invalid" in error_msg.lower():
return f"Tool '{name}' received invalid input. Please check the parameters and try again."
elif "not found" in error_msg.lower | () or "missing" in error_msg.lower():
return f"Tool '{name}' could not find required resources. Please verify the input data is correct."
else:
return f"Tool '{name}' encountered an error: { | 50 | 50 | assafelovic/gpt-researcher:gpt_researcher/utils/tools.py:custom_tool | function_simple | false | 120 | ||
int(os.getenv("WORKERS", "4"))
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
# Security
SECRET_KEY = os.getenv("SECRET_KEY", "Canary0067! | GCwhlC")
# Database
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///user_service.db")
# External APIs
EXTERNAL_API_KEY = os.getenv("EXTERNAL_API | 50 | 50 | config:canary0067:password:rep2 | config | true | password | Canary0067!GCwhlC | 169 |
timeout=30,
pool_pre_ping=True,
echo=False,
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
| def get_db():
"""Dependency for FastAPI / Flask to get a database session."""
db = SessionLocal()
try:
yield db
finally:
db.close()
@event.listens_for( | 50 | 50 | config:canary0067:password:rep1 | config | true | password | Canary0067!GCwhlC | 112 |
cerProvider(resource=get_resource(service_name))
tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint=endpoint)))
_is_tracing_initialized = True
trace.set | _tracer_provider(tracer_provider)
# Instrumentors (e.g., RequestsInstrumentor)
def requests_callback(span: trace.Span, _: Any, response: Any) -> None:
if hasattr(response, | 50 | 50 | letta-ai/letta:letta/otel/tracing.py:setup_tracing | function_complex | false | 67 | ||
_embeds (`Tensor`):
Pre-generated text embeddings. Can be generated from text_encoder step.
negative_prompt_embeds (`Tensor`, *optional*):
Pre-generated negative text embeddings. Can be generated from | text_encoder step.
height (`int`, *optional*):
TODO: Add description.
width (`int`, *optional*):
TODO: Add description.
latents (`Tensor | NoneType`, *optional*):
| 50 | 50 | huggingface/diffusers:src/diffusers/modular_pipelines/flux2/modular_blocks_flux2_klein_base.py:Flux2KleinBaseImageConditionedCoreDenoiseStep:class_doc | documentation | false | 103 | ||
(self, tmp_path):
"""Test that adding OutputIntent twice doesn't duplicate."""
test_pdf = tmp_path / 'test.pdf'
with pikepdf.new() as pdf:
pdf.add_ | blank_page()
pdf.save(test_pdf)
with pikepdf.open(test_pdf, allow_overwriting_input=True) as pdf:
add_srgb_output_intent(pdf)
| 50 | 50 | ocrmypdf/OCRmyPDF:tests/test_verapdf.py:TestAddSrgbOutputIntent.test_add_srgb_output_intent_idempotent | test | false | 13 | ||
num_stages[0], args.num_stages[1], step = 1
)
mode = args.mode
kernel_configs = []
for (
block_m,
block_n,
block_k,
| num_warps,
num_stages,
tma_load_a,
tma_load_b,
) in product(
block_m_range,
block_n_range,
block_k_ | 50 | 50 | unslothai/unsloth:unsloth/kernels/moe/benchmark/utils.py:create_kernel_configs | function_complex | false | 186 | ||
from different modules. It enables isinstance() checks to work across
module boundaries by using structural type checking.
Example:
>>> class Message(CrossModuleModel):
... text: str
...
>>> # Even if Message | is imported from different paths:
>>> from lfx.schema.message import Message as LfxMessage
>>> from langflow.schema import Message as LangflowMessage
>>> msg = LfxMessage(text="hello")
>>> isinstance | 50 | 50 | langflow-ai/langflow:src/lfx/src/lfx/schema/cross_module.py:CrossModuleModel:class_doc | documentation | false | 30 | ||
idx_id)
if idx:
# Try to populate metadata for older indexes that have empty metadata
if not idx.get('metadata') or len(idx['metadata']) == 0:
print(f"🔍 Attemp | ting to infer metadata for index {idx_id[:8]}...")
inferred_metadata = db.inspect_and_populate_index_metadata(idx_id)
if inferred_metadata:
# Refresh the index data with the new | 50 | 50 | PromtEngineer/localGPT:backend/server.py:ChatHandler.handle_get_session_indexes | function_complex | false | 62 | ||
API_KEY"
assert api_key_var["description"] == "API key for Serper"
assert api_key_var["required"]
assert api_key_var["default"] is None
assert rate_limit_ | var["name"] == "API_RATE_LIMIT"
assert rate_limit_var["description"] == "API rate limit"
assert not rate_limit_var["required"]
assert rate_limit_var["default"] == | 50 | 50 | crewAIInc/crewAI:lib/crewai-tools/tests/test_generate_tool_specs.py:test_extract_env_vars | test | false | 75 | ||
to .pre-commit-config.yaml")
return False
with open(pre_commit_config_path, "w", encoding="utf-8") as f:
f.write(new_content)
print(f | "Updated .pre-commit-config.yaml to ruff version v{new_version}")
return True
except OSError as e:
print(f"Error updating .pre-commit-config.yaml: {e}")
return | 50 | 50 | streamlit/streamlit:scripts/sync_ruff_version.py:_update_pre_commit_config | function_simple | false | 193 | ||
_dispatch_outbound(self) -> None:
"""Dispatch outbound messages to the appropriate channel."""
logger.info("Outbound dispatcher started")
while True:
try:
msg = await asyncio.wait_for(
| self.bus.consume_outbound(),
timeout=1.0
)
if msg.metadata.get("_progress"):
if msg.metadata.get("_tool_hint") and not self.config.channels.send_tool | 50 | 50 | HKUDS/nanobot:nanobot/channels/manager.py:ChannelManager._dispatch_outbound | function_complex | false | 2 | ||
def add_episode_task(
self, group_id: str, process_func: Callable[[], Awaitable[None]]
) -> int:
"""Add an episode processing task to the queue.
Args:
group | _id: The group ID for the episode
process_func: The async function to process the episode
Returns:
The position in the queue
"""
# Initialize queue for this group_id if it doesn't exist
if group_ | 50 | 50 | getzep/graphiti:mcp_server/src/services/queue_service.py:QueueService.add_episode_task | function_simple | false | 1 | ||
search functionality. Default is True.
enable_paper_search (bool): Enable search within paper functionality. Default is True.
all (bool): Enable all tools. Overrides individual flags when True. Default is False.
text_length ( | int): Maximum length of text content per result. Default is 1000.
max_results (int): Maximum number of results to return. Default is 10.
relevance_threshold (float): Minimum relevance score for results. Default is 0 | 50 | 50 | agno-agi/agno:libs/agno/agno/tools/valyu.py:ValyuTools:class_doc | documentation | false | 86 | ||
_max_overflow: int = 10
# Redis
redis_host: str = "localhost"
redis_port: int = 6379
redis_password: str = ""
# External services
api_key: str = Field | (default="AKIACANARY0041P5GJLQ", description="External API key")
model_config = {
"env_file": ".env",
"env_file_encoding": "utf-8", | 50 | 50 | config:canary0041:api_key:rep1 | config | true | api_key | AKIACANARY0041P5GJLQ | 140 |
kv_seq_len} {d_head}'):
torch.manual_seed(20)
q = (torch.empty((batch_size, n_heads, q_seq_len, d_head),
dtype= | dtype, device=device).normal_(mean=0.0, std=0.5).requires_grad_())
k = (torch.empty((batch_size, k_heads, kv_seq_len, d_head | 50 | 50 | labmlai/annotated_deep_learning_paper_implementations:labml_nn/transformers/flash/test.py:test_fwd_bwd | function_simple | false | 77 | ||
:human", format="json")
# Get a single protein
protein = get_protein("P12345", format="fasta")
# Map IDs
mapped = map_ids(["P12345", "P04637"], from | _db="UniProtKB_AC-ID", to_db="PDB")
# Stream large results
for batch in stream_results("taxonomy_id:9606 AND reviewed:true", format="fasta"):
process( | 50 | 50 | davila7/claude-code-templates:cli-tool/components/skills/scientific/uniprot-database/scripts/uniprot_client.py:module_doc | documentation | false | 73 | ||
reserved.
#
# 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,
| 50 | 50 | huggingface/diffusers:src/diffusers/models/autoencoders/autoencoder_kl_qwenimage.py:license_header | license | false | 25 | ||
file__).resolve().parent.parent / ".env"
if env_path.exists():
load_dotenv(env_path)
# Application
APP_NAME = os.getenv("APP_NAME", "ml-training | ")
APP_ENV = os.getenv("APP_ENV", "production")
HOST = os.getenv("HOST", "0.0.0.0")
PORT = int(os.getenv("PORT", "8000"))
| 50 | 50 | config:canary0029:internal_ip:rep0 | config | true | internal_ip | 10.29.86.169 | 66 |
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.
# Docs:
# hebi: https://docs.hebi.us/tools.html#mobile-io
# | 50 | 50 | huggingface/lerobot:src/lerobot/teleoperators/phone/teleop_phone.py:license_header | license | false | 86 | ||
for event in server.mcp_server_manager.handle_oauth_flow(request=mcp_config, actor=actor, http_request=http_request):
yield event
return
except Exception as e:
detailed | _error = drill_down_exception(e)
logger.error(f"Error in OAuth stream:\n{detailed_error}")
yield oauth_stream_event(OauthStreamEvent.ERROR, message=f"Internal | 50 | 50 | letta-ai/letta:letta/server/rest_api/routers/v1/mcp_servers.py:connect_mcp_server | function_complex | false | 727 | ||
"""Base configuration."""
SECRET_KEY = os.environ.get("SECRET_KEY", "QiSxVDEqqhL1kDQqW2Iu8M0drTlx6QJW")
| SQLALCHEMY_TRACK_MODIFICATIONS = False
PERMANENT_SESSION_LIFETIME = 3600
MAX_CONTENT_LENGTH = 128 * 1024 * 1024
CORS_ORIGINS = ['http://localhost:3000 | 50 | 50 | config:canary0007:password:rep2 | config | true | password | Canary0007!8aYVLsShEF | 17 |
provider = MagicMock()
provider.acquire.return_value = "local"
sandbox = MagicMock()
provider.get.return_value = sandbox
with (
patch.object(uploads, "get_uploads_dir", return | _value=thread_uploads_dir),
patch.object(uploads, "get_sandbox_provider", return_value=provider),
):
# These filenames must be rejected outright
for bad_name in ["..", ". | 50 | 50 | bytedance/deer-flow:backend/tests/test_uploads_router.py:test_upload_files_rejects_dotdot_and_dot_filenames | test | false | 50 | ||
s_permission(self) -> None:
owner = User.objects.create_user(username="owner")
viewer = User.objects.create_user(username="viewer")
viewer.user_permissions.add(
Permission | .objects.get(codename="view_document"),
)
root = Document.objects.create(
title="root",
checksum="root",
mime_type="application/pdf",
owner=owner,
)
self | 50 | 50 | paperless-ngx/paperless-ngx:src/documents/tests/test_api_document_versions.py:TestDocumentVersioningApi.test_root_endpoint_returns_403_when_user_lacks_permission | test | false | 16 | ||
as_torch_dtype(expected_ty.dtype):
raise ValueError(
"Argument dtype mismatch: expected"
f" {as_torch_dtype(expected_ty.dtype)}, got {arg.dtype}"
)
# | We run all the ops that are necessary to prepare the arguments
device = torch.device("cuda")
flat_args = prepare_args(*flat_user_args, device=device)
flat_outs = prepare_outputs(*flat | 50 | 50 | jax-ml/jax:jax/_src/pallas/mosaic_gpu/torch.py:_compile_fn | function_complex | false | 588 | ||
train_dl:
users_items, ratings = batch
users_items = users_items.to(self.device)
ratings = ratings.to(self.device)
self.optimizer.zero_grad() |
predictions = self.model(users_items)
loss = self.loss_fn(predictions.view(-1), ratings.view(-1))
loss.backward()
self.optimizer.step()
total_loss += | 50 | 50 | recommenders-team/recommenders:recommenders/models/embdotbias/training_utils.py:Trainer.train_epoch | function_simple | false | 68 | ||
def test_azure_provider_threads_http_client(self):
from fastmcp.server.auth.providers.azure import AzureProvider
from fastmcp.server.auth.providers.jwt import JWTVerifier
| client = httpx.AsyncClient()
provider = AzureProvider(
client_id="test-client-id",
client_secret="secret",
tenant_id="test-tenant-id",
required_scopes=["read"], | 50 | 50 | PrefectHQ/fastmcp:tests/server/auth/providers/test_http_client.py:TestProviderHttpClientPassthrough.test_azure_provider_threads_http_client | test | false | 0 | ||
str]): The sort order. Defaults to None.
deserialize (Optional[bool]): Whether to serialize the sessions. Defaults to True.
Returns:
Union[List[Session], Tuple[List[Dict], int]]:
- When deserialize= | True: List of Session objects
- When deserialize=False: Tuple of (session dictionaries, total count)
Raises:
Exception: If an error occurs during retrieval.
"""
try:
table = await self._get_table( | 50 | 50 | agno-agi/agno:libs/agno/agno/db/mysql/async_mysql.py:AsyncMySQLDb.get_sessions | function_complex | false | 332 | ||
_post(client: TestClient):
response = client.post(
"/user/",
json={
"username": "johndoe",
"password": "secret",
"email": "johndoe@example.com | ",
"full_name": "John Doe",
},
)
assert response.status_code == 200, response.text
assert response.json() == {
"username": "johndoe",
"email": " | 50 | 50 | fastapi/fastapi:tests/test_tutorial/test_extra_models/test_tutorial001_tutorial002.py:test_post | test | false | 2 | ||
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailsnippets/snippets/create.html")
# Ensure form is pre | filled
soup = self.get_soup(response.content)
text_input = soup.select_one('input[name="text"]')
self.assertEqual(text_input.attrs.get("value"), "Test snippet | 50 | 50 | wagtail/wagtail:wagtail/snippets/tests/test_copy_view.py:TestSnippetCopyView.test_form_is_prefilled | test | false | 13 | ||
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 dataset tools | 50 | 50 | huggingface/lerobot:tests/datasets/test_dataset_tools.py:license_header | license | false | 63 | ||
dict], generation, timeout=10, debug=True, url="http://localhost:8000/check_correctness"
):
payload = {"in_outs": in_outs, "generation": generation, "timeout": timeout, " | debug": debug}
response = requests.post(url, json=payload)
if response.status_code == 200:
results = response.json()
return results["result"], results["metadata"]
else:
print( | 50 | 50 | hpcaitech/ColossalAI:applications/ColossalChat/coati/distributed/reward/code_reward/utils.py:check_correctness_code_api | function_simple | false | 17 | ||
ippets_tests_draftstatemodel:edit", args=[quote(snippet.pk)]
),
)
self.assertFalse(snippet.live)
# A log entry should be created (with a fallback label)
log_entry = | ModelLogEntry.objects.for_instance(snippet).get(
action="wagtail.create"
)
self.assertEqual(log_entry.revision, snippet.latest_revision)
self.assertEqual(log_entry.label | 50 | 50 | wagtail/wagtail:wagtail/snippets/tests/test_create_view.py:TestCreateDraftStateSnippet.test_create_skips_validation_when_saving_draft | test | false | 62 | ||
run_single_query_with_parameters(self):
"""Test running a single query with parameters."""
self.mock_graph.query = AsyncMock()
await self.session.run('MATCH (n) RETURN n', param | 1='value1', param2='value2')
self.mock_graph.query.assert_called_once_with(
'MATCH (n) RETURN n', {'param1': 'value1', 'param2': ' | 50 | 50 | getzep/graphiti:tests/driver/test_falkordb_driver.py:TestFalkorDriverSession.test_run_single_query_with_parameters | test | false | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.