SYMBOL INDEX (1343 symbols across 46 files)

FILE: app.py
  function find_key (line 16) | def find_key(token):
  function page_not_found (line 83) | def page_not_found(e):
  function static_proxy (line 89) | def static_proxy(path):
  function index_redirection (line 99) | def index_redirection():
  function acme (line 106) | def acme(token):

FILE: app_test.py
  class PysheeetTest (line 23) | class PysheeetTest(LiveServerTestCase):
    method create_app (line 26) | def create_app(self):
    method check_security_headers (line 44) | def check_security_headers(self, resp):
    method check_csrf_cookies (line 54) | def check_csrf_cookies(self, resp):
    method test_index_redirection_req (line 60) | def test_index_redirection_req(self):
    method test_static_proxy_req (line 68) | def test_static_proxy_req(self):
    method test_acme_req (line 80) | def test_acme_req(self):
    method test_find_key (line 93) | def test_find_key(self):
    method test_acme (line 109) | def test_acme(self):
    method test_index_redirection (line 126) | def test_index_redirection(self):
    method test_static_proxy (line 132) | def test_static_proxy(self):
    method test_page_not_found (line 145) | def test_page_not_found(self):

FILE: docs/conf.py
  function add_html_link (line 329) | def add_html_link(app, pagename, templatename, context, doctree):
  function create_sitemap (line 340) | def create_sitemap(app, exception):
  function setup (line 364) | def setup(app):

FILE: src/basic/asyncio_.py
  class TestAsyncioBasics (line 7) | class TestAsyncioBasics:
    method test_asyncio_run (line 10) | def test_asyncio_run(self):
    method test_create_task (line 19) | def test_create_task(self):
    method test_gather (line 33) | def test_gather(self):
    method test_wait_for_timeout (line 46) | def test_wait_for_timeout(self):
    method test_wait_first_completed (line 58) | def test_wait_first_completed(self):
  class TestAsyncIterator (line 83) | class TestAsyncIterator:
    method test_async_iterator (line 86) | def test_async_iterator(self):
    method test_async_generator (line 114) | def test_async_generator(self):
  class TestAsyncContextManager (line 129) | class TestAsyncContextManager:
    method test_async_context_manager (line 132) | def test_async_context_manager(self):
    method test_asynccontextmanager_decorator (line 154) | def test_asynccontextmanager_decorator(self):
  class TestSynchronization (line 172) | class TestSynchronization:
    method test_lock (line 175) | def test_lock(self):
    method test_semaphore (line 194) | def test_semaphore(self):
    method test_event (line 215) | def test_event(self):
  class TestQueue (line 237) | class TestQueue:
    method test_queue (line 240) | def test_queue(self):
    method test_priority_queue (line 263) | def test_priority_queue(self):
  class TestExceptionHandling (line 283) | class TestExceptionHandling:
    method test_task_exception (line 286) | def test_task_exception(self):
    method test_gather_return_exceptions (line 299) | def test_gather_return_exceptions(self):
  class TestCancellation (line 316) | class TestCancellation:
    method test_cancel_task (line 319) | def test_cancel_task(self):
  class TestExecutor (line 347) | class TestExecutor:
    method test_run_in_executor (line 350) | def test_run_in_executor(self):
  class TestSubprocess (line 366) | class TestSubprocess:
    method test_subprocess (line 369) | def test_subprocess(self):
  class TestTimeout (line 386) | class TestTimeout:
    method test_wait_for_timeout (line 389) | def test_wait_for_timeout(self):

FILE: src/basic/basic.py
  function get_version_info (line 12) | def get_version_info() -> tuple:
  function get_version_string (line 17) | def get_version_string() -> str:
  function check_version (line 22) | def check_version(major: int, minor: int) -> bool:
  function classify_number (line 28) | def classify_number(x: int) -> str:
  function is_even (line 38) | def is_even(x: int) -> bool:
  function sum_range (line 44) | def sum_range(n: int) -> int:
  function find_first_even (line 52) | def find_first_even(numbers: list) -> int | None:
  function sum_odd_only (line 60) | def sum_odd_only(numbers: list) -> int:
  function loop_completed (line 70) | def loop_completed(items: list, target) -> bool:
  function safe_divide (line 79) | def safe_divide(a: float, b: float) -> float | None:
  function parse_int (line 87) | def parse_int(s: str) -> int | None:
  function divide_or_raise (line 95) | def divide_or_raise(a: float, b: float) -> float:
  function squares (line 103) | def squares(n: int) -> list:
  function even_numbers (line 108) | def even_numbers(n: int) -> list:
  function square_dict (line 113) | def square_dict(n: int) -> dict:
  function is_truthy (line 119) | def is_truthy(value) -> bool:
  function swap (line 125) | def swap(a, b) -> tuple:
  function first_and_rest (line 130) | def first_and_rest(items: list) -> tuple:
  class TestVersion (line 137) | class TestVersion:
    method test_get_version_info (line 138) | def test_get_version_info(self):
    method test_check_version (line 143) | def test_check_version(self):
  class TestControlFlow (line 148) | class TestControlFlow:
    method test_classify_number (line 149) | def test_classify_number(self):
    method test_is_even (line 154) | def test_is_even(self):
  class TestLoops (line 159) | class TestLoops:
    method test_sum_range (line 160) | def test_sum_range(self):
    method test_find_first_even (line 163) | def test_find_first_even(self):
    method test_sum_odd_only (line 167) | def test_sum_odd_only(self):
    method test_loop_completed (line 170) | def test_loop_completed(self):
  class TestExceptions (line 175) | class TestExceptions:
    method test_safe_divide (line 176) | def test_safe_divide(self):
    method test_parse_int (line 180) | def test_parse_int(self):
    method test_divide_or_raise (line 184) | def test_divide_or_raise(self):
  class TestComprehensions (line 190) | class TestComprehensions:
    method test_squares (line 191) | def test_squares(self):
    method test_even_numbers (line 194) | def test_even_numbers(self):
    method test_square_dict (line 197) | def test_square_dict(self):
  class TestTruthiness (line 201) | class TestTruthiness:
    method test_falsy (line 202) | def test_falsy(self):
    method test_truthy (line 208) | def test_truthy(self):
  class TestAssignment (line 214) | class TestAssignment:
    method test_swap (line 215) | def test_swap(self):
    method test_first_and_rest (line 218) | def test_first_and_rest(self):

FILE: src/basic/cext_.py
  function has_c_compiler (line 19) | def has_c_compiler():
  class TestCtypesBasic (line 38) | class TestCtypesBasic:
    method test_libc_strlen (line 41) | def test_libc_strlen(self):
    method test_libc_abs (line 56) | def test_libc_abs(self):
    method test_math_sqrt (line 68) | def test_math_sqrt(self):
  class TestCtypesStructures (line 84) | class TestCtypesStructures:
    method test_simple_structure (line 87) | def test_simple_structure(self):
    method test_nested_structure (line 101) | def test_nested_structure(self):
    method test_array_in_structure (line 116) | def test_array_in_structure(self):
  class TestCtypesPointers (line 131) | class TestCtypesPointers:
    method test_pointer_to_int (line 134) | def test_pointer_to_int(self):
    method test_byref (line 144) | def test_byref(self):
  class TestCtypesCustomLibrary (line 154) | class TestCtypesCustomLibrary:
    method fib_library (line 158) | def fib_library(self, tmp_path):
    method test_fib (line 210) | def test_fib(self, fib_library):
    method test_add (line 217) | def test_add(self, fib_library):
    method test_multiply (line 223) | def test_multiply(self, fib_library):
  class TestCffi (line 229) | class TestCffi:
    method cffi_available (line 233) | def cffi_available(self):
    method test_cffi_libc (line 242) | def test_cffi_libc(self, cffi_available):
    method test_cffi_math (line 263) | def test_cffi_math(self, cffi_available):
  class TestPythonPerformance (line 285) | class TestPythonPerformance:
    method test_python_fib (line 288) | def test_python_fib(self):
    method test_python_fib_iterative (line 301) | def test_python_fib_iterative(self):
    method test_python_fib_memoized (line 317) | def test_python_fib_memoized(self):

FILE: src/basic/concurrency_.py
  function _mp_square (line 11) | def _mp_square(x):
  function _mp_add (line 15) | def _mp_add(a, b):
  function _mp_worker (line 19) | def _mp_worker(q, n):
  function _mp_increment (line 23) | def _mp_increment(counter):
  function _mp_double (line 29) | def _mp_double(arr):
  class TestThreading (line 34) | class TestThreading:
    method test_thread_creation (line 37) | def test_thread_creation(self):
    method test_thread_with_return_value (line 52) | def test_thread_with_return_value(self):
    method test_lock (line 67) | def test_lock(self):
    method test_rlock (line 85) | def test_rlock(self):
    method test_semaphore (line 105) | def test_semaphore(self):
    method test_event (line 126) | def test_event(self):
    method test_condition (line 148) | def test_condition(self):
    method test_barrier (line 177) | def test_barrier(self):
    method test_queue (line 197) | def test_queue(self):
  class TestMultiprocessing (line 221) | class TestMultiprocessing:
    method test_process_creation (line 224) | def test_process_creation(self):
    method test_pool_map (line 238) | def test_pool_map(self):
    method test_pool_starmap (line 247) | def test_pool_starmap(self):
    method test_shared_value (line 256) | def test_shared_value(self):
    method test_shared_array (line 271) | def test_shared_array(self):
  class TestConcurrentFutures (line 283) | class TestConcurrentFutures:
    method test_thread_pool_map (line 286) | def test_thread_pool_map(self):
    method test_thread_pool_submit (line 297) | def test_thread_pool_submit(self):
    method test_as_completed (line 309) | def test_as_completed(self):
    method test_future_callback (line 323) | def test_future_callback(self):
    method test_future_exception (line 341) | def test_future_exception(self):
    method test_future_timeout (line 353) | def test_future_timeout(self):
    method test_future_cancel (line 367) | def test_future_cancel(self):
    method test_process_pool_map (line 385) | def test_process_pool_map(self):
  class TestProducerConsumer (line 395) | class TestProducerConsumer:
    method test_basic_producer_consumer (line 398) | def test_basic_producer_consumer(self):
    method test_multiple_consumers (line 426) | def test_multiple_consumers(self):

