SYMBOL INDEX (422 symbols across 39 files)

FILE: docusaurus/src/components/BrowserWindow/index.js
  function BrowserWindow (line 13) | function BrowserWindow({
  function IframeWindow (line 48) | function IframeWindow({url}) {

FILE: docusaurus/src/components/HomepageCommunity/index.js
  function Testimonial (line 5) | function Testimonial({ testimonialLimitToShow, allTestimonials }) {
  function HomepageCommunity (line 48) | function HomepageCommunity() {

FILE: docusaurus/src/components/HomepageFAQ/index.js
  function HomepageFAQ (line 37) | function HomepageFAQ() {

FILE: docusaurus/src/components/HomepageFastkafkaChat/index.js
  function Feature (line 38) | function Feature({Svg, title, description}) {

FILE: docusaurus/src/components/HomepageFeatures/index.js
  function Feature (line 38) | function Feature({src, title, description}) {
  function HomepageFeatures (line 52) | function HomepageFeatures() {

FILE: docusaurus/src/components/HomepageWhatYouGet/index.js
  function HomepageWhatYouGet (line 7) | function HomepageWhatYouGet() {

FILE: docusaurus/src/components/RobotFooterIcon/index.js
  function RobotFooterIcon (line 6) | function RobotFooterIcon() {

FILE: docusaurus/src/pages/demo/index.js
  function Hello (line 13) | function Hello() {

FILE: docusaurus/src/pages/index.js
  function HomepageHeader (line 14) | function HomepageHeader() {
  function Home (line 34) | function Home() {

FILE: fastkafka/__init__.py
  function dummy (line 17) | def dummy() -> None:

FILE: fastkafka/_aiokafka_imports.py
  function dummy (line 18) | def dummy() -> None:

FILE: fastkafka/_application/app.py
  function _get_kafka_config (line 60) | def _get_kafka_config(
  function _get_kafka_brokers (line 86) | def _get_kafka_brokers(
  function _get_broker_addr_list (line 135) | def _get_broker_addr_list(
  function _get_topic_name (line 144) | def _get_topic_name(
  function _get_contact_info (line 163) | def _get_contact_info(
  class FastKafka (line 178) | class FastKafka:
    method __init__ (line 180) | def __init__(
    method is_started (line 309) | def is_started(self) -> bool:
    method set_kafka_broker (line 322) | def set_kafka_broker(self, kafka_broker_name: str) -> None:
    method __aenter__ (line 340) | async def __aenter__(self) -> "FastKafka":
    method __aexit__ (line 347) | async def __aexit__(
    method _start (line 357) | async def _start(self) -> None:
    method _stop (line 360) | async def _stop(self) -> None:
    method consumes (line 363) | def consumes(
    method produces (line 375) | def produces(
    method benchmark (line 387) | def benchmark(
    method run_in_background (line 395) | def run_in_background(
    method _populate_consumers (line 400) | def _populate_consumers(
    method get_topics (line 406) | def get_topics(self) -> Iterable[str]:
    method _populate_producers (line 409) | async def _populate_producers(self) -> None:
    method _populate_bg_tasks (line 412) | async def _populate_bg_tasks(self) -> None:
    method create_docs (line 415) | def create_docs(self) -> None:
    method create_mocks (line 418) | def create_mocks(self) -> None:
    method _shutdown_consumers (line 421) | async def _shutdown_consumers(self) -> None:
    method _shutdown_producers (line 424) | async def _shutdown_producers(self) -> None:
    method _shutdown_bg_tasks (line 427) | async def _shutdown_bg_tasks(self) -> None:
  function _get_decoder_fn (line 431) | def _get_decoder_fn(decoder: str) -> Callable[[bytes, Type[BaseModel]], ...
  function _prepare_and_check_brokers (line 451) | def _prepare_and_check_brokers(
  function _resolve_key (line 464) | def _resolve_key(key: str, dictionary: Dict[str, Any]) -> str:
  function consumes (line 475) | def consumes(
  function _get_encoder_fn (line 563) | def _get_encoder_fn(encoder: str) -> Callable[[BaseModel], bytes]:
  function produces (line 585) | def produces(
  function get_topics (line 668) | def get_topics(self: FastKafka) -> Iterable[str]:
  function run_in_background (line 681) | def run_in_background(
  function _populate_consumers (line 718) | def _populate_consumers(
  function _shutdown_consumers (line 761) | async def _shutdown_consumers(
  function _create_producer (line 769) | async def _create_producer(  # type: ignore
  function _populate_producers (line 814) | async def _populate_producers(self: FastKafka) -> None:
  function _shutdown_producers (line 859) | async def _shutdown_producers(self: FastKafka) -> None:
  function _populate_bg_tasks (line 882) | async def _populate_bg_tasks(
  function _shutdown_bg_tasks (line 895) | async def _shutdown_bg_tasks(
  function _start (line 918) | async def _start(self: FastKafka) -> None:
  function _stop (line 931) | async def _stop(self: FastKafka) -> None:
  function create_docs (line 943) | def create_docs(self: FastKafka) -> None:
  class AwaitedMock (line 972) | class AwaitedMock:
    method _await_for (line 981) | def _await_for(f: Callable[..., Any]) -> Callable[..., Any]:
    method __init__ (line 1014) | def __init__(self, o: Any):
  function create_mocks (line 1031) | def create_mocks(self: FastKafka) -> None:
  function benchmark (line 1113) | def benchmark(
  function fastapi_lifespan (line 1168) | def fastapi_lifespan(

FILE: fastkafka/_application/tester.py
  function _get_broker_spec (line 32) | def _get_broker_spec(bootstrap_server: str) -> KafkaBroker:
  class Tester (line 48) | class Tester(FastKafka):
    method __init__ (line 51) | def __init__(
    method _start_tester (line 79) | async def _start_tester(self) -> None:
    method _stop_tester (line 88) | async def _stop_tester(self) -> None:
    method _create_mirrors (line 94) | def _create_mirrors(self) -> None:
    method _arrange_mirrors (line 97) | def _arrange_mirrors(self) -> None:
    method _set_arguments_and_return_old (line 100) | def _set_arguments_and_return_old(
    method _restore_initial_arguments (line 121) | def _restore_initial_arguments(self, initial_arguments: Dict[Any, Any]...
    method using_external_broker (line 131) | async def using_external_broker(
    method using_inmemory_broker (line 154) | async def using_inmemory_broker(
    method _create_ctx (line 177) | async def _create_ctx(self) -> AsyncGenerator["Tester", None]:
    method __aenter__ (line 192) | async def __aenter__(self) -> "Tester":
    method __aexit__ (line 196) | async def __aexit__(self, *args: Any) -> None:
  function mirror_producer (line 200) | def mirror_producer(
  function mirror_consumer (line 245) | def mirror_consumer(
  function _create_mirrors (line 284) | def _create_mirrors(self: Tester) -> None:
  class AmbiguousWarning (line 331) | class AmbiguousWarning:
    method __init__ (line 340) | def __init__(self, topic: str, functions: List[str]):
    method __getattribute__ (line 344) | def __getattribute__(self, attr: str) -> Any:
    method __call__ (line 349) | def __call__(self, *args: Any, **kwargs: Any) -> Any:
  function set_sugar (line 355) | def set_sugar(
  function _arrange_mirrors (line 394) | def _arrange_mirrors(self: Tester) -> None:

FILE: fastkafka/_cli.py
  function run (line 27) | def run(

FILE: fastkafka/_cli_docs.py
  function docs_install_deps (line 37) | def docs_install_deps() -> None:
  function generate_docs (line 63) | def generate_docs(
  function serve_docs (line 103) | def serve_docs(

FILE: fastkafka/_cli_testing.py
  function testing_install_deps (line 25) | def testing_install_deps() -> None:

FILE: fastkafka/_components/_subprocess.py
  function terminate_asyncio_process (line 22) | async def terminate_asyncio_process(p: asyncio.subprocess.Process) -> None:
  function run_async_subprocesses (line 72) | async def run_async_subprocesses(

FILE: fastkafka/_components/aiokafka_consumer_loop.py
  class EventMetadata (line 27) | class EventMetadata:
    method create_event_metadata (line 56) | def create_event_metadata(record: ConsumerRecord) -> "EventMetadata": ...
  function _callback_parameters_wrapper (line 93) | def _callback_parameters_wrapper(
  function _prepare_callback (line 123) | def _prepare_callback(callback: ConsumeCallable) -> AsyncConsumeMeta:
  function _get_single_msg_handlers (line 141) | def _get_single_msg_handlers(  # type: ignore
  function _get_batch_msg_handlers (line 198) | def _get_batch_msg_handlers(  # type: ignore
  function _aiokafka_consumer_loop (line 256) | async def _aiokafka_consumer_loop(  # type: ignore
  function sanitize_kafka_config (line 308) | def sanitize_kafka_config(**kwargs: Any) -> Dict[str, Any]:
  function aiokafka_consumer_loop (line 315) | async def aiokafka_consumer_loop(

FILE: fastkafka/_components/asyncapi.py
  class KafkaMessage (line 34) | class KafkaMessage(BaseModel):
  class SecurityType (line 39) | class SecurityType(str, Enum):
  class APIKeyLocation (line 55) | class APIKeyLocation(str, Enum):
  class SecuritySchema (line 66) | class SecuritySchema(BaseModel):
    method __init__ (line 76) | def __init__(self, **kwargs: Any):
    method model_dump (line 82) | def model_dump(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
    method model_dump_json (line 94) | def model_dump_json(self, *args: Any, **kwargs: Any) -> str:
  class KafkaBroker (line 99) | class KafkaBroker(BaseModel):
    method model_dump (line 108) | def model_dump(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
    method model_dump_json (line 120) | def model_dump_json(self, *args: Any, **kwargs: Any) -> str:
  class ContactInfo (line 125) | class ContactInfo(BaseModel):
  class KafkaServiceInfo (line 131) | class KafkaServiceInfo(BaseModel):
  class KafkaBrokers (line 140) | class KafkaBrokers(BaseModel):
    method model_dump (line 143) | def model_dump(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
    method model_dump_json (line 163) | def model_dump_json(self, *args: Any, **kwargs: Any) -> str:
  function _get_msg_cls_for_producer (line 171) | def _get_msg_cls_for_producer(f: ProduceCallable) -> Type[Any]:
  function _get_msg_cls_for_consumer (line 188) | def _get_msg_cls_for_consumer(f: ConsumeCallable) -> Type[Any]:
  function _get_topic_dict (line 216) | def _get_topic_dict(
  function _get_channels_schema (line 240) | def _get_channels_schema(
  function _get_kafka_msg_classes (line 251) | def _get_kafka_msg_classes(
  function _get_kafka_msg_definitions (line 260) | def _get_kafka_msg_definitions(
  function _get_example (line 271) | def _get_example(cls: Type[BaseModel]) -> BaseModel:
  function _add_example_to_msg_definitions (line 283) | def _add_example_to_msg_definitions(
  function _get_msg_definitions_with_examples (line 294) | def _get_msg_definitions_with_examples(
  function _get_security_schemes (line 314) | def _get_security_schemes(kafka_brokers: KafkaBrokers) -> Dict[str, Any]:
  function _get_components_schema (line 329) | def _get_components_schema(
  function _get_servers_schema (line 362) | def _get_servers_schema(kafka_brokers: KafkaBrokers) -> Dict[str, Any]:
  function _get_asyncapi_schema (line 371) | def _get_asyncapi_schema(
  function yaml_file_cmp (line 392) | def yaml_file_cmp(file_1: Union[Path, str], file_2: Union[Path, str]) ->...
  function _generate_async_spec (line 417) | def _generate_async_spec(
  function _generate_async_docs (line 461) | def _generate_async_docs(
  function export_async_spec (line 497) | def export_async_spec(

FILE: fastkafka/_components/benchmarking.py
  function _benchmark (line 18) | def _benchmark(

FILE: fastkafka/_components/docs_dependencies.py
  function _check_npm (line 33) | def _check_npm(required_major_version: int = npm_required_major_version)...
  function _check_npm_with_local (line 76) | def _check_npm_with_local(node_path: Path = node_path) -> None:
  function _install_node (line 103) | def _install_node(
  function _install_docs_npm_deps (line 158) | async def _install_docs_npm_deps() -> None:

FILE: fastkafka/_components/encoder/avro.py
  class AvroBase (line 22) | class AvroBase(BaseModel):
    method avro_schema_for_pydantic_object (line 26) | def avro_schema_for_pydantic_object(
    method avro_schema_for_pydantic_class (line 53) | def avro_schema_for_pydantic_class(
    method avro_schema (line 80) | def avro_schema(
    method _avro_schema (line 102) | def _avro_schema(schema: Dict[str, Any], namespace: str) -> Dict[str, ...
  function avro_encoder (line 239) | def avro_encoder(msg: BaseModel) -> bytes:
  function avro_decoder (line 263) | def avro_decoder(raw_msg: bytes, cls: Type[BaseModel]) -> Any:
  function avsc_to_pydantic (line 283) | def avsc_to_pydantic(schema: Dict[str, Any]) -> Type[BaseModel]:

FILE: fastkafka/_components/encoder/json.py
  function _to_json_utf8 (line 19) | def _to_json_utf8(o: Any) -> bytes:
  function json_encoder (line 28) | def json_encoder(msg: BaseModel) -> bytes:
  function json_decoder (line 42) | def json_decoder(raw_msg: bytes, cls: Type[BaseModel]) -> Any:

FILE: fastkafka/_components/helpers.py
  function in_notebook (line 7) | def in_notebook() -> bool:
  function change_dir (line 38) | def change_dir(d: str) -> Generator[None, None, None]:
  class ImportFromStringError (line 56) | class ImportFromStringError(Exception):
  function _import_from_string (line 60) | def _import_from_string(import_str: str) -> Any:
  function true_after (line 105) | def true_after(seconds: Union[int, float]) -> Callable[[], bool]:
  function unwrap_list_type (line 115) | def unwrap_list_type(var_type: Union[Type, Parameter]) -> Union[Type, Pa...
  function remove_suffix (line 137) | def remove_suffix(topic: str) -> str:

FILE: fastkafka/_components/logger.py
  function suppress_timestamps (line 26) | def suppress_timestamps(flag: bool = True) -> None:
  function get_default_logger_configuration (line 37) | def get_default_logger_configuration(level: int = logging.INFO) -> Dict[...
  function get_logger (line 80) | def get_logger(
  function set_level (line 120) | def set_level(level: int) -> None:
  function cached_log (line 138) | def cached_log(

FILE: fastkafka/_components/meta.py
  function test_eq (line 21) | def test_eq(a: Any, b: Any) -> None:
  function copy_func (line 30) | def copy_func(f: Union[F, FunctionType]) -> Union[F, FunctionType]:
  function patch_to (line 45) | def patch_to(
  function eval_type (line 72) | def eval_type(
  function union2tuple (line 86) | def union2tuple(t) -> Tuple[Any, ...]:  # type: ignore
  function get_annotations_ex (line 97) | def get_annotations_ex(
  function patch (line 159) | def patch(  # type: ignore
  function _delegates_without_docs (line 172) | def _delegates_without_docs(
  function _format_args (line 219) | def _format_args(xs: List[docstring_parser.DocstringParam]) -> str:
  function combine_params (line 225) | def combine_params(
  function delegates (line 263) | def delegates(
  function use_parameters_of (line 300) | def use_parameters_of(
  function filter_using_signature (line 317) | def filter_using_signature(f: Callable, **kwargs: Dict[str, Any]) -> Dic...
  function export (line 326) | def export(module_name: str) -> Callable[[TorF], TorF]:
  function classcontextmanager (line 347) | def classcontextmanager(name: str = "lifecycle") -> Callable[[Type[T]], ...
  function _get_default_kwargs_from_sig (line 379) | def _get_default_kwargs_from_sig(f: F, **kwargs: Any) -> Dict[str, Any]:

FILE: fastkafka/_components/producer_decorator.py
  class KafkaEvent (line 38) | class KafkaEvent(Generic[BaseSubmodel]):
  function unwrap_from_kafka_event (line 51) | def unwrap_from_kafka_event(var_type: Union[Type, Parameter]) -> Union[T...
  function _wrap_in_event (line 82) | def _wrap_in_event(
  function release_callback (line 88) | def release_callback(
  function produce_single (line 102) | async def produce_single(  # type: ignore
  function send_batch (line 133) | async def send_batch(  # type: ignore
  function produce_batch (line 164) | async def produce_batch(  # type: ignore
  function producer_decorator (line 202) | def producer_decorator(

FILE: fastkafka/_components/task_streaming.py
  class TaskPool (line 26) | class TaskPool:
    method __init__ (line 27) | def __init__(
    method add (line 47) | async def add(self, item: Task) -> None:
    method discard (line 62) | def discard(self, task: Task) -> None:
    method __len__ (line 83) | def __len__(self) -> int:
    method __aenter__ (line 92) | async def __aenter__(self) -> "TaskPool":
    method __aexit__ (line 96) | async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
    method log_error (line 102) | def log_error(logger: Logger) -> Callable[[Exception], None]:
  class ExceptionMonitor (line 119) | class ExceptionMonitor:
    method __init__ (line 120) | def __init__(self) -> None:
    method on_error (line 130) | def on_error(self, e: Exception) -> None:
    method _monitor_step (line 143) | def _monitor_step(self) -> None:
    method __aenter__ (line 154) | async def __aenter__(self) -> "ExceptionMonitor":
    method __aexit__ (line 157) | async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
  class StreamExecutor (line 163) | class StreamExecutor(ABC):
    method run (line 165) | async def run(  # type: ignore
  function _process_items_task (line 183) | def _process_items_task(  # type: ignore
  class DynamicTaskExecutor (line 207) | class DynamicTaskExecutor(StreamExecutor):
    method __init__ (line 214) | def __init__(
    method run (line 239) | async def run(  # type: ignore
  function _process_items_coro (line 275) | def _process_items_coro(  # type: ignore
  class SequentialExecutor (line 305) | class SequentialExecutor(StreamExecutor):
    method __init__ (line 312) | def __init__(
    method run (line 328) | async def run(  # type: ignore
  function get_executor (line 359) | def get_executor(executor: Union[str, StreamExecutor, None] = None) -> S...

FILE: fastkafka/_components/test_dependencies.py
  function check_java (line 34) | def check_java(*, potential_jdk_path: Optional[List[Path]] = None) -> bool:
  function _install_java (line 59) | def _install_java() -> None:
  class VersionParser (line 87) | class VersionParser(HTMLParser):
    method __init__ (line 99) | def __init__(self) -> None:
    method handle_data (line 109) | def handle_data(self, data: str) -> None:
  function get_kafka_version (line 130) | def get_kafka_version(kafka_repo_url: str = kafka_repo_url) -> str:
  function check_kafka (line 169) | def check_kafka(local_path: Path = local_path) -> bool:
  function _install_kafka (line 201) | def _install_kafka(
  function _install_testing_deps (line 265) | def _install_testing_deps() -> None:
  function generate_app_src (line 275) | def generate_app_src(out_path: Union[Path, str]) -> None:
  function generate_app_in_tmp (line 303) | def generate_app_in_tmp() -> Generator[str, None, None]:

FILE: fastkafka/_docusaurus_helper.py
  function _get_return_annotation (line 49) | def _get_return_annotation(s: Signature) -> str:
  function _get_param_annotation (line 71) | def _get_param_annotation(param: Parameter) -> str:
  function _get_default_value (line 94) | def _get_default_value(param: Parameter) -> str:
  function _get_params_annotation (line 114) | def _get_params_annotation(s: Signature) -> Dict[str, Dict[str, str]]:
  function _generate_parameters_table (line 132) | def _generate_parameters_table(
  function _generate_return_and_raises_table (line 164) | def _generate_return_and_raises_table(
  function _format_docstring_section_items (line 192) | def _format_docstring_section_items(
  function _get_annotation (line 215) | def _get_annotation(symbol: Type) -> Dict[str, Union[Dict[str, Dict[str,...
  function _format_docstring_sections (line 231) | def _format_docstring_sections(symbol: Type, parsed_docstring: Docstring...
  function _format_free_links (line 258) | def _format_free_links(s: str) -> str:
  function _docstring_to_markdown (line 274) | def _docstring_to_markdown(symbol: Type) -> str:
  function _get_submodules (line 299) | def _get_submodules(module_name: str) -> List[str]:
  function _load_submodules (line 316) | def _load_submodules(
  function _get_parameters (line 340) | def _get_parameters(_signature: Signature) -> List[str]:
  function _format_symbol_definition (line 361) | def _format_symbol_definition(symbol: Type, params_list: List[str]) -> str:
  function _get_exps (line 381) | def _get_exps(mod: str) -> Dict[str, str]:
  function _lineno (line 403) | def _lineno(sym: str, fname: str) -> Optional[str]:
  class CustomNbdevLookup (line 408) | class CustomNbdevLookup(NbdevLookup.__wrapped__):  # type: ignore
    method __init__ (line 409) | def __init__(
    method code (line 417) | def code(self, sym: str) -> Optional[str]:
  function _get_symbol_source_link (line 427) | def _get_symbol_source_link(symbol: Type, lib_version: str) -> str:
  function _get_method_type (line 451) | def _get_method_type(symbol: Type) -> str:
  function _get_symbol_definition (line 466) | def _get_symbol_definition(symbol: Type, header_level: int, lib_version:...
  function _is_method (line 496) | def _is_method(symbol: Type) -> bool:
  function _get_formatted_docstring_for_symbol (line 508) | def _get_formatted_docstring_for_symbol(
  function _convert_html_style_attribute_to_jsx (line 553) | def _convert_html_style_attribute_to_jsx(contents: str) -> str:
  function _get_all_markdown_files_path (line 585) | def _get_all_markdown_files_path(docs_path: Path) -> List[Path]:
  function _fix_special_symbols_in_html (line 598) | def _fix_special_symbols_in_html(contents: str) -> str:
  function _add_file_extension_to_link (line 603) | def _add_file_extension_to_link(url: str) -> str:
  function _generate_production_url (line 616) | def _generate_production_url(url: str) -> str:
  function _fix_symbol_links (line 632) | def _fix_symbol_links(
  function _get_relative_url_prefix (line 669) | def _get_relative_url_prefix(docs_path: Path, sub_path: Path) -> str:
  function fix_invalid_syntax_in_markdown (line 692) | def fix_invalid_syntax_in_markdown(docs_path: str) -> None:
  function generate_markdown_docs (line 715) | def generate_markdown_docs(module_name: str, docs_path: str) -> None:
  function _parse_lines (line 735) | def _parse_lines(lines: List[str]) -> Tuple[List[str], int]:
  function _parse_section (line 752) | def _parse_section(text: str, ignore_first_line: bool = False) -> List[A...
  function _get_section_from_markdown (line 781) | def _get_section_from_markdown(
  function generate_sidebar (line 799) | def generate_sidebar(
  function _get_markdown_filenames_from_sidebar (line 855) | def _get_markdown_filenames_from_sidebar(sidebar_file_path: str) -> List...
  function _delete_files (line 876) | def _delete_files(files: List[Path]) -> None:
  function delete_unused_markdown_files_from_sidebar (line 895) | def delete_unused_markdown_files_from_sidebar(
  function update_readme (line 918) | def update_readme() -> None:

FILE: fastkafka/_helpers.py
  function aiokafka2confluent (line 37) | def aiokafka2confluent(**kwargs: Dict[str, Any]) -> Dict[str, Any]:
  function confluent2aiokafka (line 182) | def confluent2aiokafka(confluent_config: Dict[str, Any]) -> Dict[str, Any]:
  function produce_messages (line 207) | async def produce_messages(  # type: ignore
  function consumes_messages (line 367) | async def consumes_messages(
  function produce_and_consume_messages (line 559) | async def produce_and_consume_messages(
  function get_collapsible_admonition (line 834) | def get_collapsible_admonition(
  function source2markdown (line 857) | def source2markdown(o: Union[str, Callable[..., Any]]) -> Markdown:
  function wait_for_get_url (line 873) | async def wait_for_get_url(

FILE: fastkafka/_server.py
  class ServerProcess (line 27) | class ServerProcess:
    method __init__ (line 28) | def __init__(self, app: str, kafka_broker_name: str):
    method run (line 40) | def run(self) -> None:
    method _serve (line 46) | async def _serve(self) -> None:
    method _install_signal_handlers (line 58) | def _install_signal_handlers(self) -> None:
    method _main_loop (line 86) | async def _main_loop(self) -> None:
  function run_fastkafka_server_process (line 98) | def run_fastkafka_server_process(
  function run_fastkafka_server (line 111) | async def run_fastkafka_server(num_workers: int, app: str, kafka_broker:...
  function run_in_process (line 205) | def run_in_process(

FILE: fastkafka/_testing/apache_kafka_broker.py
  function get_zookeeper_config_string (line 39) | def get_zookeeper_config_string(
  function get_kafka_config_string (line 65) | def get_kafka_config_string(
  class ApacheKafkaBroker (line 168) | class ApacheKafkaBroker:
    method __init__ (line 173) | def __init__(
    method is_started (line 212) | def is_started(self) -> bool:
    method _check_deps (line 225) | def _check_deps(cls) -> None:
    method _start (line 232) | async def _start(self) -> str:
    method start (line 239) | def start(self) -> str:
    method stop (line 246) | def stop(self) -> None:
    method _stop (line 250) | async def _stop(self) -> None:
    method get_service_config_string (line 257) | def get_service_config_string(self, service: str, *, data_dir: Path) -...
    method _start_service (line 265) | async def _start_service(self, service: str = "kafka") -> None:
    method _start_zookeeper (line 272) | async def _start_zookeeper(self) -> None:
    method _start_kafka (line 279) | async def _start_kafka(self) -> None:
    method _create_topics (line 286) | async def _create_topics(self) -> None:
    method __enter__ (line 293) | def __enter__(self) -> str:
    method __exit__ (line 297) | def __exit__(self, *args: Any, **kwargs: Any) -> None:
    method __aenter__ (line 300) | async def __aenter__(self) -> str:
    method __aexit__ (line 304) | async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
  function _check_deps (line 309) | def _check_deps(cls: ApacheKafkaBroker) -> None:
  function run_and_match (line 325) | async def run_and_match(
  function is_port_in_use (line 407) | def is_port_in_use(port: Union[int, str]) -> bool:
  function get_free_port (line 421) | def get_free_port() -> str:
  function write_config_and_run (line 434) | async def write_config_and_run(
  function get_service_config_string (line 459) | def get_service_config_string(
  function _start_service (line 479) | async def _start_service(self: ApacheKafkaBroker, service: str = "kafka"...
  function _start_kafka (line 546) | async def _start_kafka(self: ApacheKafkaBroker) -> None:
  function _start_zookeeper (line 552) | async def _start_zookeeper(self: ApacheKafkaBroker) -> None:
  function _create_topics (line 558) | async def _create_topics(self: ApacheKafkaBroker) -> None:
  function _start (line 589) | async def _start(self: ApacheKafkaBroker) -> str:
  function _stop (line 615) | async def _stop(self: ApacheKafkaBroker) -> None:
  function start (line 624) | def start(self: ApacheKafkaBroker) -> str:
  function stop (line 668) | def stop(self: ApacheKafkaBroker) -> None:
  function _start_broker (line 683) | async def _start_broker(broker: Any) -> Union[Any, Exception]:
  function _stop_broker (line 691) | async def _stop_broker(broker: Any) -> Union[Any, Exception]:
  function _get_unique_local_brokers_to_start (line 699) | async def _get_unique_local_brokers_to_start(
  function _start_and_stop_brokers (line 739) | async def _start_and_stop_brokers(brokers: List[T]) -> AsyncIterator[None]:
  function start_apache_kafka_brokers (line 761) | async def start_apache_kafka_brokers(

FILE: fastkafka/_testing/in_memory_broker.py
  class KafkaRecord (line 36) | class KafkaRecord:
  class KafkaPartition (line 50) | class KafkaPartition:
    method __init__ (line 51) | def __init__(self, *, partition: int, topic: str):
    method write (line 63) | def write(self, value: bytes, key: Optional[bytes] = None) -> RecordMe...
    method read (line 93) | def read(self, offset: int) -> Tuple[List[KafkaRecord], int]:
    method latest_offset (line 105) | def latest_offset(self) -> int:
  class KafkaTopic (line 115) | class KafkaTopic:
    method __init__ (line 116) | def __init__(self, topic: str, num_partitions: int = 1):
    method read (line 131) | def read(  # type: ignore
    method write_with_partition (line 148) | def write_with_partition(  # type: ignore
    method write_with_key (line 165) | def write_with_key(self, value: bytes, key: bytes) -> RecordMetadata: ...
    method write (line 179) | def write(  # type: ignore
    method latest_offset (line 206) | def latest_offset(self, partition: int) -> int:
  function split_list (line 219) | def split_list(list_to_split: List[Any], split_size: int) -> List[List[A...
  class GroupMetadata (line 236) | class GroupMetadata:
    method __init__ (line 237) | def __init__(self, num_partitions: int):
    method subscribe (line 249) | def subscribe(self, consumer_id: uuid.UUID) -> None:
    method unsubscribe (line 259) | def unsubscribe(self, consumer_id: uuid.UUID) -> None:
    method rebalance (line 269) | def rebalance(self) -> None:
    method assign_partitions (line 281) | def assign_partitions(self, partitions_per_actor: int) -> None:
    method get_partitions (line 290) | def get_partitions(
    method set_offset (line 309) | def set_offset(self, partition: int, offset: int) -> None:
  class InMemoryBroker (line 321) | class InMemoryBroker:
    method __init__ (line 322) | def __init__(
    method connect (line 331) | def connect(self) -> uuid.UUID:
    method dissconnect (line 334) | def dissconnect(self, consumer_id: uuid.UUID) -> None:
    method subscribe (line 343) | def subscribe(
    method unsubscribe (line 348) | def unsubscribe(
    method read (line 353) | def read(  # type: ignore
    method write (line 364) | def write(  # type: ignore
    method lifecycle (line 376) | def lifecycle(self) -> Iterator["InMemoryBroker"]:
    method _start (line 385) | async def _start(self) -> str:
    method _stop (line 396) | async def _stop(self) -> None:
  function subscribe (line 405) | def subscribe(
  function unsubscribe (line 434) | def unsubscribe(
  function write (line 454) | def write(  # type: ignore
  function read (line 487) | def read(  # type: ignore
  class InMemoryConsumer (line 538) | class InMemoryConsumer:
    method __init__ (line 539) | def __init__(
    method __call__ (line 551) | def __call__(self, **kwargs: Any) -> "InMemoryConsumer":
    method start (line 569) | async def start(self, **kwargs: Any) -> None:
    method stop (line 573) | async def stop(self, **kwargs: Any) -> None:
    method subscribe (line 577) | def subscribe(self, topics: List[str], **kwargs: Any) -> None:
    method getmany (line 581) | async def getmany(  # type: ignore
  function start (line 589) | async def start(self: InMemoryConsumer, **kwargs: Any) -> None:
  function subscribe (line 606) | def subscribe(self: InMemoryConsumer, topics: List[str], **kwargs: Any) ...
  function stop (line 632) | async def stop(self: InMemoryConsumer, **kwargs: Any) -> None:
  function getmany (line 653) | async def getmany(  # type: ignore
  class InMemoryProducer (line 676) | class InMemoryProducer:
    method __init__ (line 677) | def __init__(self, broker: InMemoryBroker, **kwargs: Any) -> None:
    method __call__ (line 683) | def __call__(self, **kwargs: Any) -> "InMemoryProducer":
    method start (line 694) | async def start(self, **kwargs: Any) -> None:
    method stop (line 698) | async def stop(self, **kwargs: Any) -> None:
    method send (line 702) | async def send(  # type: ignore
    method partitions_for (line 712) | async def partitions_for(self, topic: str) -> List[int]:
    method _partition (line 716) | def _partition(
    method create_batch (line 722) | def create_batch(self) -> "MockBatch":
    method send_batch (line 726) | async def send_batch(self, batch: "MockBatch", topic: str, partition: ...
  function start (line 732) | async def start(self: InMemoryProducer, **kwargs: Any) -> None:
  function stop (line 749) | async def stop(self: InMemoryProducer, **kwargs: Any) -> None:
  function send (line 763) | async def send(  # type: ignore
  function partitions_for (line 806) | async def partitions_for(self: InMemoryProducer, topic: str) -> List[int]:
  function _partition (line 821) | def _partition(
  class MockBatch (line 843) | class MockBatch:
    method __init__ (line 844) | def __init__(self) -> None:
    method append (line 850) | def append(  # type: ignore
  function create_batch (line 878) | def create_batch(self: InMemoryProducer) -> "MockBatch":
  function send_batch (line 890) | async def send_batch(
  function lifecycle (line 913) | def lifecycle(self: InMemoryBroker) -> Iterator[InMemoryBroker]:

FILE: fastkafka/_testing/local_redpanda_broker.py
  function get_redpanda_docker_cmd (line 37) | def get_redpanda_docker_cmd(
  class LocalRedpandaBroker (line 84) | class LocalRedpandaBroker:
    method __init__ (line 88) | def __init__(
    method is_started (line 123) | def is_started(self) -> bool:
    method _check_deps (line 136) | async def _check_deps(cls) -> None:
    method _start (line 143) | async def _start(self) -> str:
    method start (line 150) | def start(self) -> str:
    method stop (line 157) | def stop(self) -> None:
    method _stop (line 161) | async def _stop(self) -> None:
    method get_service_config_string (line 168) | def get_service_config_string(self, service: str, *, data_dir: Path) -...
    method _start_redpanda (line 176) | async def _start_redpanda(self) -> None:
    method _create_topics (line 183) | async def _create_topics(self) -> None:
    method __enter__ (line 190) | def __enter__(self) -> str:
    method __exit__ (line 193) | def __exit__(self, *args: Any, **kwargs: Any) -> None:
    method __aenter__ (line 196) | async def __aenter__(self) -> str:
    method __aexit__ (line 199) | async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
  function check_docker (line 203) | async def check_docker(tag: str = "v23.1.2") -> bool:
  function _check_deps (line 227) | async def _check_deps(cls: LocalRedpandaBroker) -> None:
  function _start_redpanda (line 235) | async def _start_redpanda(self: LocalRedpandaBroker, service: str = "red...
  function _create_topics (line 273) | async def _create_topics(self: LocalRedpandaBroker) -> None:
  function _start (line 303) | async def _start(self: LocalRedpandaBroker) -> str:
  function _stop (line 324) | async def _stop(self: LocalRedpandaBroker) -> None:
  function start (line 333) | def start(self: LocalRedpandaBroker) -> str:
  function stop (line 376) | def stop(self: LocalRedpandaBroker) -> None:
  function start_redpanda_brokers (line 392) | async def start_redpanda_brokers(

FILE: fastkafka/_testing/test_utils.py
  function nb_safe_seed (line 32) | def nb_safe_seed(s: str) -> Callable[[int], int]:
  function mock_AIOKafkaProducer_send (line 50) | def mock_AIOKafkaProducer_send() -> Generator[unittest.mock.Mock, None, ...
  function run_script_and_cancel (line 62) | async def run_script_and_cancel(
  function display_docs (line 134) | async def display_docs(docs_path: str, port: int = 4000) -> None:

FILE: fastkafka/encoder.py
  function dummy (line 27) | def dummy() -> None:

FILE: fastkafka/executors.py
  function dummy (line 14) | def dummy() -> None:

FILE: fastkafka/testing.py
  function dummy (line 33) | def dummy() -> None: