pyk.utils module

class BugReport(bug_report: Path)

Bases: object

add_command(args: Iterable[str]) → None

add_file(finput: Path, arcname: Path) → None

add_file_contents(input: str, arcname: Path) → None

add_request(req_name: str) → None

class Chainable(f: Callable[[P], R])

Bases: Generic[P, R]

class FrozenDict(*args: Any, **kwargs: Any)

Bases: Mapping[K, V]

final class POSet(relation: 'Iterable[tuple[H, H]]')

Bases: Generic[H]

image: FrozenDict[H, frozenset[H]]

abs_or_rel_to(path: Path, base: Path) → Path

add_indent(indent: str, lines: Iterable[str]) → list[str]

case(cases: Iterable[tuple[Callable[[P], bool], Callable[[P], R]]], default: Callable[[P], R] | None = None) → Callable[[P], R]

check_absolute_path(path: Path) → None

check_dir_path(path: Path) → None

check_file_path(path: Path) → None

check_relative_path(path: Path) → None

check_type(x: Any, typ: type[T]) → T

compare_short_hashes(lhs: str, rhs: str) → bool

deconstruct_short_hash(h: str) → tuple[str, str]

ensure_dir_path(path: str | Path) → Path

exit_with_process_error(err: CalledProcessError) → None

filter_none(mapping: Mapping[K, V]) → dict[K, V]

find_common_items(l1: Iterable[T], l2: Iterable[T]) → tuple[list[T], list[T], list[T]]

gen_file_timestamp(comment: str = '//') → str

hash_file(file: Path, chunk_num_blocks: int = 128) → str

hash_str(x: object) → str

intersperse(iterable: Iterable[T], delimiter: T) → Iterator[T]

is_hash(x: Any) → bool

is_hexstring(x: str) → bool

maybe(f: Callable[[P], R]) → Callable[[P | None], R | None]

merge_with(f: Callable[[V, V], V], d1: Mapping[K, V], d2: Mapping[K, V]) → dict[K, V]

none(x: Any) → None

nonempty_str(x: Any) → str

not_none(x: T | None) → T

partition(iterable: Iterable[T], pred: Callable[[T, T], bool]) → list[list[T]]

Partition the iterable into sublists based on the given predicate.

predicate pred(_, _) should satisfy: - pred(x, x) - if pred(x, y) and pred(y, z) then pred(x, z); - if pred(x, y) then pred(y, x);

raised(f: Callable, *args: Any, **kwargs: Any) → BaseException | None

repeat_last(iterable: Iterable[T]) → Iterator[T]

run_process(args: str | Iterable[str], *, check: bool = True, input: str | None = None, pipe_stdout: bool = True, pipe_stderr: bool = False, cwd: str | Path | None = None, env: Mapping[str, str] | None = None, logger: Logger | None = None, exec_process: bool = False) → CompletedProcess

run_process_2(args: str | Iterable[str], *, input: str | None = None, write_stdout: bool = False, write_stderr: bool = False, cwd: str | Path | None = None, env: Mapping[str, str] | None = None, logger: Logger | None = None, loglevel: int | None = None, check: bool = True) → CompletedProcess

shorten_hash(h: str, left_chars: int = 6, right_chars: int = 6) → str

shorten_hashes(value: Any, left_chars: int = 6, right_chars: int = 6) → Any

single(iterable: Iterable[T]) → T

some(iterable: Iterable[T]) → T | None

tuple_of() → Callable[[tuple[()]], tuple[()]]

tuple_of(f1: Callable[[P1], R1], /) → Callable[[tuple[P1]], tuple[R1]]

tuple_of(f1: Callable[[P1], R1], f2: Callable[[P2], R2], /) → Callable[[tuple[P1, P2]], tuple[R1, R2]]

tuple_of(f1: Callable[[P1], R1], f2: Callable[[P2], R2], f3: Callable[[P3], R3], /) → Callable[[tuple[P1, P2, P3]], tuple[R1, R2, R3]]

tuple_of(f1: Callable[[P1], R1], f2: Callable[[P2], R2], f3: Callable[[P3], R3], f4: Callable[[P4], R4], /) → Callable[[tuple[P1, P2, P3, P4]], tuple[R1, R2, R3, R4]]

unique(iterable: Iterable[H]) → Iterator[H]