FILE: src/basic/crypto_.py
  class TestSecureRandom (line 23) | class TestSecureRandom:
    method test_token_bytes (line 26) | def test_token_bytes(self):
    method test_token_urlsafe (line 32) | def test_token_urlsafe(self):
    method test_token_hex (line 36) | def test_token_hex(self):
    method test_randbelow (line 40) | def test_randbelow(self):
  class TestHashing (line 46) | class TestHashing:
    method test_sha256 (line 49) | def test_sha256(self):
    method test_sha3_256 (line 56) | def test_sha3_256(self):
    method test_blake2b (line 61) | def test_blake2b(self):
    method test_blake2b_keyed (line 66) | def test_blake2b_keyed(self):
  class TestHMAC (line 78) | class TestHMAC:
    method test_hmac_create_verify (line 81) | def test_hmac_create_verify(self):
    method test_hmac_tamper_detection (line 89) | def test_hmac_tamper_detection(self):
  class TestKeyDerivation (line 98) | class TestKeyDerivation:
    method test_pbkdf2 (line 101) | def test_pbkdf2(self):
    method test_pbkdf2_verify (line 113) | def test_pbkdf2_verify(self):
    method test_hkdf (line 133) | def test_hkdf(self):
  class TestAESGCM (line 146) | class TestAESGCM:
    method test_encrypt_decrypt (line 149) | def test_encrypt_decrypt(self):
    method test_with_associated_data (line 158) | def test_with_associated_data(self):
    method test_tamper_detection (line 168) | def test_tamper_detection(self):
  class TestChaCha20Poly1305 (line 180) | class TestChaCha20Poly1305:
    method test_encrypt_decrypt (line 183) | def test_encrypt_decrypt(self):
  class TestFernet (line 193) | class TestFernet:
    method test_encrypt_decrypt (line 196) | def test_encrypt_decrypt(self):
    method test_different_tokens (line 204) | def test_different_tokens(self):
  class TestRSA (line 214) | class TestRSA:
    method test_key_generation (line 217) | def test_key_generation(self):
    method test_key_serialization (line 226) | def test_key_serialization(self):
    method test_oaep_encrypt_decrypt (line 238) | def test_oaep_encrypt_decrypt(self):
    method test_pss_sign_verify (line 263) | def test_pss_sign_verify(self):
  class TestEd25519 (line 290) | class TestEd25519:
    method test_sign_verify (line 293) | def test_sign_verify(self):
    method test_invalid_signature (line 301) | def test_invalid_signature(self):
  class TestX25519 (line 310) | class TestX25519:
    method test_key_exchange (line 313) | def test_key_exchange(self):
  class TestHybridEncryption (line 326) | class TestHybridEncryption:
    method test_hybrid_encrypt_decrypt (line 329) | def test_hybrid_encrypt_decrypt(self):

FILE: src/basic/datetime_.py
  function test_current_datetime (line 8) | def test_current_datetime():
  function test_create_datetime (line 20) | def test_create_datetime():
  function test_timestamp_conversion (line 34) | def test_timestamp_conversion():
  function test_strftime_formatting (line 45) | def test_strftime_formatting():
  function test_strptime_parsing (line 56) | def test_strptime_parsing():
  function test_timedelta_arithmetic (line 68) | def test_timedelta_arithmetic():
  function test_timezone_operations (line 87) | def test_timezone_operations():
  function test_date_comparison (line 102) | def test_date_comparison():
  function test_weekday_operations (line 118) | def test_weekday_operations():
  function test_start_end_of_day (line 132) | def test_start_end_of_day():
  function test_start_end_of_month (line 143) | def test_start_end_of_month():
  function test_calendar_operations (line 157) | def test_calendar_operations():
  function test_date_range (line 166) | def test_date_range():
  function test_age_calculation (line 183) | def test_age_calculation():
  function test_time_ago (line 205) | def test_time_ago():
  function test_business_days (line 232) | def test_business_days():

FILE: src/basic/dict.py
  function create_dict_literal (line 12) | def create_dict_literal():
  function create_dict_constructor (line 17) | def create_dict_constructor():
  function create_dict_comprehension (line 22) | def create_dict_comprehension(n: int) -> dict:
  function get_keys (line 28) | def get_keys(d: dict) -> list:
  function get_values (line 33) | def get_values(d: dict) -> list:
  function get_items (line 38) | def get_items(d: dict) -> list:
  function find_common_keys (line 44) | def find_common_keys(a: dict, b: dict) -> set:
  function setdefault_example (line 50) | def setdefault_example():
  function defaultdict_example (line 57) | def defaultdict_example():
  function merge_dicts_operator (line 65) | def merge_dicts_operator(a: dict, b: dict) -> dict:
  function merge_dicts_unpack (line 70) | def merge_dicts_unpack(a: dict, b: dict) -> dict:
  function dict_comprehension_filter (line 76) | def dict_comprehension_filter(n: int) -> dict:
  function swap_keys_values (line 81) | def swap_keys_values(d: dict) -> dict:
  class EmuDict (line 87) | class EmuDict:
    method __init__ (line 90) | def __init__(self, data=None):
    method __repr__ (line 93) | def __repr__(self):
    method __getitem__ (line 96) | def __getitem__(self, key):
    method __setitem__ (line 99) | def __setitem__(self, key, val):
    method __delitem__ (line 102) | def __delitem__(self, key):
    method __contains__ (line 105) | def __contains__(self, key):
    method __iter__ (line 108) | def __iter__(self):
    method __len__ (line 111) | def __len__(self):
  class LRUCache (line 116) | class LRUCache:
    method __init__ (line 119) | def __init__(self, maxsize=128):
    method get (line 123) | def get(self, key):
    method put (line 129) | def put(self, key, value):
  function fibonacci (line 138) | def fibonacci(n: int) -> int:
  class TestDictCreation (line 146) | class TestDictCreation:
    method test_literal (line 147) | def test_literal(self):
    method test_constructor (line 150) | def test_constructor(self):
    method test_comprehension (line 153) | def test_comprehension(self):
  class TestDictAccess (line 157) | class TestDictAccess:
    method test_get_keys (line 158) | def test_get_keys(self):
    method test_get_values (line 161) | def test_get_values(self):
    method test_get_items (line 164) | def test_get_items(self):
  class TestDictOperations (line 168) | class TestDictOperations:
    method test_find_common_keys (line 169) | def test_find_common_keys(self):
    method test_setdefault (line 172) | def test_setdefault(self):
    method test_defaultdict (line 175) | def test_defaultdict(self):
    method test_merge_operator (line 178) | def test_merge_operator(self):
    method test_merge_unpack (line 181) | def test_merge_unpack(self):
  class TestDictComprehension (line 185) | class TestDictComprehension:
    method test_filter (line 186) | def test_filter(self):
    method test_swap (line 189) | def test_swap(self):
  class TestEmuDict (line 193) | class TestEmuDict:
    method test_getitem (line 194) | def test_getitem(self):
    method test_setitem (line 198) | def test_setitem(self):
    method test_contains (line 203) | def test_contains(self):
    method test_len (line 208) | def test_len(self):
  class TestLRUCache (line 212) | class TestLRUCache:
    method test_get_put (line 213) | def test_get_put(self):
    method test_eviction (line 219) | def test_eviction(self):
    method test_fibonacci (line 226) | def test_fibonacci(self):

FILE: src/basic/fileio_.py
  function test_read_write_text (line 11) | def test_read_write_text(tmp_path):
  function test_read_lines (line 25) | def test_read_lines(tmp_path):
  function test_write_modes (line 38) | def test_write_modes(tmp_path):
  function test_binary_files (line 53) | def test_binary_files(tmp_path):
  function test_pathlib_properties (line 67) | def test_pathlib_properties(tmp_path):
  function test_pathlib_with_suffix (line 77) | def test_pathlib_with_suffix():
  function test_pathlib_read_write (line 85) | def test_pathlib_read_write(tmp_path):
  function test_pathlib_bytes (line 95) | def test_pathlib_bytes(tmp_path):
  function test_list_directory (line 106) | def test_list_directory(tmp_path):
  function test_glob_pattern (line 121) | def test_glob_pattern(tmp_path):
  function test_recursive_glob (line 131) | def test_recursive_glob(tmp_path):
  function test_mkdir_parents (line 142) | def test_mkdir_parents(tmp_path):
  function test_path_exists (line 151) | def test_path_exists(tmp_path):
  function test_temporary_file (line 168) | def test_temporary_file():
  function test_temporary_directory (line 179) | def test_temporary_directory():
  function test_csv_read_write (line 190) | def test_csv_read_write(tmp_path):
  function test_csv_dictreader (line 212) | def test_csv_dictreader(tmp_path):
  function test_json_read_write (line 225) | def test_json_read_write(tmp_path):
  function test_gzip_read_write (line 239) | def test_gzip_read_write(tmp_path):
  function test_zipfile_create_extract (line 253) | def test_zipfile_create_extract(tmp_path):
  function test_symlink (line 280) | def test_symlink(tmp_path):
  function test_file_stat (line 293) | def test_file_stat(tmp_path):
  function test_shutil_copy (line 303) | def test_shutil_copy(tmp_path):
  function test_shutil_copytree (line 327) | def test_shutil_copytree(tmp_path):
  function test_shutil_copytree_ignore (line 346) | def test_shutil_copytree_ignore(tmp_path):
  function test_shutil_copytree_dirs_exist_ok (line 362) | def test_shutil_copytree_dirs_exist_ok(tmp_path):
  function test_shutil_move (line 380) | def test_shutil_move(tmp_path):
  function test_shutil_rmtree (line 400) | def test_shutil_rmtree(tmp_path):
  function test_shutil_disk_usage (line 414) | def test_shutil_disk_usage(tmp_path):
  function test_shutil_which (line 424) | def test_shutil_which():
  function test_shutil_make_archive (line 435) | def test_shutil_make_archive(tmp_path):
  function test_shutil_unpack_archive (line 450) | def test_shutil_unpack_archive(tmp_path):

FILE: src/basic/func.py
  function greet (line 12) | def greet(name: str, greeting: str = "Hello") -> str:
  function good_default (line 17) | def good_default(items=None):
  function sum_all (line 26) | def sum_all(*args) -> int:
  function format_info (line 31) | def format_info(**kwargs) -> str:
  function mixed_args (line 36) | def mixed_args(a, b=None, *args, **kwargs):
  function keyword_only (line 42) | def keyword_only(a, b, *, kw):
  function keyword_only_default (line 47) | def keyword_only_default(a, *, kw=10):
  function positional_only (line 53) | def positional_only(a, b, /, c):
  function combined_args (line 58) | def combined_args(a, /, b, *, c):
  function make_multiplier (line 70) | def make_multiplier(n: int):
  function make_counter (line 79) | def make_counter():
  function fibonacci (line 92) | def fibonacci(n: int):
  function log_calls (line 101) | def log_calls(func):
  function repeat (line 114) | def repeat(times: int):
  class CountCalls (line 131) | class CountCalls:
    method __init__ (line 134) | def __init__(self, func):
    method __call__ (line 139) | def __call__(self, *args, **kwargs):
  function fib_cached (line 146) | def fib_cached(n: int) -> int:
  function power (line 154) | def power(base: int, exponent: int) -> int:
  function process (line 165) | def process(arg):
  function _ (line 171) | def _(arg):
  function _ (line 176) | def _(arg):
  class Adder (line 181) | class Adder:
    method __init__ (line 184) | def __init__(self, n: int):
    method __call__ (line 187) | def __call__(self, x: int) -> int:
  function apply_twice (line 192) | def apply_twice(func, x):
  class TestDefaultArguments (line 198) | class TestDefaultArguments:
    method test_default (line 199) | def test_default(self):
    method test_custom (line 202) | def test_custom(self):
    method test_mutable_default (line 205) | def test_mutable_default(self):
  class TestVariableArguments (line 210) | class TestVariableArguments:
    method test_args (line 211) | def test_args(self):
    method test_kwargs (line 214) | def test_kwargs(self):
    method test_mixed (line 219) | def test_mixed(self):
  class TestKeywordOnly (line 227) | class TestKeywordOnly:
    method test_keyword_only (line 228) | def test_keyword_only(self):
    method test_keyword_only_default (line 231) | def test_keyword_only_default(self):
  class TestPositionalOnly (line 236) | class TestPositionalOnly:
    method test_positional_only (line 237) | def test_positional_only(self):
    method test_combined (line 241) | def test_combined(self):
  class TestLambda (line 246) | class TestLambda:
    method test_square (line 247) | def test_square(self):
    method test_add (line 250) | def test_add(self):
    method test_conditional (line 253) | def test_conditional(self):
  class TestClosure (line 258) | class TestClosure:
    method test_multiplier (line 259) | def test_multiplier(self):
    method test_counter (line 265) | def test_counter(self):
  class TestGenerator (line 272) | class TestGenerator:
    method test_fibonacci (line 273) | def test_fibonacci(self):
  class TestDecorator (line 277) | class TestDecorator:
    method test_log_calls (line 278) | def test_log_calls(self):
    method test_repeat (line 288) | def test_repeat(self):
  class TestClassDecorator (line 299) | class TestClassDecorator:
    method test_count_calls (line 300) | def test_count_calls(self):
  class TestCache (line 310) | class TestCache:
    method test_fib_cached (line 311) | def test_fib_cached(self):
  class TestPartial (line 319) | class TestPartial:
    method test_square (line 320) | def test_square(self):
    method test_cube (line 323) | def test_cube(self):
  class TestSingledispatch (line 327) | class TestSingledispatch:
    method test_default (line 328) | def test_default(self):
    method test_int (line 331) | def test_int(self):
    method test_list (line 334) | def test_list(self):
  class TestCallable (line 338) | class TestCallable:
    method test_adder (line 339) | def test_adder(self):
  class TestHigherOrder (line 345) | class TestHigherOrder:
    method test_apply_twice (line 346) | def test_apply_twice(self):
    method test_map (line 349) | def test_map(self):
    method test_filter (line 352) | def test_filter(self):
    method test_reduce (line 355) | def test_reduce(self):

FILE: src/basic/future_.py
  function get_all_features (line 13) | def get_all_features() -> list[str]:
  function get_feature_info (line 18) | def get_feature_info(name: str) -> tuple:
  class Node (line 27) | class Node:
    method __init__ (line 30) | def __init__(self, value: int, next: Node | None = None):
    method append (line 34) | def append(self, value: int) -> Node:
  function get_annotations (line 41) | def get_annotations(func) -> dict:
  function true_division (line 47) | def true_division(a: int, b: int) -> float:
  function floor_division (line 52) | def floor_division(a: int, b: int) -> int:
  function check_version (line 58) | def check_version(major: int, minor: int) -> bool:
  function get_version_string (line 63) | def get_version_string() -> str:
  class TestFutureFeatures (line 69) | class TestFutureFeatures:
    method test_get_all_features (line 70) | def test_get_all_features(self):
    method test_get_feature_info (line 76) | def test_get_feature_info(self):
  class TestAnnotations (line 82) | class TestAnnotations:
    method test_node_creation (line 83) | def test_node_creation(self):
    method test_node_append (line 88) | def test_node_append(self):
    method test_annotations_are_strings (line 94) | def test_annotations_are_strings(self):
  class TestDivision (line 102) | class TestDivision:
    method test_true_division (line 103) | def test_true_division(self):
    method test_floor_division (line 107) | def test_floor_division(self):
  class TestVersionCheck (line 112) | class TestVersionCheck:
    method test_check_version (line 113) | def test_check_version(self):
    method test_get_version_string (line 119) | def test_get_version_string(self):

FILE: src/basic/generator.py
  function simple_gen (line 14) | def simple_gen():
  function countdown (line 21) | def countdown(n: int):
  function fibonacci (line 28) | def fibonacci(n: int):
  function infinite_counter (line 36) | def infinite_counter(start: int = 0):
  function gen_expr_sum (line 45) | def gen_expr_sum(n: int) -> int:
  function accumulator (line 51) | def accumulator():
  function average (line 61) | def average():
  function chain (line 75) | def chain(*iterables):
  function flatten (line 81) | def flatten(nested):
  class Range (line 91) | class Range:
    method __init__ (line 94) | def __init__(self, start: int, end: int):
    method __iter__ (line 98) | def __iter__(self):
    method __reversed__ (line 104) | def __reversed__(self):
  function filter_positive (line 112) | def filter_positive(nums):
  function double (line 119) | def double(nums):
  function read_lines (line 125) | def read_lines(lines):
  function filter_comments (line 131) | def filter_comments(lines):
  function gen_with_exception (line 139) | def gen_with_exception():
  function gen_with_cleanup (line 148) | def gen_with_cleanup():
  function capture_output (line 159) | def capture_output():
  class TestGeneratorBasics (line 166) | class TestGeneratorBasics:
    method test_simple_gen (line 167) | def test_simple_gen(self):
    method test_countdown (line 170) | def test_countdown(self):
    method test_fibonacci (line 173) | def test_fibonacci(self):
    method test_infinite_counter (line 176) | def test_infinite_counter(self):
  class TestGeneratorExpression (line 183) | class TestGeneratorExpression:
    method test_gen_expr_sum (line 184) | def test_gen_expr_sum(self):
    method test_unpack (line 187) | def test_unpack(self):
    method test_unpack_multiple (line 191) | def test_unpack_multiple(self):
  class TestSend (line 197) | class TestSend:
    method test_accumulator (line 198) | def test_accumulator(self):
  class TestGeneratorReturn (line 206) | class TestGeneratorReturn:
    method test_average (line 207) | def test_average(self):
  class TestYieldFrom (line 219) | class TestYieldFrom:
    method test_chain (line 220) | def test_chain(self):
    method test_flatten (line 223) | def test_flatten(self):
  class TestIterableClass (line 227) | class TestIterableClass:
    method test_range (line 228) | def test_range(self):
    method test_reversed_range (line 231) | def test_reversed_range(self):
  class TestPipeline (line 235) | class TestPipeline:
    method test_pipeline (line 236) | def test_pipeline(self):
    method test_text_pipeline (line 241) | def test_text_pipeline(self):
  class TestThrowClose (line 247) | class TestThrowClose:
    method test_throw (line 248) | def test_throw(self):
    method test_close (line 253) | def test_close(self):
  class TestGeneratorState (line 259) | class TestGeneratorState:
    method test_states (line 260) | def test_states(self):
  class TestGeneratorType (line 275) | class TestGeneratorType:
    method test_isinstance (line 276) | def test_isinstance(self):
  class TestContextManager (line 284) | class TestContextManager:
    method test_capture (line 285) | def test_capture(self):
  function prime (line 292) | def prime(n: int):
  function closure_gen (line 306) | def closure_gen(start: int = 0):
  function fib (line 315) | def fib(n: int) -> int:
  function g_fib (line 322) | def g_fib(n: int):
  function run_scheduler (line 328) | def run_scheduler(tasks: list) -> list:
  function tokenize (line 351) | def tokenize(text: str):
  class Node (line 370) | class Node:
    method __init__ (line 373) | def __init__(self, *args):
  class Number (line 378) | class Number(Node):
  class BinOp (line 382) | class BinOp(Node):
  function parse (line 386) | def parse(toks):
  class NodeVisitor (line 421) | class NodeVisitor:
    method visit (line 424) | def visit(self, node):
    method genvisit (line 437) | def genvisit(self, node):
  class Evaluator (line 444) | class Evaluator(NodeVisitor):
    method visit_Number (line 447) | def visit_Number(self, node):
    method visit_BinOp (line 450) | def visit_BinOp(self, node):
  function evaluate (line 462) | def evaluate(exp: str):
  class AsyncIter (line 470) | class AsyncIter:
    method __init__ (line 473) | def __init__(self, n):
    method __aiter__ (line 476) | def __aiter__(self):
    method __anext__ (line 479) | async def __anext__(self):
  function agen (line 486) | async def agen(n: int):
  class TestPrime (line 493) | class TestPrime:
    method test_prime (line 494) | def test_prime(self):
  class TestClosure (line 498) | class TestClosure:
    method test_closure_gen (line 499) | def test_closure_gen(self):
  class TestScheduler (line 506) | class TestScheduler:
    method test_round_robin (line 507) | def test_round_robin(self):
  class TestCompiler (line 512) | class TestCompiler:
    method test_tokenize (line 513) | def test_tokenize(self):
    method test_evaluate_simple (line 519) | def test_evaluate_simple(self):
    method test_evaluate_complex (line 525) | def test_evaluate_complex(self):
  class TestAsyncGen (line 531) | class TestAsyncGen:
    method test_async_iter (line 532) | def test_async_iter(self):
    method test_async_iter_class (line 540) | def test_async_iter_class(self):

FILE: src/basic/heap.py
  function heapify_list (line 12) | def heapify_list(items: list) -> list:
  function heap_push (line 19) | def heap_push(h: list, item) -> list:
  function heap_pop (line 25) | def heap_pop(h: list):
  function heap_pushpop (line 30) | def heap_pushpop(h: list, item):
  function heap_replace (line 35) | def heap_replace(h: list, item):
  function heap_sort (line 41) | def heap_sort(items: list) -> list:
  function max_heap_sort (line 49) | def max_heap_sort(items: list) -> list:
  class MaxHeapItem (line 56) | class MaxHeapItem:
    method __init__ (line 59) | def __init__(self, val):
    method __lt__ (line 62) | def __lt__(self, other):
  function priority_queue_example (line 67) | def priority_queue_example():
  class Task (line 77) | class Task:
    method __init__ (line 80) | def __init__(self, priority: int, name: str):
    method __lt__ (line 84) | def __lt__(self, other):
    method __repr__ (line 87) | def __repr__(self):
  function task_queue (line 91) | def task_queue():
  function k_smallest (line 101) | def k_smallest(items: list, k: int) -> list:
  function k_largest (line 106) | def k_largest(items: list, k: int) -> list:
  function k_largest_by_key (line 111) | def k_largest_by_key(items: list, k: int, key) -> list:
  function merge_sorted (line 117) | def merge_sorted(*iterables) -> list:
  function merge_sorted_reverse (line 122) | def merge_sorted_reverse(*iterables) -> list:
  function top_k (line 128) | def top_k(items: list, k: int) -> list:
  class IndexedHeap (line 140) | class IndexedHeap:
    method __init__ (line 145) | def __init__(self):
    method push (line 149) | def push(self, item, priority):
    method remove (line 156) | def remove(self, item):
    method pop (line 160) | def pop(self):
  class TestBasicHeap (line 170) | class TestBasicHeap:
    method test_heapify (line 171) | def test_heapify(self):
    method test_push_pop (line 175) | def test_push_pop(self):
    method test_pushpop (line 183) | def test_pushpop(self):
    method test_replace (line 188) | def test_replace(self):
  class TestHeapSort (line 195) | class TestHeapSort:
    method test_sort (line 196) | def test_sort(self):
    method test_max_sort (line 199) | def test_max_sort(self):
  class TestPriorityQueue (line 203) | class TestPriorityQueue:
    method test_priority_order (line 204) | def test_priority_order(self):
  class TestCustomObjects (line 211) | class TestCustomObjects:
    method test_max_heap_item (line 212) | def test_max_heap_item(self):
    method test_task_queue (line 218) | def test_task_queue(self):
  class TestKElements (line 225) | class TestKElements:
    method test_k_smallest (line 226) | def test_k_smallest(self):
    method test_k_largest (line 229) | def test_k_largest(self):
    method test_k_largest_by_key (line 232) | def test_k_largest_by_key(self):
  class TestMerge (line 239) | class TestMerge:
    method test_merge_sorted (line 240) | def test_merge_sorted(self):
    method test_merge_three (line 243) | def test_merge_three(self):
    method test_merge_reverse (line 246) | def test_merge_reverse(self):
  class TestTopK (line 250) | class TestTopK:
    method test_top_k (line 251) | def test_top_k(self):
  class TestIndexedHeap (line 255) | class TestIndexedHeap:
    method test_push_pop (line 256) | def test_push_pop(self):
    method test_update_priority (line 263) | def test_update_priority(self):

FILE: src/basic/list.py
  function init_immutable (line 16) | def init_immutable(n: int) -> list:
  function init_mutable (line 21) | def init_mutable(n: int) -> list:
  function shallow_copy (line 27) | def shallow_copy(lst: list) -> list:
  function deep_copy (line 32) | def deep_copy(lst: list) -> list:
  function squares (line 38) | def squares(n: int) -> list:
  function filter_even (line 43) | def filter_even(nums: list) -> list:
  function flatten (line 48) | def flatten(nested: list) -> list:
  function extended_unpack (line 54) | def extended_unpack(lst: list) -> tuple:
  function enumerate_example (line 61) | def enumerate_example(items: list) -> list:
  function zip_to_dict (line 66) | def zip_to_dict(keys: list, values: list) -> dict:
  function unzip (line 71) | def unzip(pairs: list) -> tuple:
  function sort_by_key (line 77) | def sort_by_key(items: list, key_func) -> list:
  function sort_dicts (line 82) | def sort_dicts(dicts: list, key: str) -> list:
  class Stack (line 88) | class Stack:
    method __init__ (line 91) | def __init__(self):
    method push (line 94) | def push(self, item):
    method pop (line 97) | def pop(self):
    method peek (line 100) | def peek(self):
    method is_empty (line 103) | def is_empty(self):
    method __len__ (line 106) | def __len__(self):
  class TestInitialize (line 111) | class TestInitialize:
    method test_immutable (line 112) | def test_immutable(self):
    method test_mutable (line 117) | def test_mutable(self):
  class TestCopy (line 123) | class TestCopy:
    method test_shallow (line 124) | def test_shallow(self):
    method test_deep (line 130) | def test_deep(self):
  class TestComprehensions (line 137) | class TestComprehensions:
    method test_squares (line 138) | def test_squares(self):
    method test_filter_even (line 141) | def test_filter_even(self):
    method test_flatten (line 144) | def test_flatten(self):
  class TestUnpacking (line 148) | class TestUnpacking:
    method test_extended (line 149) | def test_extended(self):
  class TestEnumerateZip (line 156) | class TestEnumerateZip:
    method test_enumerate (line 157) | def test_enumerate(self):
    method test_zip_to_dict (line 160) | def test_zip_to_dict(self):
    method test_unzip (line 163) | def test_unzip(self):
  class TestSorting (line 169) | class TestSorting:
    method test_sort_by_key (line 170) | def test_sort_by_key(self):
    method test_sort_dicts (line 173) | def test_sort_dicts(self):
  class TestStack (line 178) | class TestStack:
    method test_push_pop (line 179) | def test_push_pop(self):
    method test_peek (line 186) | def test_peek(self):
    method test_is_empty (line 192) | def test_is_empty(self):
  function bisect_insort (line 200) | def bisect_insort(items: list) -> list:
  function bisect_left_example (line 208) | def bisect_left_example(lst: list, x) -> int:
  function bisect_right_example (line 213) | def bisect_right_example(lst: list, x) -> int:
  function binary_search (line 218) | def binary_search(arr: list, x, lo: int = 0, hi: int = None) -> int:
  function create_2d_list (line 227) | def create_2d_list(rows: int, cols: int) -> list:
  function circular_buffer (line 233) | def circular_buffer(items: list, maxlen: int) -> deque:
  function chunk (line 242) | def chunk(lst: list, n: int) -> list:
  function groupby_example (line 248) | def groupby_example(s: str) -> list:
  function create_trie (line 254) | def create_trie(words: list) -> dict:
  function trie_has_prefix (line 264) | def trie_has_prefix(trie: dict, prefix: str) -> bool:
  class TestBisect (line 274) | class TestBisect:
    method test_insort (line 275) | def test_insort(self):
    method test_bisect_left (line 278) | def test_bisect_left(self):
    method test_bisect_right (line 282) | def test_bisect_right(self):
    method test_binary_search (line 286) | def test_binary_search(self):
  class TestNestedLists (line 293) | class TestNestedLists:
    method test_create_2d (line 294) | def test_create_2d(self):
  class TestDeque (line 300) | class TestDeque:
    method test_circular_buffer (line 301) | def test_circular_buffer(self):
  class TestChunk (line 306) | class TestChunk:
    method test_chunk (line 307) | def test_chunk(self):
  class TestGroupby (line 315) | class TestGroupby:
    method test_groupby (line 316) | def test_groupby(self):
  class TestTrie (line 325) | class TestTrie:
    method test_create_and_search (line 326) | def test_create_and_search(self):

FILE: src/basic/object.py
  class Person (line 13) | class Person:
    method __init__ (line 16) | def __init__(self, name: str, age: int):
    method greet (line 20) | def greet(self) -> str:
  class Counter (line 25) | class Counter:
    method __init__ (line 30) | def __init__(self):
  class Animal (line 36) | class Animal:
    method __init__ (line 39) | def __init__(self, name: str):
    method speak (line 42) | def speak(self) -> str:
  class Dog (line 46) | class Dog(Animal):
    method speak (line 47) | def speak(self) -> str:
  class Cat (line 51) | class Cat(Animal):
    method speak (line 52) | def speak(self) -> str:
  class Vector (line 57) | class Vector:
    method __init__ (line 60) | def __init__(self, x: int, y: int):
    method __repr__ (line 63) | def __repr__(self):
    method __str__ (line 66) | def __str__(self):
    method __add__ (line 69) | def __add__(self, other):
    method __mul__ (line 72) | def __mul__(self, scalar):
    method __eq__ (line 75) | def __eq__(self, other):
  class Number (line 81) | class Number:
    method __init__ (line 84) | def __init__(self, val):
    method __eq__ (line 87) | def __eq__(self, other):
    method __lt__ (line 90) | def __lt__(self, other):
  class Multiplier (line 95) | class Multiplier:
    method __init__ (line 98) | def __init__(self, factor: int):
    method __call__ (line 101) | def __call__(self, x: int) -> int:
  class Circle (line 106) | class Circle:
    method __init__ (line 109) | def __init__(self, radius: float):
    method radius (line 113) | def radius(self) -> float:
    method radius (line 117) | def radius(self, value: float):
    method area (line 123) | def area(self) -> float:
  class Positive (line 128) | class Positive:
    method __init__ (line 131) | def __init__(self, name):
    method __get__ (line 134) | def __get__(self, obj, objtype=None):
    method __set__ (line 139) | def __set__(self, obj, value):
  class DescriptorExample (line 145) | class DescriptorExample:
    method __init__ (line 148) | def __init__(self, x):
  class ManagedResource (line 153) | class ManagedResource:
    method __init__ (line 156) | def __init__(self):
    method __enter__ (line 160) | def __enter__(self):
    method __exit__ (line 164) | def __exit__(self, exc_type, exc_val, exc_tb):
  class Singleton (line 170) | class Singleton:
    method __new__ (line 175) | def __new__(cls):
  class Date (line 182) | class Date:
    method __init__ (line 185) | def __init__(self, year: int, month: int, day: int):
    method from_string (line 189) | def from_string(cls, date_string: str):
    method is_valid (line 194) | def is_valid(date_string: str) -> bool:
  class Shape (line 203) | class Shape(ABC):
    method area (line 207) | def area(self) -> float:
  class Rectangle (line 211) | class Rectangle(Shape):
    method __init__ (line 212) | def __init__(self, width: float, height: float):
    method area (line 215) | def area(self) -> float:
  class A (line 220) | class A:
    method method (line 221) | def method(self):
  class B (line 225) | class B(A):
    method method (line 226) | def method(self):
  class C (line 230) | class C(A):
    method method (line 231) | def method(self):
  class D (line 235) | class D(B, C):
  class PointWithSlots (line 240) | class PointWithSlots:
    method __init__ (line 245) | def __init__(self, x, y):
  class TestBasicClass (line 250) | class TestBasicClass:
    method test_person (line 251) | def test_person(self):
  class TestClassAttributes (line 257) | class TestClassAttributes:
    method test_counter (line 258) | def test_counter(self):
  class TestInheritance (line 266) | class TestInheritance:
    method test_dog (line 267) | def test_dog(self):
    method test_cat (line 270) | def test_cat(self):
  class TestMagicMethods (line 274) | class TestMagicMethods:
    method test_vector_add (line 275) | def test_vector_add(self):
    method test_vector_mul (line 280) | def test_vector_mul(self):
    method test_vector_repr (line 284) | def test_vector_repr(self):
    method test_vector_str (line 287) | def test_vector_str(self):
  class TestComparison (line 291) | class TestComparison:
    method test_total_ordering (line 292) | def test_total_ordering(self):
  class TestCallable (line 300) | class TestCallable:
    method test_multiplier (line 301) | def test_multiplier(self):
  class TestProperty (line 307) | class TestProperty:
    method test_circle_area (line 308) | def test_circle_area(self):
    method test_circle_setter (line 312) | def test_circle_setter(self):
    method test_circle_invalid (line 317) | def test_circle_invalid(self):
  class TestDescriptor (line 323) | class TestDescriptor:
    method test_positive (line 324) | def test_positive(self):
    method test_positive_invalid (line 328) | def test_positive_invalid(self):
  class TestContextManager (line 333) | class TestContextManager:
    method test_managed_resource (line 334) | def test_managed_resource(self):
  class TestSingleton (line 340) | class TestSingleton:
    method test_singleton (line 341) | def test_singleton(self):
  class TestClassMethods (line 348) | class TestClassMethods:
    method test_from_string (line 349) | def test_from_string(self):
    method test_is_valid (line 354) | def test_is_valid(self):
  class TestABC (line 359) | class TestABC:
    method test_rectangle (line 360) | def test_rectangle(self):
    method test_abstract_instantiation (line 364) | def test_abstract_instantiation(self):
  class TestMRO (line 369) | class TestMRO:
    method test_diamond (line 370) | def test_diamond(self):
    method test_mro (line 373) | def test_mro(self):
  class TestSlots (line 377) | class TestSlots:
    method test_slots (line 378) | def test_slots(self):
    method test_slots_no_dict (line 383) | def test_slots_no_dict(self):

