----------------------------------------------------------------------
This is the API documentation for the cc_transcript library.
----------------------------------------------------------------------


## Classes

Core classes


TranscriptDiscovery()

Locates Claude Code transcript files on disk.

Transcripts live as ``*.jsonl`` files under
:data:`CLAUDE_PROJECTS_DIR` (``~/.claude/projects``), one directory per
project plus ``subagents/`` sidechain files.

TranscriptParser()

The public facade over the active parsing backend.

Resolves a :class:`Backend` once and streams parsed transcripts through it.

FileStateStore(conn: 'aiosqlite.Connection') -> 'None'

Tracks which transcript files have been ingested, keyed by mtime.

Backed by a single async SQLite (``aiosqlite``) database with WAL journaling
and a task lock, so it is safe to share one store across concurrent tasks.
Consumers compose their own writes alongside :meth:`record_file` inside
:meth:`transaction` to keep ingestion state and derived records atomic.

Example:
    >>> store = await FileStateStore.open(Path("state.db"), extra_schema=MY_SCHEMA)
    >>> async with store.transaction() as conn:
    ...     await conn.execute("INSERT INTO my_table VALUES (?)", (value,))
    ...     await store.record_file(str(path), mtime)

PythonBackend()

The reference pure-Python parsing backend.

Parses each file off the event loop via :mod:`anyio` worker threads,
keeping at most ``prefetch`` files in flight at once.


## FileStateStore Methods

Methods for the FileStateStore class


open(path: 'Path', *, extra_schema: 'str' = '') -> 'Self'

Opens (creating if needed) the store at ``path``.

Args:
    path: The database file path; its parent is created if absent.
    extra_schema: Additional DDL to execute after the file schema,
        e.g. consumer tables that reference ``files(path)``.

Returns:
    The opened store.

close(self) -> 'None'

Closes the underlying connection.

__aenter__(self) -> 'Self'

__aexit__(self, exc_type: 'type[BaseException] | None', exc: 'BaseException | None', tb: 'TracebackType | None') -> 'None'

transaction(self) -> 'AsyncIterator[aiosqlite.Connection]'

Yields the locked connection inside a single committed transaction.

Use this to compose consumer writes with :meth:`record_file` so they
commit or roll back together. :meth:`record_file` called within the
block joins this transaction instead of opening its own.

Yields:
    The store's connection, held under the store lock.

file_mtimes(self) -> 'dict[str, float]'

Returns the recorded ``path`` to ``mtime`` map.

record_file(self, path: 'str', mtime: 'float') -> 'None'

Upserts the recorded mtime for ``path``.

Call inside :meth:`transaction` to commit alongside consumer writes;
called on its own it commits immediately.

upsert_file(self, path: 'str', mtime: 'float') -> 'None'


## Dataclasses

Data-holding classes


ParsedTranscript(path: 'Path', mtime: 'float', events: 'tuple[TranscriptEvent, ...]') -> None

The parsed events of a single transcript file.

Attributes:
    path: The transcript's path on disk.
    mtime: The transcript's modification time when parsed.
    events: The parsed events, in file order.

FilterConfig(keep_types: 'tuple[type[TranscriptEvent], ...] | None' = None, drop_sidechain: 'bool' = False, drop_synthetic: 'bool' = False, drop_compacted: 'bool' = False, drop_empty: 'bool' = False, drop_ephemeral_entrypoints: 'frozenset[str]' = frozenset(), junk_pattern: 're.Pattern[str] | None' = None) -> None

Opt-in, consumer-side filtering of a transcript event stream.

A back-compatible flag-bag that lowers to a :class:`~cc_transcript.FilterSpec`
via :meth:`to_spec`. Every flag defaults off, so a bare ``FilterConfig()``
passes events through untouched.

Attributes:
    keep_types: When set, drop every event not an instance of one of these
        types; a type-level allowlist applied before the per-event rules.
    drop_sidechain: Drop events whose envelope marks a sidechain.
    drop_synthetic: Drop assistant events with model ``<synthetic>``.
    drop_compacted: Drop compaction-summary and transcript-only entries
        (envelope flags on :class:`~cc_transcript.models.EntryMeta`).
    drop_empty: Drop user events with no text and assistant events with
        neither text nor a tool use.
    drop_ephemeral_entrypoints: Drop events from these entrypoints.
    junk_pattern: Drop user events whose text matches this pattern.

FilterSpec(clauses: 'tuple[Clause, ...]') -> None

An ordered list of :class:`Clause` rules applied to an event stream.

AssistantEvent(meta: 'EntryMeta', model: 'str', text: 'str', blocks: 'tuple[ContentBlock, ...]', stop_reason: 'str | None') -> None

An assistant turn.

Attributes:
    meta: The entry envelope metadata.
    model: The model that produced the turn, e.g. ``<synthetic>``.
    text: The joined text of the turn.
    blocks: The parsed content blocks, including thinking and tool uses.
    stop_reason: The model's stop reason, when present.

EntryMeta(uuid: 'EntryUuid', parent_uuid: 'EntryUuid | None', session_id: 'SessionId', timestamp: 'datetime', cwd: 'str | None', git_branch: 'str | None', cc_version: 'CcVersion | None', is_sidechain: 'bool', is_meta: 'bool', entrypoint: 'str | None', is_compact_summary: 'bool', is_visible_in_transcript_only: 'bool') -> None

Envelope metadata shared by the conversational transcript events.

Attributes:
    uuid: The entry's unique identifier.
    parent_uuid: The parent entry's id, or None for roots.
    session_id: The session this entry belongs to.
    timestamp: The entry's timezone-aware timestamp.
    cwd: The working directory recorded for the entry.
    git_branch: The git branch recorded for the entry.
    cc_version: The Claude Code version that wrote the entry.
    is_sidechain: Whether the entry belongs to a subagent sidechain.
    is_meta: Whether the entry is a meta entry injected by the client.
    entrypoint: The entrypoint that produced the entry, e.g. ``cli``.
    is_compact_summary: Whether the entry is a compaction summary.
    is_visible_in_transcript_only: Whether the entry is transcript-only.

ModeEvent(session_id: 'SessionId', channel: "Literal['mode', 'permission-mode']", value: 'str') -> None

A mode or permission-mode change marker.

These entries carry only a session id on disk — no uuid, timestamp, or
other envelope fields — so they hold a :attr:`session_id` directly rather
than an :class:`EntryMeta`.

Attributes:
    session_id: The session whose mode changed.
    channel: Which mode channel changed.
    value: The new mode value.

OtherEvent(type: 'str', raw: 'Mapping[str, Any]') -> None

Any recognized entry without a guaranteed conversational envelope.

Covers attachment, ai-title, last-prompt, summary, queue-operation,
file-history-snapshot, and similar entry types whose shape carries no
:class:`EntryMeta`.

Attributes:
    type: The entry's ``type`` field.
    raw: The entry's full decoded payload.

SystemEvent(meta: 'EntryMeta', subtype: 'str', content: 'str | None') -> None

A system entry, such as a hook summary or notice.

Attributes:
    meta: The entry envelope metadata.
    subtype: The system entry's subtype.
    content: The entry's text content, when present.

TextBlock(text: 'str') -> None

A text content block from a user or assistant message.

Attributes:
    text: The block's literal text.

ThinkingBlock(thinking: 'str') -> None

An extended-thinking content block emitted by the assistant.

Attributes:
    thinking: The model's thinking text.

ToolResultBlock(tool_use_id: 'ToolUseId', content: 'str', is_error: 'bool', is_async: 'bool' = False) -> None

The result of a tool invocation, delivered in a user turn.

Attributes:
    tool_use_id: The id of the originating tool-use block.
    content: The result text, flattened from string or block content.
    is_error: Whether the tool reported a failure.
    is_async: Whether the originating tool ran asynchronously, read from the
        entry-level ``toolUseResult.isAsync`` marker.

ToolUseBlock(id: 'ToolUseId', name: 'str', input: 'Mapping[str, Any]') -> None

An assistant request to invoke a tool.

Attributes:
    id: The tool-use identifier referenced by the matching result.
    name: The tool's name.
    input: The tool's input arguments, preserved verbatim.

UserEvent(meta: 'EntryMeta', text: 'str', blocks: 'tuple[ContentBlock, ...]', interrupted: 'bool') -> None

A user turn.

Attributes:
    meta: The entry envelope metadata.
    text: The joined text of the turn.
    blocks: The parsed content blocks, including tool results.
    interrupted: Whether the turn is a user interruption.

KindIs(kinds: 'frozenset[EventKind]') -> None

Matches events whose kind is in ``kinds``.

MetaFlag(flag: 'MetaFlagName') -> None

Matches when an :class:`~cc_transcript.models.EntryMeta` boolean is set.

EntrypointIn(entrypoints: 'frozenset[str]') -> None

Matches when ``meta.entrypoint`` is in ``entrypoints``.

ModelIs(models: 'frozenset[str]') -> None

Matches assistant events whose ``model`` is in ``models``.

TextEmpty(consider_tool_use: 'bool' = True) -> None

Matches events with blank text.

Attributes:
    consider_tool_use: When true, an assistant event with a tool-use block
        is not considered empty even with blank text.

TextMatchesAny(groups: 'tuple[tuple[str, str], ...]', ignore_case: 'bool' = True) -> None

Matches when the event text matches any of the named regex ``groups``.

Attributes:
    groups: Ordered ``(name, pattern)`` pairs; names label composable,
        individually includable building blocks.
    ignore_case: Whether to compile case-insensitively.

TextInSet(phrases: 'frozenset[str]', strip_trailing: 'str' = '.!?…,;:') -> None

Matches when the normalized event text is in ``phrases``.

Normalization mirrors a bare-message check: strip, drop trailing
punctuation, strip again, lowercase.

WordCountAtMost(n: 'int') -> None

Matches when the event text has at most ``n`` whitespace-split words.

Clause(predicate: 'Predicate', action: 'Action' = <Action.DROP: 'drop'>, applies_to: 'frozenset[EventKind]' = frozenset(), negate: 'bool' = False, label: 'str | None' = None) -> None

One filter rule: when ``predicate`` holds, apply ``action``.

Attributes:
    predicate: The condition tested against an event.
    action: ``DROP`` removes the event (first drop wins, stops evaluation);
        ``TAG`` records ``label`` on a surviving event and continues.
    applies_to: When non-empty, the clause is only evaluated for these kinds.
    negate: Invert the predicate match.
    label: The label recorded by a ``TAG`` clause.

Clause(predicate: 'Predicate', action: 'Action' = <Action.DROP: 'drop'>, applies_to: 'frozenset[EventKind]' = frozenset(), negate: 'bool' = False, label: 'str | None' = None) -> None

One filter rule: when ``predicate`` holds, apply ``action``.

Attributes:
    predicate: The condition tested against an event.
    action: ``DROP`` removes the event (first drop wins, stops evaluation);
        ``TAG`` records ``label`` on a surviving event and continues.
    applies_to: When non-empty, the clause is only evaluated for these kinds.
    negate: Invert the predicate match.
    label: The label recorded by a ``TAG`` clause.

EntrypointIn(entrypoints: 'frozenset[str]') -> None

Matches when ``meta.entrypoint`` is in ``entrypoints``.

KindIs(kinds: 'frozenset[EventKind]') -> None

Matches events whose kind is in ``kinds``.

MetaFlag(flag: 'MetaFlagName') -> None

Matches when an :class:`~cc_transcript.models.EntryMeta` boolean is set.

