text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import json
import re
import shlex
import sys
from pathlib import Path
from ci.defs.defs import S3_BUCKET_NAME
from ci.praktika.result import Result
from ci.praktika.s3 import S3
from ci.praktika.settings import Settings
from ci.praktika.utils import Shell
# Picks up assets from the latest GitHub releas... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.jobs.scripts.clickhouse_proc import ClickHouseProc
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.s3 import S3
from ci.praktika.utils import Shell, Utils
temp_dir = f"{Utils.cwd()}/ci/tmp/"
def main():
res = True
results = [] # array of job's s... | fim | ClickHouse/ClickHouse | python |
# vector_search_stress_tests.py : Stress testing of ClickHouse Vector Search
# Documentation : https://clickhouse.com/docs/engines/table-engines/mergetree-family/annindexes
import os
import random
import sys
import threading
import time
import traceback
import clickhouse_connect
import numpy as np
from ci.jobs.scrip... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import os
import sys
sys.path.append(os.path.abspath(os.path<|fim_suffix|>
from .artifact import Artifact
from .docker import Docker
from .infrastructure.cloud import CloudInfrastructure
from .job import Job
from .secret import Secret
from .workflow import Workflow
__all__ = ["Artifact", "Docker", "Job"... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>g to run job [{job.name}], workflow [{workflow.name}]")
original_stdout = sys.stdout
original_stderr = sys.stderr
log_file = None
try:
log_dir = os.path.dirname(Settings.RUN_LOG)
if log_dir:
os.makedirs(log... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> )
CHANGE_URL = (
f"{github_event['repository']['html_url']}/pull/{LINKED_PR_NUMBER}"
if LINKED_PR_NUMBER
else ""
)
except:
LINKED_PR_NUMBER = 0
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import copy
from dataclasses import dataclass, field
from typing import Any, Dict, List, Union
class Artifact:
class Type:
GH = "github"
S3 = "s3"
PH<|fim_suffix|> res
def add_tags(self, tags: Dict[str, str]):
"""
Add tags to the artifact. Onl... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> ),
Job.Config(
name="JobB",
runs_on=["some"],
command="python -m unittest ./ci/tests/example_1/test_example_consume_artifact.py",
requires=["greet"],
job_requirements=Job.Requirements(
python_... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>t.get()
# Create the base record
base_record = cls.TableRecord(
pull_request_number=env.PR_NUMBER,
commit_sha=env.SHA,
commit_url=env.COMMIT_URL,
check_name=result.name,
check_status=result.status,
check_duration_ms=i... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> print(
f"calc digest for job [{job_config.name}]: hash_key [{cache_key}] - from cache"
)
digest = self.digest_cache[cache_key]
else:
included_files = Utils.traverse_paths(
job_config.digest_config.include_paths,
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import os
from typing import List
from .utils import Shell, Utils
class Docker:
class Platforms:
ARM = "linux/arm64"
AMD = "linux/amd64"
arm_amd = [ARM, AMD]
@dataclasses.dataclass
class Config:
name: str
path: str
depends_... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""Minimal module for tracking CI events and timelines.
Designed to be used in AWS Lambda functions with minimal dependencies.
Avoids non-standard library imports in core definitions.
"""
import dataclasses
import gzip
import json
import os
import time
from typing import List
@dataclasses.dataclass
cl... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>
<|fim_prefix|>#!/usr/bin/env pytho<|fim_middle|>n<|endoftext|> | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from .machine_init import <|fim_suffix|>n__":
run()
<|fim_middle|>run
if __name__ == "__mai<|endoftext|> | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ECTORY", DefaultExecutionSettings.GH_ACTIONS_DIRECTORY
)
RUNNER_SCALING_TYPE = os.getenv(
"RUNNER_SCALING_TYPE", DefaultExecutionSettings.RUNNER_SCALING_TYPE
)
MAX_WAIT_TIME_BEFORE_SCALE_DOWN_SEC = int(
os.getenv(
"MAX_WAIT_TIME_BEFORE_SCALE_DOWN_SEC",
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>is called, decrease_capacity [{decrease_capacity}]"
)
traceback.print_stack()
if not self.instance_id:
self.update_instance_info()
assert self.instance_id
command = f"aws autoscaling terminate-instance-in-auto-scaling-group --instance-id {self.instance_i... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import json
import os
import re
import shlex
import tempfile
import time
import traceback
from typing import Dict, List, Optional, Union
from praktika._environment import _Environment
from praktika.info import Info
from praktika.result import Result
from praktika.settings import Settin... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import json
import time
import requests
try:
import jwt # From pyjwt
assert hasattr(jwt, "encode"), "Invalid jwt module, 'encode' not found"
USING_PYJWT = True
except (ImportError, AssertionError):
USING_PYJWT = False
print(
"Warning: pyjwt not availa<|fim_suffix|>"gh auth ... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import os
from concurrent.futures import ThreadPoolExecutor
from ._environment import _Environment
from .cache import Cache
from .runtime import RunConfig
from .settings import Settings
from .utils import Utils
class CacheRunnerHooks:
@classmethod
def configure(cls, workflow, skip_lookup=False)... | fim | ClickHouse/ClickHouse | python |
import dataclasses
import json
from pathlib import Path
from typing import List
from ._environment import _Environment
from .info import Info
from .parser import WorkflowConfigParser
from .result import Result, ResultInfo, _ResultS3
from .runtime import RunConfig
from .s3 import S3
from .settings import Settings
from ... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from abc import ABC, abstractmethod
from . import Workflow
class HookInterface(ABC):
@abstractmethod
def pre_run(self, _workflow, _job):
"""
runs in pre-run step
:param _workflow:
:param _job:
:return:
"""
pass
@abstractmethod
def... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from pathlib import Path
from praktika.utils import Shell
from .s3 impor<|fim_suffix|>th=compressed_file,
content_type="text/html",
content_encoding="gzip",
with_rename=True,
)
with open(page_file, "w", encoding="utf-8") as f:
f.write(html... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>e:
assert branch
ref_param = f"REF={branch}"
path = Settings.S3_REPORT_BUCKET
for bucket, endpoint in Settings.S3_BUCKET_TO_HTTP_ENDPOINT.items():
if bucket in path:
path = path.replace(bucket, endpoint)
break
res ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> tag_specs.append(
{
"ResourceId": self.name,
"ResourceType": "auto-scaling-group",
"Key": k,
"Value": v,
"PropagateAtLaunch": True,
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> * 60)
def shutdown(
self,
force: bool = True,
only: Optional[List[str]] = None,
):
"""
Terminate running EC2 instances and release Dedicated Hosts.
Args:
force: If True, forcefully terminate instance... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import json
from dataclasses import dataclass, field
from typing import Any, Dict, List
class DedicatedHost:
@dataclass
class Config:
# Logical pool name (used for tagging/identification)
name: str
region: str = ""
# Mandatory runner identification fields
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional
class EC2Instance:
@dataclass
class Config:
# Stable logical name (used for discovery via tags)
name: str
region: str = ""
# Number of similar instances to create (default=1)
... | fim | ClickHouse/ClickHouse | python |
import json
from dataclasses import asdict, dataclass, field
from typing import Any, Dict, List, Optional
class IAMInstanceProfile:
@dataclass
class Config:
name: (
str # IAM Instance Profile name (also used as a stable logical identifier)
)
region: str = "" # AWS region... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional
class ImageBuilder:
@dataclass
class Config:
name: str
region: str = ""
image_recipe_name: str = ""
image_recipe_version: str = "1.0.0"
parent_image: str = "" # AMI id... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import base64
import hashlib
import io
import json
import os
import sys
import zipfile
from dataclasses import asdict, dataclass, field
from pathlib import Path
from typing import Any, Dict, List
class Lambda:
@dataclass
class Config:
# lambda name
name: str
# path to co... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import base64
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional
class LaunchTemplate:
@dataclass
class Config:
# Launch Template name
name: str
region: str = ""
# Mandatory runner identification fields
praktika_resourc... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>s else ""
response_url = payload.get("response_url")
print("Interactivity user_id:", user_id)
print("Interactivity action_id:", action_id, "value:", value)
username = payload.get("user", {}).get("username", "") or payload.get(
"user", {}
).get("name", "")
toggle_action_i... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import json
import os
from event import EventFeed, FeedSubscription
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN", "")
# Module-level cache for github_login -> user_ids mapping
# Reused across Lambda invocations within the same container
SUBSCRIPTION_CACHE = {}
def _default_prefs() -> dict:
... | fim | ClickHouse/ClickHouse | python |
"""
Interactive user input utilities for terminal prompts and selections.
"""
import sys
class UserPrompt:
"""Provides interactive prompts for user input in terminal."""
@staticmethod
def _safe_input(prompt):
try:
return input(prompt)
except KeyboardInterrupt:
pri... | fim | ClickHouse/ClickHouse | python |
import json
import os
import re
import sys
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from pathlib import Path
from typing import TYPE_CHECKING, List, Optional
sys.path.append(os.path.dirname(__file__) + "/../")
from praktika.gh import GH
from praktika.result import Result
from ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>_name:
if isinstance(artifact_name_, str):
res.provides.append(artifact_name_)
elif isinstance(artifact_name_, Artifact.Config):
res.provides.append(artifact_name_.name)
else:
Utils.raise_with_error... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> if not _is_local_run():
print(f"Enable praktika job [{aux_job.name}] for [{workflow.name}]")
if workflow.enable_cache:
if not _is_local_run():
print(f"Add automatic digest config for [{aux_job.name}] job")
aux_job.di... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import hashlib
import json
import platform
import shlex
import sys
import traceback
from pathlib import Path
from typing import Dict
from . import Job, Workflow
from ._environment import _Environment
from .cidb import CIDB
from .digest import Digest
from .docker import Docker
from .gh ... | fim | ClickHouse/ClickHouse | python |
import dataclasses
from typing import Any, Dict, List
from . import Artifact, Workflow
from .mangle import _get_workflows
class AddonType:
PY = "py"
@dataclasses.dataclass
class WorkflowYaml:
@dataclasses.dataclass
class JobYaml:
name: str
needs: List[str]
runs_on: List[str]
... | fim | ClickHouse/ClickHouse | python |
import copy
import dataclasses
import datetime
import errno
import io
import json
import os
import random
import sys
import time
import traceback
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
from ._environment import _Envi... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import glob
import hashlib
import json
import os
import re
import shlex
import sys
import traceback
from pathlib import Path
from ._environment import _Environment
from .artifact import Artifact
from .cidb import CIDB
from .digest import Digest
from .event import EventFeed
from .gh imp... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>rtifacts"] = cache_artifacts_deserialized
for job_name, cache_jobs in cache_jobs.items():
cache_jobs_deserialized[job_name] = Cache.CacheRecord.from_dict(cache_jobs)
obj["cache_jobs"] = cache_artifacts_deserialized
obj.setdefault("submodule_cache_hash", "")
retu... | fim | ClickHouse/ClickHouse | python |
import dataclasses
import json
import mimetypes
import os
import time
from pathlib import Path
from typing import Any, Dict
from urllib.parse import quote
from ._environment import _Environment
from .settings import Settings
from .usage import StorageUsage
from .utils import Shell, Utils
try:
import boto3
fro... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import json
import os
from typing import List, Union
from .utils import Shell
class Secret:
class Type:
AWS_SSM_PARAMETER = "aws parameter"
AWS_SSM_SECRET = "aws secret"
GH_SECRET = "gh secret"
GH_VAR = "gh var"
@dataclasses.dataclass
cla... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import importlib.util
from pathlib import Path
from typing import Dict, Iterable, List, Optional
@dataclasses.dataclass
class _Settings:
######################################
# Pipeline generation settings #
######################################
MAIN_BRANCH = "... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import os
from pathlib import Path
from typing import Any, Dict, List
from .settings import Settings
from .utils import MetaClasses
@dataclasses.dataclass
class StorageUsage(MetaClasses.SerializableSingleton):
downloaded: int = 0
uploaded: int = 0
downloaded_details: Dict... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>talled
if not Shell.check("which zstd", verbose=True, strict=not no_strict):
print("ERROR: zstd is not installed. Cannot decompress artifact.")
return False
# Perform decompression
res = Shell.check(
f"zstd --decompress -... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>able_cidb=True",
workflow,
)
cls.evaluate_check(
Settings.SECRET_CI_DB_PASSWORD,
"Settings.SECRET_CI_DB_PASSWORD must be provided if workflow.enable_cidb=True",
workflow,
)
... | fim | ClickHouse/ClickHouse | python |
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Union
from . import Artifact, Job
from .docker import Docker
from .secret import Secret
from .utils import Utils
class Workflow:
class Event:
PULL_REQUEST = "pull_request"
PUSH = "push"
SCHEDULE = "schedule"... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import math
from typing import List
from . import Artifact, Job, Workflow
from .mangle import _get_workflows
from .parser import WorkflowConfigParser
from .settings import Settings
from .utils import Shell, Utils
class YamlGenerator:
class Templates:
TEMPLATE_MERGE_QUEUE_... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> AND check_start_time > now() - INTERVAL 3 MONTH
# AND NOT arrayExists(
# r -> positionCaseInsensitive(ifNull(test_context_raw, ''), r) > 0,
# reasons
# )
# LIMIT 100;
TEST_FAILURE_PATTERNS = [
# Common Functional tests failures
"Timeout",
"having stderror",
"result... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from setuptools import find_packages, setup
setup(
name="praktika",
version="0.1",
packages=find_packages(),
url="https://github.com/ClickHouse/<|fim_suffix|>ckhouse.com",
description="CI Infrastructure Toolbox",
entry_points={
"console_scripts": [
"praktika=pr... | fim | ClickHouse/ClickHouse | python |
"""
Tests for `ci.jobs.functional_tests.invert_bugfix_validation_status`.
The bugfix-validation inverter flips per-test `FAIL`/`OK` so that a regression
test for a bug, which is expected to `FAIL` on master HEAD, is reported as
"bug reproduced". When the run itself failed catastrophically (status
`ERROR`, e.g. runner ... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""
Tests for CIDB.convert_status mapping.
Adding a new Result.Status value requires updating CIDB._STATUS_TO_CIDB.
These tests verify that every status is mapped and TableRecord auto-converts.
"""
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
from ci.prakti... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""
End-to-end test for the process-group orphan cleanup in tests/clickhouse-test.
Works on both Linux and macOS. The ``pgrep()`` helper is imported directly
from ``tests/clickhouse-test`` so it uses ``ps -eo pid,ppid,pgid,command``
(POSIX) rather than the ``pgrep --pgroup`` system command (Linux-only).... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>branch): tweak is the real count.
calls = _patch(monkeypatch, pr_number=0, commit_count="106")
version = CHVersion.get_current_version_as_dict()
assert version["tweak"] == 106
assert version["string"] == "26.6.1.106"
assert len(calls) == 1
assert "git rev-list --count --first-paren... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""
End-to-end tests for the CI report pipeline.
Seeds a synthetic workspace and runs jobs to verify that the artifact
collection and encryption pipeline produces `.zst.enc` and `.rsa` files in
the result JSON.
"""
import json
import os
import shutil
import subprocess
import sys
from pathlib import Path... | fim | ClickHouse/ClickHouse | python |
"""
Tests for Event ci_status handling.
The Event.ci_status field stores Result.Status values directly.
The EventFeed sanitizer must handle both old (lowercase) and new (uppercase) formats.
"""
import os
import sys
import time
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
from ci.praktika.eve... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""
Regression tests for `ci/jobs/scripts/find_tests.py` test-name derivation.
PR #104097 changed only `tests/queries/0_stateless/02995_settings_26_4_1.tsv`
under `tests/queries/0_stateless/`. The flaky-check driver derived the test
name `02995_settings_26_4_1` by stripping the extension and asked
`clic... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ed by a blank line; got: {lines[trunc_idx + 1]!r}"
)
_assert_table_renders_at_top_level(md)
assert "|[Job 0](" in md
assert "|[Job 14](" in md
assert "|[Job 15](" not in md, "rows must be truncated to first 15"
def test_to_markdown_extras_plus_small_failure_table(monkeypatch):
"... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>hook(job.name)
if should_skip:
workflow_config.set_job_as_filtered(job.name, reason)
# Phase 2: production filtering logic
_filter_unaffected_jobs(jobs, workflow_config, changed_files)
return workflow_config.filtered_jobs
# --------------------------------------... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>in info
assert "dpkg" not in info
assert files == []
def test_parse_failure_asan_check_failed_with_stack_trace(tmp_path):
server_log = tmp_path / "clickhouse-server.err.log"
stderr_log = tmp_path / "stderr.log"
server_log.write_text(
"2026.06.09 00:00:00.000000 [ 1 ] {} <Fat... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>t(captured):
ct["print_sql_stacktraces"](args)
output = captured.getvalue()
# The function must have queried system.stack_trace and printed
# traces. We don't require a specific thread name — any non-trivial
# output confirms the round-trip succeeded.
assert "Collecting stack... | fim | ClickHouse/ClickHouse | python |
"""
Tests for XFAIL/XPASS handling in ResultTranslator.from_pytest_jsonl.
XFAIL (expected failure): test failed as expected → OK status, does not fail job.
XPASS (unexpected pass): test passed unexpectedly → XPASS status, fails job.
"""
import json
import tempfile
import os
import sys
sys.path.insert(0, os.path.joi... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>subs)
assert r.status == Result.Status.OK
def test_create_from_aggregates_fail():
subs = [Result("a", Result.Status.OK), Result("b", Result.Status.FAIL)]
r = Result.create_from(name="t", results=subs)
assert r.status == Result.Status.FAIL
def test_create_from_aggregates_error():
su... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>"]))
<|fim_prefix|>"""
Tests for `ci.jobs.stress_job.read_test_results` and
`ci.jobs.stress_job.process_results`.
Regression coverage for two flavours of "Unknown job error" in
`Stress test (*)` / `Upgrade check (*)` jobs:
- The original chronic "Cannot parse test_results.tsv
(list index out of ra... | fim | ClickHouse/ClickHouse | python |
"""
Test for Runner._parse_workflow_inputs.
Covers the parser used by the `--workflow-input` CLI flag, which accepts
comma-separated `name=value` pairs and writes them to workflow_inputs.json
for jobs to read via `Info.get_workflow_input_value`.
"""
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirnam... | fim | ClickHouse/ClickHouse | python |
from praktika import Workflow
from ci.defs.defs import BASE_BRANCH, DOCKERS, SECRETS
from ci.defs.job_configs import JobConfigs
workflow = Workflow.Config(
name="VectorSearchStress",
event=Workflow.Event.SCHEDULE,
branches=[BASE_BRANCH],
jobs=[JobConfigs.vector_search_stress_job],
artifacts=[],
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> *[job for job in JobConfigs.functional_tests_jobs if "amd_asan_ubsan" in job.name],
*[
job
for job in JobConfigs.unittest_jobs
if any(t in job.name for t in ("asan_ubsan", "tsan"))
],
*[job for job in JobConfigs.stress_test_jobs if "amd_t... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.defs.defs import RunnerLabels
from ci.praktika.secret import Secret
from praktika import Job, Workflow
workfl<|fim_suffix|>hon3 ./ci/jobs/build_praktika.py",
),
],
secrets=[
Secret.Config(
name="TWINE_PASSWORD",
type=Secret.Type.GH_SECRET,
)... | fim | ClickHouse/ClickHouse | python |
from praktika import Job, Workflow
from ci.defs.defs import BASE_BRANCH, SECRETS, RunnerLabels
# TODO: add alert on workflow failure
# TODO: make it native praktika workflow + native praktika job - generated automatically if statistics feature is enabled for any workflow
workflow = Workflow.Config(
name="Hourly... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ctConfigs.llvm_profdata_file,
ArtifactConfigs.llvm_coverage_info_file,
],
dockers=DOCKERS,
enable_dockers_manifest_merge=True,
set_latest_for_docker_merged_manifest=True,
secrets=SECRETS,
enable_job_filtering_by_changes=True,
enable_cache=True,
enable_report=True,
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import DOCKERS, SECRETS, ArtifactConfigs, ArtifactNames, JobNames
from ci.defs.job_configs import <|fim_suffix|>enable_cache=True,
enable_report=True,
enable_cidb=True,
enable_merge_ready_status=True,
enable_commit_status_on_failure=True,
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import BASE_BRANCH, DOCKERS, SECRETS, ArtifactConfigs, ArtifactNames
from ci.defs.job_configs<|fim_suffix|> *ArtifactConfigs.clickhouse_binaries,
],
enable_cache=True,
enable_report=True,
enable_cidb=True,
cron_schedules=["13 2 * *... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>],
)
WORKFLOWS = [
workflow,
]
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import BASE_BRANCH, DOCKERS, SECRETS, ArtifactConfigs, ArtifactNames
from ci.defs.job_configs import JobConfigs
# TODO: add alert on workflow failure
workflow = Workflow.Config(
name="NightlyFuzzers",
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>gs.jepsen_keeper,
],
artifacts=[
*ArtifactConfigs.clickhouse_binaries,
],
dockers=DOCKERS,
secrets=SECRETS,
enable_cache=True,
enable_report=True,
enable_cidb=True,
cron_schedules=["13 4 * * *"],
pre_hooks=["python3 ./ci/jobs/scripts/workflow_hooks/store_dat... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>clickhouse_binaries,
],
dockers=DOCKERS,
secrets=SECRETS,
enable_cache=True,
enable_report=True,
enable_cidb=True,
cron_schedules=["17 1 * * 0,2,4,6"],
pre_hooks=["python3 ./ci/jobs/scripts/workflow_hooks/store_data.py"],
)
WORKFLOWS = [workflow]
<|fim_prefix|>from praktik... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Job, Workflow
from ci.defs.defs import BASE_BRANCH, DOCKERS, SECRETS, ArtifactConfigs, ArtifactNames, BuildTypes
from ci.defs.job_configs import JobConfigs
binary_build_job = Job.Config.get_job(
JobConfigs.build_jobs, f"Build ({BuildTypes.ARM_BINARY})"
).set_provides(ArtifactNam... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>DULE,
branches=[BASE_BRANCH],
jobs=[
Job.Config(
name="Collect Statistics",
command="python3 ./ci/jobs/collect_statistics.py",
runs_on=RunnerLabels.STYLE_CHECK_ARM,
)
],
secrets=SECRETS,
enable_report=True,
enable_cidb=False,
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> workflow,
]
<|fim_prefix|>from praktika import Job, Workflow
from ci.defs.defs import BASE_BRANCH, SECRETS, RunnerLabels
workflow = Workflow.Config(
name="NightlyUpload",
event=Workflow.Event.SCHEDULE,
branches=[BASE_BRANCH],
jobs=[
Job.Config(
name="Upload clickhou... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import BASE_BRANCH, DOCKERS, SECRETS, ArtifactConfigs<|fim_suffix|>lickhouse_pgo_profile_amd,
ArtifactConfigs.clickhouse_pgo_profile_arm,
ArtifactConfigs.clickhouse_bolt_profile_amd,
ArtifactConfigs.clickhouse_bolt_profile_arm,
]... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import BASE_BRANCH, DOCKERS, SECRETS, ArtifactConfigs
from ci.defs.job_configs import JobConfigs
workflow = Workflow.Config(
<|fim_suffix|>actConfigs.toolchain_pgo_bolt_amd,
ArtifactConfigs.toolchain_pgo_bolt_arm,
],
enable_cache=True,
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import (
BASE_BRANCH,
DOCKERS,
SECRETS,
ArtifactConfigs,
ArtifactNames,
JobNames,
)
from ci.defs.job_configs import JobConfigs
from ci.jobs.scripts.workflow_hooks.filter_job import should_skip_job
from ci.jobs.scripts.workflow_hooks.... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import Workflow
from ci.defs.defs import BINARIES_WITH_LONG_RETENTION, DOCKERS, SECRETS, ArtifactConfigs
from ci.defs.job_configs import JobConfigs
from ci.jobs.scripts.workflow_hooks.filter_job import should_skip_job
builds_for_release_branch = [
job
for job in JobConfigs.build_jo... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>
// Generated from PromQLLexer.g4 by ANTLR 4.13.2
#include "PromQLLexer.h"
using namespace antlr4;
using namespace antlr4_grammars;
using namespace antlr4;
namespace {
struct PromQLLexerStaticData final {
PromQLLexerStaticData(std::vector<std::string> ruleNames,
std::v... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>o implement the lexer is lazily initialized during the first
// call to the constructor. You can call this function if you wish to initialize the static state
// ahead of time.
static void initialize();
private:
// Individual action functions triggered by action() above.
// Individual semanti... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>erride;
};
RangeSelectorContext* rangeSelector();
class SelectorWithOffsetContext : public antlr4::ParserRuleContext {
public:
SelectorWithOffsetContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
InstantSelectorContext... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>
// Generated from P<|fim_suffix|>4 by ANTLR 4.13.2
#include "PromQLParserBaseListener.h"
using namespace antlr4_grammars;
<|fim_middle|>romQLParser.g<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>
// Generated from PromQLParser.g4 by ANTLR 4.13.2
#pragma once
#include "antlr4-runtime.h"
#include "PromQLParserListener.h"
namespace antlr4_grammars {
/**
* This class provides an empty implementation of PromQLParserListener,
* which can be extended to crea<|fim_suffix|>de { }
virtual void ex... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>
// Generated from PromQLParser.g4 by ANTLR 4.13.2
#include<|fim_suffix|>ng namespace antlr4_grammars;
<|fim_middle|> "PromQLParserBaseVisitor.h"
usi<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>override {
return visitChildren(ctx);
}
virtual std::any visitLabelMatcher(PromQLParser::LabelMatcherContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitLabelMatcherOperator(PromQLParser::LabelMatcherOperatorContext *ctx) override {
return visitChildren(ctx);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>antlr4_grammars;
<|fim_prefix|>
// Generated from PromQLParser.g4 by ANTLR 4.13.2
#include "PromQLParserListener.h"
using namespace<|fim_middle|> <|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>(PromQLParser::On_Context *ctx) = 0;
virtual void enterIgnoring(PromQLParser::IgnoringContext *ctx) = 0;
virtual void exitIgnoring(PromQLParser::IgnoringContext *ctx) = 0;
virtual void enterGroupLeft(PromQLParser::GroupLeftContext *ctx) = 0;
virtual void exitGroupLeft(PromQLParser::GroupLeftCont... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>
// Genera<|fim_suffix|>romQLParserVisitor.h"
using namespace antlr4_grammars;
<|fim_middle|>ted from PromQLParser.g4 by ANTLR 4.13.2
#include "P<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>
// Generated from PromQLParser.g4 by ANTLR 4.13.2
#pragma once
#include "antlr4-runtime.h"
#include "PromQLParser.h"
namespace antlr4_grammars {
/**
* This class defines an abstract visitor for a parse tree
* produced by PromQLParser.
*/
class PromQLParserVisitor : public antlr4::tree::Abstract... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ITH_SNAPPY */
/* #undef ARROW_WITH_UTF8PROC */
/* #undef ARROW_WITH_ZLIB */
/* #undef ARROW_WITH_ZSTD */
/* #undef PARQUET_REQUIRE_ENCRYPTION */
<|fim_prefix|>// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with t... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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 Lice... | fim | ClickHouse/ClickHouse | c |
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ION "200.0.0"
// define the parquet created by version
#define CREATED_BY_VERSION "parquet-cpp version 1.5.1-SNAPSHOT"
#endif // PARQUET_VERSION_H
<|fim_prefix|>// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed w... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>x.h>
Delete me.
*/
<|fim_prefix|>/*
Temporary hack caused by 17355425 - THRIFT-4735: Remov<|fim_middle|>e Qt4 build support
Fixes
../contrib/arrow-cmake/cpp/src/parquet/parquet_types.h:18:10: fatal error: thrift/stdcxx.h: No such file or directory
#include <thrift/stdcx<|endoftext|> | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.