FILE: src/basic/os_.py
  class TestSystemInfo (line 17) | class TestSystemInfo:
    method test_os_name (line 20) | def test_os_name(self):
    method test_platform_system (line 24) | def test_platform_system(self):
    method test_cpu_count (line 28) | def test_cpu_count(self):
    method test_getpid (line 34) | def test_getpid(self):
    method test_getcwd (line 39) | def test_getcwd(self):
  class TestEnvironmentVariables (line 45) | class TestEnvironmentVariables:
    method test_get_env (line 48) | def test_get_env(self):
    method test_getenv_default (line 54) | def test_getenv_default(self):
    method test_set_env (line 59) | def test_set_env(self):
    method test_env_not_found (line 65) | def test_env_not_found(self):
  class TestPathOperations (line 71) | class TestPathOperations:
    method test_join (line 74) | def test_join(self):
    method test_dirname_basename (line 81) | def test_dirname_basename(self):
    method test_splitext (line 87) | def test_splitext(self):
    method test_abspath (line 93) | def test_abspath(self):
    method test_exists (line 98) | def test_exists(self):
    method test_isfile_isdir (line 103) | def test_isfile_isdir(self):
  class TestDirectoryOperations (line 111) | class TestDirectoryOperations:
    method test_mkdir_rmdir (line 114) | def test_mkdir_rmdir(self):
    method test_makedirs (line 123) | def test_makedirs(self):
    method test_makedirs_exist_ok (line 130) | def test_makedirs_exist_ok(self):
    method test_listdir (line 135) | def test_listdir(self):
    method test_walk (line 145) | def test_walk(self):
  class TestFileOperations (line 162) | class TestFileOperations:
    method test_rename (line 165) | def test_rename(self):
    method test_remove (line 175) | def test_remove(self):
    method test_getsize (line 183) | def test_getsize(self):
  class TestSubprocess (line 195) | class TestSubprocess:
    method test_run_simple (line 198) | def test_run_simple(self):
    method test_check_output (line 206) | def test_check_output(self):
    method test_run_with_input (line 211) | def test_run_with_input(self):
  class TestTempFiles (line 219) | class TestTempFiles:
    method test_named_temp_file (line 222) | def test_named_temp_file(self):
    method test_temp_directory (line 230) | def test_temp_directory(self):
    method test_gettempdir (line 241) | def test_gettempdir(self):
  class TestPathlib (line 247) | class TestPathlib:
    method test_path_creation (line 250) | def test_path_creation(self):
    method test_path_join (line 257) | def test_path_join(self):
    method test_path_parent (line 262) | def test_path_parent(self):
    method test_path_exists (line 267) | def test_path_exists(self):
    method test_read_write_text (line 272) | def test_read_write_text(self):
    method test_mkdir (line 279) | def test_mkdir(self):
    method test_glob (line 286) | def test_glob(self):
    method test_iterdir (line 296) | def test_iterdir(self):
  class TestPsutil (line 306) | class TestPsutil:
    method psutil_available (line 310) | def psutil_available(self):
    method test_cpu_count (line 319) | def test_cpu_count(self, psutil_available):
    method test_cpu_percent (line 328) | def test_cpu_percent(self, psutil_available):
    method test_virtual_memory (line 334) | def test_virtual_memory(self, psutil_available):
    method test_disk_usage (line 342) | def test_disk_usage(self, psutil_available):
    method test_process (line 350) | def test_process(self, psutil_available):
    method test_boot_time (line 358) | def test_boot_time(self, psutil_available):

FILE: src/basic/rexp.py
  function search_pattern (line 13) | def search_pattern(pattern: str, text: str) -> str | None:
  function match_start (line 19) | def match_start(pattern: str, text: str) -> bool:
  function fullmatch (line 24) | def fullmatch(pattern: str, text: str) -> bool:
  function find_all (line 30) | def find_all(pattern: str, text: str) -> list:
  function find_all_groups (line 35) | def find_all_groups(pattern: str, text: str) -> list:
  function split_pattern (line 41) | def split_pattern(pattern: str, text: str) -> list:
  function parse_date (line 47) | def parse_date(text: str) -> dict | None:
  function parse_date_named (line 55) | def parse_date_named(text: str) -> dict | None:
  function parse_url (line 63) | def parse_url(url: str) -> tuple | None:
  function has_repeated_char (line 70) | def has_repeated_char(text: str) -> bool:
  function match_html_tag (line 75) | def match_html_tag(text: str) -> str | None:
  function find_before_at (line 82) | def find_before_at(text: str) -> list:
  function find_after_dollar (line 87) | def find_after_dollar(text: str) -> list:
  function find_not_followed_by (line 92) | def find_not_followed_by(text: str, suffix: str) -> list:
  function replace_pattern (line 98) | def replace_pattern(pattern: str, repl: str, text: str) -> str:
  function double_numbers (line 103) | def double_numbers(text: str) -> str:
  function camel_to_snake (line 108) | def camel_to_snake(s: str) -> str:
  function is_valid_email (line 133) | def is_valid_email(text: str) -> bool:
  function is_valid_ip (line 138) | def is_valid_ip(text: str) -> bool:
  function is_valid_mac (line 143) | def is_valid_mac(text: str) -> bool:
  function is_valid_url (line 148) | def is_valid_url(text: str) -> bool:
  function is_valid_hex_color (line 153) | def is_valid_hex_color(text: str) -> bool:
  function is_valid_phone (line 158) | def is_valid_phone(text: str) -> bool:
  function is_strong_password (line 163) | def is_strong_password(text: str) -> bool:
  function find_open_tags (line 169) | def find_open_tags(html: str) -> list:
  function find_close_tags (line 174) | def find_close_tags(html: str) -> list:
  function strip_html_tags (line 179) | def strip_html_tags(html: str) -> str:
  function tokenize (line 188) | def tokenize(text: str) -> list:
  function find_hashtags (line 208) | def find_hashtags(text: str) -> list:
  function find_mentions (line 213) | def find_mentions(text: str) -> list:
  function extract_domain (line 218) | def extract_domain(url: str) -> str | None:
  class TestBasicMatching (line 225) | class TestBasicMatching:
    method test_search (line 226) | def test_search(self):
    method test_match_start (line 230) | def test_match_start(self):
    method test_fullmatch (line 234) | def test_fullmatch(self):
  class TestFindAll (line 239) | class TestFindAll:
    method test_find_all (line 240) | def test_find_all(self):
    method test_find_all_groups (line 243) | def test_find_all_groups(self):
  class TestSplit (line 250) | class TestSplit:
    method test_split (line 251) | def test_split(self):
  class TestGroups (line 256) | class TestGroups:
    method test_parse_date (line 257) | def test_parse_date(self):
    method test_parse_date_named (line 261) | def test_parse_date_named(self):
    method test_parse_url (line 265) | def test_parse_url(self):
  class TestBackReference (line 269) | class TestBackReference:
    method test_repeated_char (line 270) | def test_repeated_char(self):
    method test_html_tag (line 274) | def test_html_tag(self):
  class TestLookaround (line 279) | class TestLookaround:
    method test_lookahead (line 280) | def test_lookahead(self):
    method test_lookbehind (line 283) | def test_lookbehind(self):
    method test_negative_lookahead (line 286) | def test_negative_lookahead(self):
  class TestSubstitution (line 290) | class TestSubstitution:
    method test_replace (line 291) | def test_replace(self):
    method test_double_numbers (line 294) | def test_double_numbers(self):
    method test_camel_to_snake (line 297) | def test_camel_to_snake(self):
  class TestValidation (line 302) | class TestValidation:
    method test_email (line 303) | def test_email(self):
    method test_ip (line 308) | def test_ip(self):
    method test_mac (line 313) | def test_mac(self):
    method test_url (line 317) | def test_url(self):
    method test_hex_color (line 321) | def test_hex_color(self):
    method test_phone (line 326) | def test_phone(self):
    method test_password (line 330) | def test_password(self):
  class TestHtmlTags (line 335) | class TestHtmlTags:
    method test_open_tags (line 336) | def test_open_tags(self):
    method test_close_tags (line 339) | def test_close_tags(self):
    method test_strip_tags (line 342) | def test_strip_tags(self):
  class TestLexer (line 346) | class TestLexer:
    method test_tokenize (line 347) | def test_tokenize(self):
  class TestUtility (line 354) | class TestUtility:
    method test_hashtags (line 355) | def test_hashtags(self):
    method test_mentions (line 358) | def test_mentions(self):
    method test_extract_domain (line 361) | def test_extract_domain(self):

FILE: src/basic/set.py
  function create_set_literal (line 10) | def create_set_literal():
  function create_set_from_list (line 15) | def create_set_from_list(items: list) -> set:
  function create_empty_set (line 20) | def create_empty_set() -> set:
  function set_comprehension_basic (line 26) | def set_comprehension_basic(items: list) -> set:
  function set_comprehension_filter (line 31) | def set_comprehension_filter(items: list, threshold: int) -> set:
  function set_comprehension_squares (line 36) | def set_comprehension_squares(n: int) -> set:
  function uniquify_list (line 42) | def uniquify_list(items: list) -> list:
  function uniquify_preserve_order (line 47) | def uniquify_preserve_order(items: list) -> list:
  function add_single (line 53) | def add_single(s: set, item) -> set:
  function add_multiple (line 59) | def add_multiple(s: set, items) -> set:
  function remove_item (line 66) | def remove_item(s: set, item) -> set:
  function discard_item (line 72) | def discard_item(s: set, item) -> set:
  function pop_item (line 78) | def pop_item(s: set):
  function union (line 84) | def union(a: set, b: set) -> set:
  function intersection (line 89) | def intersection(a: set, b: set) -> set:
  function difference (line 94) | def difference(a: set, b: set) -> set:
  function symmetric_difference (line 99) | def symmetric_difference(a: set, b: set) -> set:
  function is_subset (line 104) | def is_subset(a: set, b: set) -> bool:
  function is_proper_subset (line 109) | def is_proper_subset(a: set, b: set) -> bool:
  function is_superset (line 114) | def is_superset(a: set, b: set) -> bool:
  function is_disjoint (line 119) | def is_disjoint(a: set, b: set) -> bool:
  function membership_test (line 125) | def membership_test(s: set, item) -> bool:
  function create_frozenset (line 131) | def create_frozenset(items: list) -> frozenset:
  function frozenset_as_dict_key (line 136) | def frozenset_as_dict_key():
  function frozenset_in_set (line 141) | def frozenset_in_set():
  class TestSetCreation (line 147) | class TestSetCreation:
    method test_literal (line 148) | def test_literal(self):
    method test_from_list (line 151) | def test_from_list(self):
    method test_empty (line 154) | def test_empty(self):
  class TestSetComprehension (line 159) | class TestSetComprehension:
    method test_basic (line 160) | def test_basic(self):
    method test_filter (line 163) | def test_filter(self):
    method test_squares (line 166) | def test_squares(self):
  class TestUniquify (line 170) | class TestUniquify:
    method test_uniquify (line 171) | def test_uniquify(self):
    method test_preserve_order (line 175) | def test_preserve_order(self):
  class TestAddRemove (line 179) | class TestAddRemove:
    method test_add_single (line 180) | def test_add_single(self):
    method test_add_multiple (line 184) | def test_add_multiple(self):
    method test_remove (line 188) | def test_remove(self):
    method test_remove_missing (line 192) | def test_remove_missing(self):
    method test_discard (line 197) | def test_discard(self):
    method test_pop (line 202) | def test_pop(self):
  class TestSetOperations (line 209) | class TestSetOperations:
    method test_union (line 210) | def test_union(self):
    method test_intersection (line 213) | def test_intersection(self):
    method test_difference (line 216) | def test_difference(self):
    method test_symmetric_difference (line 219) | def test_symmetric_difference(self):
    method test_subset (line 222) | def test_subset(self):
    method test_proper_subset (line 227) | def test_proper_subset(self):
    method test_superset (line 231) | def test_superset(self):
    method test_disjoint (line 235) | def test_disjoint(self):
  class TestMembership (line 240) | class TestMembership:
    method test_in (line 241) | def test_in(self):
  class TestFrozenset (line 246) | class TestFrozenset:
    method test_create (line 247) | def test_create(self):
    method test_immutable (line 251) | def test_immutable(self):
    method test_as_dict_key (line 255) | def test_as_dict_key(self):
    method test_in_set (line 259) | def test_in_set(self):