ModelIs(models: 'frozenset[str]') -> None

Matches assistant events whose ``model`` is in ``models``.

TextEmpty(consider_tool_use: 'bool' = True) -> None

Matches events with blank text.

Attributes:
    consider_tool_use: When true, an assistant event with a tool-use block
        is not considered empty even with blank text.

TextInSet(phrases: 'frozenset[str]', strip_trailing: 'str' = '.!?…,;:') -> None

Matches when the normalized event text is in ``phrases``.

Normalization mirrors a bare-message check: strip, drop trailing
punctuation, strip again, lowercase.

TextMatchesAny(groups: 'tuple[tuple[str, str], ...]', ignore_case: 'bool' = True) -> None

Matches when the event text matches any of the named regex ``groups``.

Attributes:
    groups: Ordered ``(name, pattern)`` pairs; names label composable,
        individually includable building blocks.
    ignore_case: Whether to compile case-insensitively.

WordCountAtMost(n: 'int') -> None

Matches when the event text has at most ``n`` whitespace-split words.

Clause(predicate: 'Predicate', action: 'Action' = <Action.DROP: 'drop'>, applies_to: 'frozenset[EventKind]' = frozenset(), negate: 'bool' = False, label: 'str | None' = None) -> None

One filter rule: when ``predicate`` holds, apply ``action``.

Attributes:
    predicate: The condition tested against an event.
    action: ``DROP`` removes the event (first drop wins, stops evaluation);
        ``TAG`` records ``label`` on a surviving event and continues.
    applies_to: When non-empty, the clause is only evaluated for these kinds.
    negate: Invert the predicate match.
    label: The label recorded by a ``TAG`` clause.

EntrypointIn(entrypoints: 'frozenset[str]') -> None

Matches when ``meta.entrypoint`` is in ``entrypoints``.

KindIs(kinds: 'frozenset[EventKind]') -> None

Matches events whose kind is in ``kinds``.

MetaFlag(flag: 'MetaFlagName') -> None

Matches when an :class:`~cc_transcript.models.EntryMeta` boolean is set.

ModelIs(models: 'frozenset[str]') -> None

Matches assistant events whose ``model`` is in ``models``.

TextEmpty(consider_tool_use: 'bool' = True) -> None

Matches events with blank text.

Attributes:
    consider_tool_use: When true, an assistant event with a tool-use block
        is not considered empty even with blank text.

TextMatchesAny(groups: 'tuple[tuple[str, str], ...]', ignore_case: 'bool' = True) -> None

Matches when the event text matches any of the named regex ``groups``.

Attributes:
    groups: Ordered ``(name, pattern)`` pairs; names label composable,
        individually includable building blocks.
    ignore_case: Whether to compile case-insensitively.


## Protocols

Structural typing protocols


Backend(*args, **kwargs)

A transcript-parsing backend.

Implementations parse a batch of transcript paths into
:class:`ParsedTranscript` objects, streaming results as they finish.


## Enumerations

Enum types


Action(*values)

What a matching :class:`Clause` does to an event.


## Named Tuples

NamedTuple types


AssistantMessage(content: ForwardRef('str'), timestamp: ForwardRef('datetime'), session_id: ForwardRef('SessionId'), uuid: ForwardRef('str'), tool_calls: ForwardRef('tuple[ToolCall, ...]'), thinking_chars: ForwardRef('int'), claude_model: ForwardRef('str'), role: ForwardRef("Literal['assistant']") = 'assistant')

An assistant turn distilled for analysis: its text, tool calls, and responding model.

ToolCall(name: ForwardRef('str'), file_path: ForwardRef('str | None') = None)

A single tool invocation within a message: the tool ``name`` and optional target file path.

UserMessage(content: ForwardRef('str'), timestamp: ForwardRef('datetime'), session_id: ForwardRef('SessionId'), uuid: ForwardRef('str'), tool_calls: ForwardRef('tuple[ToolCall, ...]'), thinking_chars: ForwardRef('int'), cc_version: ForwardRef('str'), role: ForwardRef("Literal['user']") = 'user')

A user turn distilled for analysis: its text, tool calls, and authoring metadata.


## Functions

Public functions


build_spec(*fragments: 'Clause | tuple[Clause, ...]') -> 'FilterSpec'

Flattens ``Clause`` / ``tuple[Clause, ...]`` fragments into a :class:`FilterSpec`.

drop_compacted() -> 'tuple[Clause, Clause]'

Drops compaction-summary and transcript-only entries.

drop_empty(*, only_from: 'frozenset[EventKind]') -> 'Clause'

Drops blank events of one kind.

Assistant turns with a tool-use block are not blank; user turns have no such
rescue, so ``consider_tool_use`` is keyed off ``only_from``. Defined for the
single-kind ``USERS`` / ``ASSISTANTS`` sets.

drop_entrypoints(entrypoints: 'Iterable[str]') -> 'Clause'

Drops events whose ``meta.entrypoint`` is in ``entrypoints``.

drop_junk(*categories: 'str', only_from: 'frozenset[EventKind]' = frozenset({'user'})) -> 'Clause'

Drops events matching any group in the named :data:`JUNK_CATEGORIES`.

drop_meta_flag(flag: 'MetaFlagName', *, only_from: 'frozenset[EventKind]' = frozenset()) -> 'Clause'

Drops events whose ``EntryMeta`` boolean ``flag`` is set.

drop_phrases(phrases: 'frozenset[str]', *, only_from: 'frozenset[EventKind]' = frozenset({'user'})) -> 'Clause'

Drops events whose normalized text is one of ``phrases``.

drop_short(max_words: 'int', *, only_from: 'frozenset[EventKind]' = frozenset({'user'})) -> 'Clause'

Drops events with at most ``max_words`` whitespace-split words.

drop_sidechain(*, except_assistants: 'bool' = False) -> 'Clause'

Drops sidechain events; ``except_assistants`` keeps assistant sidechains.

drop_synthetic() -> 'Clause'

Drops assistant events with the ``<synthetic>`` model.

keep_only(*kinds: 'EventKind') -> 'Clause'

Drops every event whose kind is not in ``kinds``.

apply_filters(events: 'Iterable[TranscriptEvent]', config: 'FilterConfig') -> 'Iterator[TranscriptEvent]'

Yields the events that survive ``config``.

Args:
    events: The events to filter.
    config: The filtering rules to apply.

Yields:
    The events for which every enabled rule holds.

annotate_spec(events: 'Iterable[TranscriptEvent]', spec: 'FilterSpec') -> 'Iterator[tuple[TranscriptEvent, tuple[str, ...]]]'

Yields ``(event, labels)`` for events surviving ``spec``, with TAG labels.

apply_spec(events: 'Iterable[TranscriptEvent]', spec: 'FilterSpec') -> 'Iterator[TranscriptEvent]'

Yields the events that survive every ``DROP`` clause of ``spec``.

keep(event: 'TranscriptEvent', spec: 'FilterSpec') -> 'bool'

Returns whether ``event`` survives every ``DROP`` clause of ``spec``.

labels_for(event: 'TranscriptEvent', spec: 'FilterSpec') -> 'tuple[str, ...]'

Returns the TAG labels ``spec`` records for ``event``, in clause order.

parse_event(data: 'Mapping[str, Any]') -> 'TranscriptEvent | None'

parse_events_from_bytes(raw: 'bytes') -> 'list[TranscriptEvent]'

parse_meta(data: 'Mapping[str, Any]') -> 'EntryMeta'

flatten_result_content(content: 'str | list[dict[str, Any]]') -> 'str'

parse_user_blocks(content: 'str | list[dict[str, Any]]', *, is_async: 'bool' = False) -> 'tuple[str, tuple[ContentBlock, ...]]'

parse_assistant_blocks(content: 'list[dict[str, Any]]') -> 'tuple[str, tuple[ContentBlock, ...]]'

parse_assistant_block(block: 'dict[str, Any]') -> 'ContentBlock'

decode_line(line: 'bytes') -> 'TranscriptEvent | None'

parse_one(path: 'Path', mtime: 'float') -> 'ParsedTranscript'

parse_one_filtered(path: 'Path', mtime: 'float', spec: 'FilterSpec | None') -> 'ParsedTranscript'

load_rust_backend() -> 'Backend | None'

compile_groups(groups: 'tuple[tuple[str, str], ...]', ignore_case: 'bool') -> 're.Pattern[str]'

event_kind(event: 'TranscriptEvent') -> 'EventKind'

event_text(event: 'TranscriptEvent') -> 'str'

event_meta(event: 'TranscriptEvent') -> 'EntryMeta | None'

normalize_bare(text: 'str', strip_trailing: 'str' = '.!?…,;:') -> 'str'

predicate_matches(predicate: 'Predicate', event: 'TranscriptEvent', kind: 'EventKind') -> 'bool'

meta_flag(meta: 'EntryMeta', flag: 'MetaFlagName') -> 'bool'

clause_matches(clause: 'Clause', event: 'TranscriptEvent', kind: 'EventKind') -> 'bool'

is_portable(spec: 'FilterSpec') -> 'bool'

Returns whether every clause is executable by the Rust interpreter.

A spec is portable when each :class:`TextMatchesAny` uses only group names
proven to match identically under the Rust ``regex`` crate; non-portable
specs fall back to the Python interpreter.

clause_portable(clause: 'Clause') -> 'bool'

spec_to_json(spec: 'FilterSpec') -> 'str'

Serializes ``spec`` to the JSON contract consumed by the Rust backend.

clause_to_dict(clause: 'Clause') -> 'dict[str, Any]'

predicate_to_dict(predicate: 'Predicate') -> 'dict[str, Any]'

compile_groups(groups: 'tuple[tuple[str, str], ...]', ignore_case: 'bool') -> 're.Pattern[str]'


## Async Functions

Asynchronous functions


parse_events_async(path: 'Path') -> 'list[TranscriptEvent]'


## Constants

Module-level constants and data


CcVersion(x, /)

NewType creates simple unique types with almost zero runtime overhead.

NewType(name, tp) is considered a subtype of tp
by static type checkers. At runtime, NewType(name, tp) returns
a dummy callable that simply returns its argument.

Usage::

    UserId = NewType('UserId', int)

    def name_by_id(user_id: UserId) -> str:
        ...

    UserId('user')          # Fails type check

    name_by_id(42)          # Fails type check
    name_by_id(UserId(42))  # OK

    num = UserId(5) + 1     # type: int

EntryUuid(x, /)

NewType creates simple unique types with almost zero runtime overhead.

NewType(name, tp) is considered a subtype of tp
by static type checkers. At runtime, NewType(name, tp) returns
a dummy callable that simply returns its argument.

Usage::

    UserId = NewType('UserId', int)

    def name_by_id(user_id: UserId) -> str:
        ...

    UserId('user')          # Fails type check

    name_by_id(42)          # Fails type check
    name_by_id(UserId(42))  # OK

    num = UserId(5) + 1     # type: int

SessionId(x, /)

NewType creates simple unique types with almost zero runtime overhead.

NewType(name, tp) is considered a subtype of tp
by static type checkers. At runtime, NewType(name, tp) returns
a dummy callable that simply returns its argument.

Usage::

    UserId = NewType('UserId', int)

    def name_by_id(user_id: UserId) -> str:
        ...

    UserId('user')          # Fails type check

    name_by_id(42)          # Fails type check
    name_by_id(UserId(42))  # OK

    num = UserId(5) + 1     # type: int

ToolUseId(x, /)

NewType creates simple unique types with almost zero runtime overhead.

NewType(name, tp) is considered a subtype of tp
by static type checkers. At runtime, NewType(name, tp) returns
a dummy callable that simply returns its argument.

Usage::

    UserId = NewType('UserId', int)

    def name_by_id(user_id: UserId) -> str:
        ...

    UserId('user')          # Fails type check

    name_by_id(42)          # Fails type check
    name_by_id(UserId(42))  # OK

    num = UserId(5) + 1     # type: int

parser.ContentBlock

Represent a PEP 604 union type

E.g. for int | str

parser.TranscriptEvent

Represent a PEP 604 union type

E.g. for int | str

parser.INTERRUPT_MARKER

str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.

parse_event(data: 'Mapping[str, Any]') -> 'TranscriptEvent | None'

models.ContentBlock

Represent a PEP 604 union type

E.g. for int | str

models.TranscriptEvent

Represent a PEP 604 union type

E.g. for int | str

Literal(*args, **kwargs)

Literal(*args, **kwargs)

filterspec.TRAILING_PUNCT

str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.

filterspec.STRUCTURAL_TAG_GROUP

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.STRUCTURAL_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.AGENT_INJECTION_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.INTERRUPT_MARKER_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.STOP_HOOK_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.CONTINUATION_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.COMMAND_ECHO_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.JUNK_CATEGORIES

dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
    d = {}
    for k, v in iterable:
        d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
    in the keyword argument list.  For example:  dict(one=1, two=2)

filterspec.STRUCTURAL_NOISE_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.SENTIMENT_JUNK_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.FRUSTRATION_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.MILD_IMPATIENCE_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filterspec.PORTABLE_GROUP_NAMES

Build an immutable unordered collection of unique elements.

filterspec.RESUME_PHRASE_SET

Build an immutable unordered collection of unique elements.

filterspec.TRIVIAL_ACK_SET

Build an immutable unordered collection of unique elements.

filterspec.SHORT_MESSAGE_MAX_WORDS

int([x]) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments
are given.  If x is a number, return x.__int__().  For floating-point
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base.  The literal can be preceded by '+' or '-' and be surrounded
by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4

filterspec.CONVERSATIONAL

Build an immutable unordered collection of unique elements.

filterspec.USERS

Build an immutable unordered collection of unique elements.

filterspec.ASSISTANTS

Build an immutable unordered collection of unique elements.

filterspec.Predicate

Represent a PEP 604 union type

E.g. for int | str

filterspec.STRUCTURAL_NOISE_RE

Compiled regular expression object.

filterspec.INTERRUPT_MARKER_RE

Compiled regular expression object.

filterspec.STOP_HOOK_RE

Compiled regular expression object.

builders.ASSISTANTS

Build an immutable unordered collection of unique elements.

builders.JUNK_CATEGORIES

dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
    d = {}
    for k, v in iterable:
        d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
    in the keyword argument list.  For example:  dict(one=1, two=2)

builders.USERS

Build an immutable unordered collection of unique elements.

builders.NOISE_SPEC

An ordered list of :class:`Clause` rules applied to an event stream.

store.FILE_SCHEMA

str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.

discovery.CLAUDE_PROJECTS_DIR

Path subclass for non-Windows systems.

On a POSIX system, instantiating a Path should return this object.

filters.ASSISTANTS

Build an immutable unordered collection of unique elements.

filters.SENTIMENT_JUNK_GROUPS

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

filters.USERS

Build an immutable unordered collection of unique elements.

filters.JUNK_USER_MESSAGE_RE

Compiled regular expression object.

filters.KIND_BY_TYPE

dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
    d = {}
    for k, v in iterable:
        d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
    in the keyword argument list.  For example:  dict(one=1, two=2)

messages.BaseMessage

Represent a PEP 604 union type

E.g. for int | str

messages.TranscriptMessage

Represent a PEP 604 union type

E.g. for int | str


## Other

Additional exports