FILE: src/basic/socket_.py
  class TestHostname (line 9) | class TestHostname:
    method test_gethostname (line 12) | def test_gethostname(self):
    method test_gethostbyname_localhost (line 17) | def test_gethostbyname_localhost(self):
    method test_getaddrinfo (line 21) | def test_getaddrinfo(self):
  class TestByteOrder (line 30) | class TestByteOrder:
    method test_htons (line 33) | def test_htons(self):
    method test_htonl (line 39) | def test_htonl(self):
    method test_ntohs (line 44) | def test_ntohs(self):
    method test_ntohl (line 49) | def test_ntohl(self):
  class TestIPConversion (line 55) | class TestIPConversion:
    method test_inet_aton (line 58) | def test_inet_aton(self):
    method test_inet_ntoa (line 62) | def test_inet_ntoa(self):
    method test_inet_pton_ipv4 (line 66) | def test_inet_pton_ipv4(self):
    method test_inet_ntop_ipv4 (line 70) | def test_inet_ntop_ipv4(self):
    method test_inet_pton_ipv6 (line 74) | def test_inet_pton_ipv6(self):
    method test_inet_ntop_ipv6 (line 78) | def test_inet_ntop_ipv6(self):
  class TestSocketOptions (line 83) | class TestSocketOptions:
    method test_reuseaddr (line 86) | def test_reuseaddr(self):
    method test_timeout (line 93) | def test_timeout(self):
    method test_blocking (line 99) | def test_blocking(self):
  class TestTCPEchoServer (line 108) | class TestTCPEchoServer:
    method test_echo (line 111) | def test_echo(self):
  class TestUDPEchoServer (line 145) | class TestUDPEchoServer:
    method test_echo (line 148) | def test_echo(self):
  class TestSocketPair (line 176) | class TestSocketPair:
    method test_socketpair (line 179) | def test_socketpair(self):
  class TestPortCheck (line 194) | class TestPortCheck:
    method test_port_available (line 197) | def test_port_available(self):
    method test_port_in_use (line 206) | def test_port_in_use(self):
  class TestMACConversion (line 223) | class TestMACConversion:
    method test_mac_to_bytes (line 226) | def test_mac_to_bytes(self):
    method test_bytes_to_mac (line 233) | def test_bytes_to_mac(self):
  class TestSelectorsEcho (line 241) | class TestSelectorsEcho:
    method test_selectors_echo (line 244) | def test_selectors_echo(self):

FILE: src/basic/sqlalchemy_core.py
  class TestEngine (line 44) | class TestEngine:
    method test_create_sqlite_memory (line 47) | def test_create_sqlite_memory(self):
    method test_create_sqlite_file (line 51) | def test_create_sqlite_file(self, tmp_path):
  class TestRawSQL (line 57) | class TestRawSQL:
    method test_execute_raw_sql (line 60) | def test_execute_raw_sql(self):
  class TestTransaction (line 77) | class TestTransaction:
    method test_begin_commit (line 80) | def test_begin_commit(self):
  class TestMetadata (line 92) | class TestMetadata:
    method test_define_table (line 95) | def test_define_table(self):
    method test_reflect_table (line 108) | def test_reflect_table(self):
  class TestInspect (line 121) | class TestInspect:
    method test_get_table_names (line 124) | def test_get_table_names(self):
  class TestCoreInsert (line 133) | class TestCoreInsert:
    method test_single_insert (line 136) | def test_single_insert(self):
    method test_bulk_insert (line 154) | def test_bulk_insert(self):
  class TestCoreSelect (line 171) | class TestCoreSelect:
    method test_select_all (line 174) | def test_select_all(self):
    method test_select_where (line 194) | def test_select_where(self):
  class TestCoreUpdate (line 217) | class TestCoreUpdate:
    method test_update (line 220) | def test_update(self):
  class TestCoreDelete (line 242) | class TestCoreDelete:
    method test_delete (line 245) | def test_delete(self):
  class TestExpressionLanguage (line 265) | class TestExpressionLanguage:
    method test_and_condition (line 268) | def test_and_condition(self):
    method test_or_condition (line 297) | def test_or_condition(self):
    method test_in_clause (line 319) | def test_in_clause(self):
  class TestCoreJoin (line 340) | class TestCoreJoin:
    method test_join (line 343) | def test_join(self):
  class TestAggregate (line 379) | class TestAggregate:
    method test_count (line 382) | def test_count(self):
    method test_sum_group_by (line 398) | def test_sum_group_by(self):
  class TestDropTable (line 428) | class TestDropTable:
    method test_drop_single (line 431) | def test_drop_single(self):
    method test_drop_all (line 442) | def test_drop_all(self):

FILE: src/basic/sqlalchemy_orm.py
  class TestDeclarativeBase (line 33) | class TestDeclarativeBase:
    method test_define_model (line 36) | def test_define_model(self):
  class TestSession (line 49) | class TestSession:
    method test_add_commit (line 52) | def test_add_commit(self):
    method test_add_all (line 72) | def test_add_all(self):
  class TestORMQuery (line 93) | class TestORMQuery:
    method test_select_all (line 96) | def test_select_all(self):
    method test_filter_where (line 116) | def test_filter_where(self):
  class TestORMFilter (line 144) | class TestORMFilter:
    method test_and_filter (line 147) | def test_and_filter(self):
    method test_or_filter (line 177) | def test_or_filter(self):
    method test_in_filter (line 202) | def test_in_filter(self):
  class TestORMUpdate (line 224) | class TestORMUpdate:
    method test_update_object (line 227) | def test_update_object(self):
  class TestORMDelete (line 251) | class TestORMDelete:
    method test_delete_object (line 254) | def test_delete_object(self):
  class TestOneToMany (line 283) | class TestOneToMany:
    method test_relationship (line 286) | def test_relationship(self):
  class TestManyToMany (line 318) | class TestManyToMany:
    method test_relationship (line 321) | def test_relationship(self):
  class TestSelfReferential (line 377) | class TestSelfReferential:
    method test_hierarchy (line 380) | def test_hierarchy(self):
  class TestCascade (line 419) | class TestCascade:
    method test_delete_orphan (line 422) | def test_delete_orphan(self):
  class TestEagerLoading (line 452) | class TestEagerLoading:
    method test_joinedload (line 455) | def test_joinedload(self):
  class TestHybridProperty (line 487) | class TestHybridProperty:
    method test_full_name (line 490) | def test_full_name(self):
  class TestEventHooks (line 516) | class TestEventHooks:
    method test_before_insert (line 519) | def test_before_insert(self):

FILE: src/basic/sqlalchemy_query.py
  class TestOrderBy (line 33) | class TestOrderBy:
    method test_ascending (line 36) | def test_ascending(self):
    method test_descending (line 64) | def test_descending(self):
  class TestLimitOffset (line 86) | class TestLimitOffset:
    method test_limit (line 89) | def test_limit(self):
    method test_offset (line 110) | def test_offset(self):
  class TestGroupBy (line 132) | class TestGroupBy:
    method test_sum_group_by (line 135) | def test_sum_group_by(self):
    method test_having (line 166) | def test_having(self):
  class TestJoin (line 195) | class TestJoin:
    method test_inner_join (line 198) | def test_inner_join(self):
    method test_outer_join (line 233) | def test_outer_join(self):
  class TestSubquery (line 267) | class TestSubquery:
    method test_scalar_subquery (line 270) | def test_scalar_subquery(self):
  class TestCTE (line 300) | class TestCTE:
    method test_cte (line 303) | def test_cte(self):
  class TestExists (line 338) | class TestExists:
    method test_exists (line 341) | def test_exists(self):
    method test_not_exists (line 376) | def test_not_exists(self):
  class TestUnion (line 412) | class TestUnion:
    method test_union_all (line 415) | def test_union_all(self):
  class TestCase (line 444) | class TestCase:
    method test_case (line 447) | def test_case(self):
  class TestDistinct (line 481) | class TestDistinct:
    method test_distinct (line 484) | def test_distinct(self):
    method test_count_distinct (line 511) | def test_count_distinct(self):
  class TestAliased (line 539) | class TestAliased:
    method test_aliased (line 542) | def test_aliased(self):
  class TestRawSQL (line 579) | class TestRawSQL:
    method test_text (line 582) | def test_text(self):

FILE: src/basic/typing_.py
  function greet (line 22) | def greet(name: str) -> str:
  function add (line 27) | def add(a: int, b: int) -> int:
  function sum_list (line 33) | def sum_list(numbers: list[int]) -> int:
  function get_value (line 38) | def get_value(data: dict[str, int], key: str) -> int | None:
  function find_user (line 44) | def find_user(user_id: int) -> Optional[str]:
  function process (line 50) | def process(value: int | str) -> str:
  function apply (line 56) | def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
  function first (line 68) | def first(items: list[T]) -> T:
  function double_num (line 76) | def double_num(x: Number) -> Number:
  class Stack (line 82) | class Stack(Generic[T]):
    method __init__ (line 85) | def __init__(self) -> None:
    method push (line 88) | def push(self, item: T) -> None:
    method pop (line 91) | def pop(self) -> T:
    method is_empty (line 94) | def is_empty(self) -> bool:
  class Drawable (line 99) | class Drawable(Protocol):
    method draw (line 102) | def draw(self) -> str: ...
  class Circle (line 105) | class Circle:
    method draw (line 108) | def draw(self) -> str:
  class Square (line 112) | class Square:
    method draw (line 115) | def draw(self) -> str:
  function render (line 119) | def render(shape: Drawable) -> str:
  class UserDict (line 125) | class UserDict(TypedDict):
  function set_status (line 133) | def set_status(status: Literal["active", "inactive"]) -> str:
  class Config (line 143) | class Config:
    method __init__ (line 149) | def __init__(self, name: str) -> None:
  class TestBasicTypes (line 154) | class TestBasicTypes:
    method test_greet (line 155) | def test_greet(self):
    method test_add (line 158) | def test_add(self):
  class TestCollections (line 162) | class TestCollections:
    method test_sum_list (line 163) | def test_sum_list(self):
    method test_get_value (line 166) | def test_get_value(self):
  class TestOptionalUnion (line 171) | class TestOptionalUnion:
    method test_find_user (line 172) | def test_find_user(self):
    method test_process (line 176) | def test_process(self):
  class TestCallable (line 181) | class TestCallable:
    method test_apply (line 182) | def test_apply(self):
    method test_double (line 185) | def test_double(self):
  class TestGenerics (line 189) | class TestGenerics:
    method test_first (line 190) | def test_first(self):
    method test_double_num (line 194) | def test_double_num(self):
  class TestGenericClass (line 199) | class TestGenericClass:
    method test_stack (line 200) | def test_stack(self):
  class TestProtocol (line 209) | class TestProtocol:
    method test_render (line 210) | def test_render(self):
  class TestTypedDict (line 215) | class TestTypedDict:
    method test_user_dict (line 216) | def test_user_dict(self):
  class TestLiteral (line 222) | class TestLiteral:
    method test_set_status (line 223) | def test_set_status(self):
  class TestClassVar (line 227) | class TestClassVar:
    method test_config (line 228) | def test_config(self):

FILE: src/basic/unicode_.py
  function encode_utf8 (line 11) | def encode_utf8(s: str) -> bytes:
  function decode_utf8 (line 16) | def decode_utf8(b: bytes) -> str:
  function encode_with_errors (line 21) | def encode_with_errors(s: str, encoding: str, errors: str) -> bytes:
  function get_code_point (line 27) | def get_code_point(char: str) -> int:
  function get_char (line 32) | def get_char(code_point: int) -> str:
  function format_code_points (line 37) | def format_code_points(s: str) -> list[str]:
  function normalize_nfc (line 43) | def normalize_nfc(s: str) -> str:
  function normalize_nfd (line 48) | def normalize_nfd(s: str) -> str:
  function get_char_name (line 54) | def get_char_name(char: str) -> str:
  function get_char_category (line 59) | def get_char_category(char: str) -> str:
  function lookup_char (line 64) | def lookup_char(name: str) -> str:
  function case_insensitive_equal (line 70) | def case_insensitive_equal(s1: str, s2: str) -> bool:
  class TestEncodingDecoding (line 76) | class TestEncodingDecoding:
    method test_encode_utf8 (line 77) | def test_encode_utf8(self):
    method test_decode_utf8 (line 80) | def test_decode_utf8(self):
    method test_roundtrip (line 83) | def test_roundtrip(self):
    method test_encode_errors_ignore (line 87) | def test_encode_errors_ignore(self):
    method test_encode_errors_replace (line 90) | def test_encode_errors_replace(self):
  class TestCodePoints (line 94) | class TestCodePoints:
    method test_get_code_point (line 95) | def test_get_code_point(self):
    method test_get_char (line 100) | def test_get_char(self):
    method test_format_code_points (line 105) | def test_format_code_points(self):
  class TestNormalization (line 109) | class TestNormalization:
    method test_nfc (line 110) | def test_nfc(self):
    method test_nfd (line 116) | def test_nfd(self):
    method test_normalization_equality (line 121) | def test_normalization_equality(self):
  class TestCharInfo (line 128) | class TestCharInfo:
    method test_get_char_name (line 129) | def test_get_char_name(self):
    method test_get_char_category (line 133) | def test_get_char_category(self):
    method test_lookup_char (line 138) | def test_lookup_char(self):
  class TestStringOperations (line 143) | class TestStringOperations:
    method test_case_insensitive (line 144) | def test_case_insensitive(self):
    method test_unicode_upper_lower (line 148) | def test_unicode_upper_lower(self):
    method test_unicode_isalpha (line 152) | def test_unicode_isalpha(self):

FILE: src/cext/capi/args.c
  function PyObject (line 5) | static PyObject* no_args(PyObject* self) { Py_RETURN_NONE; }
  function PyObject (line 8) | static PyObject* single_arg(PyObject* self, PyObject* arg) { return Py_B...
  function PyObject (line 11) | static PyObject* pos_args(PyObject* self, PyObject* args) {
  function PyObject (line 20) | static PyObject* kw_args(PyObject* self, PyObject* args, PyObject* kwarg...
  function PyObject (line 31) | static PyObject* typed_args(PyObject* self, PyObject* args) {
  type PyModuleDef (line 51) | struct PyModuleDef
  function PyMODINIT_FUNC (line 53) | PyMODINIT_FUNC PyInit_args(void) { return PyModule_Create(&module); }

FILE: src/cext/capi/errors.c
  function PyObject (line 7) | static PyObject* raise_value_error(PyObject* self) {
  function PyObject (line 13) | static PyObject* raise_foo_error(PyObject* self) {
  function PyObject (line 19) | static PyObject* raise_with_format(PyObject* self, PyObject* args) {
  function PyObject (line 29) | static PyObject* divide(PyObject* self, PyObject* args) {
  type PyModuleDef (line 49) | struct PyModuleDef
  function PyMODINIT_FUNC (line 51) | PyMODINIT_FUNC PyInit_errors(void) {

FILE: src/cext/capi/gil.c
  function PyObject (line 12) | static PyObject* sleep_with_gil(PyObject* self, PyObject* args) {
  function PyObject (line 22) | static PyObject* sleep_no_gil(PyObject* self, PyObject* args) {
  function fib_impl (line 35) | static unsigned long fib_impl(unsigned long n) {
  function PyObject (line 40) | static PyObject* fib_no_gil(PyObject* self, PyObject* args) {
  type PyModuleDef (line 59) | struct PyModuleDef
  function PyMODINIT_FUNC (line 61) | PyMODINIT_FUNC PyInit_gil(void) { return PyModule_Create(&module); }

FILE: src/cext/capi/simple.c
  function PyObject (line 9) | static PyObject* hello(PyObject* self) { return PyUnicode_FromString("He...
  function PyObject (line 11) | static PyObject* add(PyObject* self, PyObject* args) {
  function fib_impl (line 19) | static unsigned long fib_impl(unsigned long n) {
  function PyObject (line 24) | static PyObject* fib(PyObject* self, PyObject* args) {
  type PyModuleDef (line 39) | struct PyModuleDef
  function PyMODINIT_FUNC (line 41) | PyMODINIT_FUNC PyInit_simple(void) { return PyModule_Create(&module); }

FILE: src/cext/capi/test_capi.py
  class TestSimple (line 15) | class TestSimple:
    method test_hello (line 18) | def test_hello(self):
    method test_add (line 23) | def test_add(self):
    method test_fib (line 29) | def test_fib(self):
  class TestArgs (line 38) | class TestArgs:
    method test_no_args (line 41) | def test_no_args(self):
    method test_single_arg (line 46) | def test_single_arg(self):
    method test_pos_args (line 52) | def test_pos_args(self):
    method test_kw_args (line 58) | def test_kw_args(self):
    method test_typed_args (line 65) | def test_typed_args(self):
  class TestGil (line 72) | class TestGil:
    method test_fib_no_gil (line 75) | def test_fib_no_gil(self):
  class TestErrors (line 82) | class TestErrors:
    method test_raise_value_error (line 85) | def test_raise_value_error(self):
    method test_raise_foo_error (line 91) | def test_raise_foo_error(self):
    method test_raise_with_format (line 97) | def test_raise_with_format(self):
    method test_divide (line 103) | def test_divide(self):
  class TestTypesDemo (line 111) | class TestTypesDemo:
    method test_list_demo (line 114) | def test_list_demo(self):
    method test_list_sum (line 119) | def test_list_sum(self):
    method test_iter_list (line 124) | def test_iter_list(self):
    method test_dict_demo (line 129) | def test_dict_demo(self):
    method test_dict_get (line 134) | def test_dict_get(self):
    method test_iter_dict (line 141) | def test_iter_dict(self):
    method test_tuple_demo (line 148) | def test_tuple_demo(self):
    method test_tuple_unpack (line 153) | def test_tuple_unpack(self):
    method test_set_demo (line 159) | def test_set_demo(self):
    method test_set_contains (line 164) | def test_set_contains(self):
    method test_str_demo (line 171) | def test_str_demo(self):
    method test_str_format (line 176) | def test_str_format(self):
    method test_bytes_demo (line 181) | def test_bytes_demo(self):
    method test_bytes_len (line 186) | def test_bytes_len(self):

FILE: src/cext/capi/types_demo.c
  function PyObject (line 5) | static PyObject* list_demo(PyObject* self) {
  function PyObject (line 13) | static PyObject* list_sum(PyObject* self, PyObject* args) {
  function PyObject (line 28) | static PyObject* iter_list(PyObject* self, PyObject* args) {
  function PyObject (line 48) | static PyObject* dict_demo(PyObject* self) {
  function PyObject (line 55) | static PyObject* dict_get(PyObject* self, PyObject* args) {
  function PyObject (line 70) | static PyObject* iter_dict(PyObject* self, PyObject* args) {
  function PyObject (line 87) | static PyObject* tuple_demo(PyObject* self) { return Py_BuildValue("(isd...
  function PyObject (line 89) | static PyObject* tuple_unpack(PyObject* self, PyObject* args) {
  function PyObject (line 100) | static PyObject* set_demo(PyObject* self) {
  function PyObject (line 109) | static PyObject* set_contains(PyObject* self, PyObject* args) {
  function PyObject (line 120) | static PyObject* str_demo(PyObject* self) {
  function PyObject (line 129) | static PyObject* str_format(PyObject* self, PyObject* args) {
  function PyObject (line 139) | static PyObject* bytes_demo(PyObject* self) { return PyBytes_FromString(...
  function PyObject (line 141) | static PyObject* bytes_len(PyObject* self, PyObject* args) {
  type PyModuleDef (line 167) | struct PyModuleDef
  function PyMODINIT_FUNC (line 169) | PyMODINIT_FUNC PyInit_types_demo(void) { return PyModule_Create(&module); }

FILE: src/cext/conftest.py
  function pytest_configure (line 10) | def pytest_configure(config):

FILE: src/cext/example.cpp
  function add (line 19) | int add(int a, int b) { return a + b; }
  function fib (line 21) | unsigned long fib(unsigned long n) {
  function fib_iter (line 27) | unsigned long fib_iter(unsigned long n) {
  function PYBIND11_MODULE (line 38) | PYBIND11_MODULE(example, m) {

FILE: src/cext/fib.c
  function fib (line 25) | unsigned long fib(unsigned long n) {
  function fib_iter (line 30) | unsigned long fib_iter(unsigned long n) {
  function add (line 41) | int add(int a, int b) { return a + b; }
  function multiply (line 43) | double multiply(double a, double b) { return a * b; }
  type Point (line 46) | typedef struct {
  function point_distance (line 51) | double point_distance(Point* p1, Point* p2) {
  function point_scale (line 57) | void point_scale(Point* p, double factor) {

FILE: src/cext/gil_example.cpp
  function slow_operation (line 24) | void slow_operation(int seconds) {
  function fib_nogil (line 31) | unsigned long fib_nogil(unsigned long n) {
  function call_python_callback (line 44) | void call_python_callback(py::function callback, const std::string& msg) {
  function PYBIND11_MODULE (line 55) | PYBIND11_MODULE(gil_example, m) {

FILE: src/cext/numpy_example.cpp
  function multiply_inplace (line 26) | void multiply_inplace(py::array_t<double> arr, double factor) {
  function add_arrays (line 34) | py::array_t<double> add_arrays(py::array_t<double> a, py::array_t<double...
  function matrix_sum (line 52) | double matrix_sum(py::array_t<double> mat) {
  function square (line 64) | py::array_t<double> square(py::array_t<double> arr) {
  function PYBIND11_MODULE (line 75) | PYBIND11_MODULE(numpy_example, m) {

FILE: src/cext/test_cext.py
  class TestExample (line 49) | class TestExample:
    method test_add (line 52) | def test_add(self):
    method test_fib (line 57) | def test_fib(self):
    method test_fib_iter (line 63) | def test_fib_iter(self):
  class TestVector (line 71) | class TestVector:
    method test_constructor (line 74) | def test_constructor(self):
    method test_length (line 83) | def test_length(self):
    method test_dot (line 90) | def test_dot(self):
    method test_normalized (line 95) | def test_normalized(self):
    method test_add (line 100) | def test_add(self):
    method test_sub (line 107) | def test_sub(self):
    method test_mul (line 114) | def test_mul(self):
    method test_eq (line 120) | def test_eq(self):
    method test_repr (line 127) | def test_repr(self):
  class TestNumPy (line 135) | class TestNumPy:
    method test_multiply_inplace (line 138) | def test_multiply_inplace(self):
    method test_add_arrays (line 143) | def test_add_arrays(self):
    method test_add_arrays_length_mismatch (line 149) | def test_add_arrays_length_mismatch(self):
    method test_matrix_sum (line 155) | def test_matrix_sum(self):
    method test_square (line 159) | def test_square(self):
  class TestGIL (line 166) | class TestGIL:
    method test_fib_nogil (line 169) | def test_fib_nogil(self):
    method test_slow_operation_parallel (line 173) | def test_slow_operation_parallel(self):
    method test_callback (line 196) | def test_callback(self):

FILE: src/cext/vector.cpp
  class Vector2D (line 28) | class Vector2D {
    method Vector2D (line 32) | Vector2D(double x = 0, double y = 0) : x(x), y(y) {}
    method length (line 34) | double length() const { return std::sqrt(x * x + y * y); }
    method dot (line 36) | double dot(const Vector2D& other) const { return x * other.x + y * oth...
    method Vector2D (line 38) | Vector2D normalized() const {
    method Vector2D (line 44) | Vector2D operator+(const Vector2D& other) const { return Vector2D(x + ...
    method Vector2D (line 46) | Vector2D operator-(const Vector2D& other) const { return Vector2D(x - ...
    method Vector2D (line 48) | Vector2D operator*(double scalar) const { return Vector2D(x * scalar, ...
    method repr (line 52) | std::string repr() const {
  function PYBIND11_MODULE (line 59) | PYBIND11_MODULE(vector, m) {

FILE: src/cpp_from_python/cpp_from_py.cpp
  function hello_world (line 29) | void hello_world() {
  function variables (line 44) | void variables() {
  function lists_and_vectors (line 62) | std::vector<int> lists_and_vectors() {
  function array_slicing (line 83) | std::vector<int> array_slicing() {
  function dictionaries_and_maps (line 111) | std::map<std::string, int> dictionaries_and_maps() {
  function for_loop (line 129) | void for_loop() {
  function add (line 150) | auto add(int a, int b) -> int {
  function create_square_lambda (line 170) | std::function<int(int)> create_square_lambda() {
  function create_multiply_lambda (line 183) | std::function<int(int)> create_multiply_lambda(int multiplier) {
  function transform_with_lambda (line 196) | std::vector<int> transform_with_lambda(const std::vector<int>& numbers) {
  function list_comprehension (line 213) | std::vector<int> list_comprehension() {
  function string_operations (line 234) | std::string string_operations() {
  class Person (line 257) | class Person {
  function find_value (line 286) | std::optional<int> find_value(const std::string& key) {
  function create_tuple (line 305) | std::tuple<int, int> create_tuple() {
  function filter_evens (line 318) | std::vector<int> filter_evens(const std::vector<int>& numbers) {
  function has_even (line 335) | bool has_even(const std::vector<int>& numbers) {
  function all_positive (line 349) | bool all_positive(const std::vector<int>& numbers) {
  function sort_vector (line 363) | std::vector<int> sort_vector(std::vector<int> numbers) {
  function find_min (line 377) | int find_min(const std::vector<int>& numbers) {
  function sum_vector (line 390) | int sum_vector(const std::vector<int>& numbers) {
  function greet (line 406) | std::string greet(const std::string& name, const std::string& greeting =...
  function TEST (line 410) | TEST(BasicTest, AddFunction) {
  function TEST (line 416) | TEST(VectorTest, ListsAndVectors) {
  function TEST (line 423) | TEST(VectorTest, ArraySlicing) {
  function TEST (line 430) | TEST(MapTest, DictionariesAndMaps) {
  function TEST (line 437) | TEST(LambdaTest, SquareLambda) {
  function TEST (line 444) | TEST(LambdaTest, MultiplyLambda) {
  function TEST (line 450) | TEST(LambdaTest, TransformWithLambda) {
  function TEST (line 460) | TEST(VectorTest, ListComprehension) {
  function TEST (line 467) | TEST(StringTest, StringOperations) {
  function TEST (line 473) | TEST(ClassTest, PersonClass) {
  function TEST (line 480) | TEST(OptionalTest, FindValue) {
  function TEST (line 489) | TEST(TupleTest, CreateTuple) {
  function TEST (line 495) | TEST(AlgorithmTest, FilterEvens) {
  function TEST (line 503) | TEST(AlgorithmTest, HasEven) {
  function TEST (line 510) | TEST(AlgorithmTest, AllPositive) {
  function TEST (line 517) | TEST(AlgorithmTest, SortVector) {
  function TEST (line 524) | TEST(AlgorithmTest, FindMin) {
  function TEST (line 529) | TEST(AlgorithmTest, SumVector) {
  function TEST (line 534) | TEST(FunctionTest, DefaultArguments) {
  function main (line 539) | int main(int argc, char **argv) {

FILE: src/llm/vllm/offline_bench.py
  function viztracer_profiler (line 35) | def viztracer_profiler(output_file, world_rank):
  function cuda_profiler (line 64) | def cuda_profiler(enabled, world_rank):
  function load_sharegpt_prompts (line 84) | def load_sharegpt_prompts(dataset_path: str, num_prompts: int) -> List[s...
  function generate_random_prompts (line 97) | def generate_random_prompts(num_prompts: int, input_len: int, tokenizer)...
  function generate_dummy_prompts (line 113) | def generate_dummy_prompts(num_prompts: int) -> List[str]:
  function parse_args (line 126) | def parse_args():
  function main (line 224) | def main():
  function print_results (line 417) | def print_results(

FILE: src/megatron/entrypoint.py
  function load_recipe (line 30) | def load_recipe(path, **kwargs):
  function parse_cli_overrides (line 38) | def parse_cli_overrides(cfg, args):
  function main (line 46) | def main() -> None:

FILE: src/megatron/recipes/deepseek_v2_lite_pretrain.py
  function configure (line 6) | def configure(hf_path=None, moe_token_dispatcher_type=None):

FILE: src/megatron/viztracer_plugin.py
  function _patched_handle_step (line 31) | def _patched_handle_step(config, iteration, rank, pytorch_prof):
  function _patched_handle_stop (line 60) | def _patched_handle_stop(config, iteration, rank, pytorch_prof, nsys_nvt...
  function install (line 77) | def install():

FILE: src/new_py3/py3.py
  function dict_merge (line 15) | def dict_merge(a: dict, b: dict) -> dict:
  function dict_update (line 20) | def dict_update(a: dict, b: dict) -> dict:
  function positional_only (line 27) | def positional_only(a, b, /, c, d):
  function walrus_example (line 33) | def walrus_example(data: list):
  function walrus_fib (line 40) | def walrus_fib(count: int) -> list:
  class Point (line 48) | class Point:
  class FrozenPoint (line 56) | class FrozenPoint:
  function fstring_basic (line 64) | def fstring_basic(name: str) -> str:
  function fstring_format (line 69) | def fstring_format(value: float) -> str:
  function async_greet (line 75) | async def async_greet() -> str:
  function general_unpacking (line 82) | def general_unpacking() -> list:
  function fib_gen (line 88) | def fib_gen(n: int):
  function delegate_fib (line 96) | def delegate_fib(n: int):
  function extended_unpacking (line 102) | def extended_unpacking() -> tuple:
  function keyword_only (line 109) | def keyword_only(a, b, *, kw):
  function nonlocal_example (line 115) | def nonlocal_example() -> str:
  class TestPython312 (line 129) | class TestPython312:
    method test_box_int (line 130) | def test_box_int(self):
    method test_first (line 135) | def test_first(self):
    method test_fstring_nested (line 140) | def test_fstring_nested(self):
  class TestPython311 (line 147) | class TestPython311:
    method test_exception_group (line 148) | def test_exception_group(self):
  class TestPython310 (line 163) | class TestPython310:
    method test_http_status (line 164) | def test_http_status(self):
    method test_describe_point (line 178) | def test_describe_point(self):
  class TestPython39 (line 192) | class TestPython39:
    method test_dict_merge (line 193) | def test_dict_merge(self):
    method test_dict_update (line 196) | def test_dict_update(self):
  class TestPython38 (line 200) | class TestPython38:
    method test_positional_only (line 201) | def test_positional_only(self):
    method test_walrus (line 205) | def test_walrus(self):
    method test_walrus_fib (line 209) | def test_walrus_fib(self):
  class TestPython37 (line 213) | class TestPython37:
    method test_dataclass (line 214) | def test_dataclass(self):
    method test_frozen_dataclass (line 217) | def test_frozen_dataclass(self):
  class TestPython36 (line 222) | class TestPython36:
    method test_fstring_basic (line 223) | def test_fstring_basic(self):
    method test_fstring_format (line 226) | def test_fstring_format(self):
  class TestPython35 (line 230) | class TestPython35:
    method test_async_greet (line 231) | def test_async_greet(self):
    method test_general_unpacking (line 234) | def test_general_unpacking(self):
  class TestPython33 (line 238) | class TestPython33:
    method test_delegate_fib (line 239) | def test_delegate_fib(self):
  class TestPython30 (line 243) | class TestPython30:
    method test_extended_unpacking (line 244) | def test_extended_unpacking(self):
    method test_keyword_only (line 247) | def test_keyword_only(self):
    method test_nonlocal (line 250) | def test_nonlocal(self):

FILE: src/security/vulnerability_.py
  class TestTimingAttack (line 9) | class TestTimingAttack:
    method test_insecure_comparison (line 12) | def test_insecure_comparison(self):
    method test_secure_comparison (line 30) | def test_secure_comparison(self):
  class TestWeakRandom (line 39) | class TestWeakRandom:
    method test_weak_random (line 42) | def test_weak_random(self):
    method test_secure_random (line 55) | def test_secure_random(self):
  class TestSQLInjection (line 66) | class TestSQLInjection:
    method test_vulnerable_query_building (line 69) | def test_vulnerable_query_building(self):
    method test_parameterized_query (line 86) | def test_parameterized_query(self):
  class TestCommandInjection (line 98) | class TestCommandInjection:
    method test_vulnerable_shell_command (line 101) | def test_vulnerable_shell_command(self):
    method test_secure_command (line 114) | def test_secure_command(self):
  class TestPickleVulnerability (line 133) | class TestPickleVulnerability:
    method test_pickle_code_execution (line 136) | def test_pickle_code_execution(self):
    method test_safe_json (line 154) | def test_safe_json(self):
  class TestHardcodedSecrets (line 166) | class TestHardcodedSecrets:
    method test_environment_variables (line 169) | def test_environment_variables(self):
  class TestAESModes (line 186) | class TestAESModes:
    method test_ecb_mode_pattern_leak (line 189) | def test_ecb_mode_pattern_leak(self):
    method test_cbc_needs_authentication (line 212) | def test_cbc_needs_authentication(self):
  class TestPasswordStorage (line 223) | class TestPasswordStorage:
    method test_weak_hash (line 226) | def test_weak_hash(self):
    method test_secure_password_hash (line 240) | def test_secure_password_hash(self):