@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/python.json

@@ -0,0 +1,717 @@
+{
+  "language": "python",
+  "definitions": {
+    "str": {
+      "signature": "class str(object='') / class str(object=b'', encoding='utf-8', errors='strict')",
+      "description": "Immutable sequence of Unicode code points. The standard text sequence type in Python.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "format": { "signature": "str.format(*args, **kwargs) -> str", "description": "Perform a string formatting operation. The string on which this method is called can contain literal text or replacement fields delimited by braces {}.", "type": "method" },
+        "join": { "signature": "str.join(iterable) -> str", "description": "Return a string which is the concatenation of the strings in iterable, separated by the string providing this method.", "type": "method" },
+        "split": { "signature": "str.split(sep=None, maxsplit=-1) -> list[str]", "description": "Return a list of the words in the string, using sep as the delimiter string. If sep is None, splits on whitespace.", "type": "method" },
+        "rsplit": { "signature": "str.rsplit(sep=None, maxsplit=-1) -> list[str]", "description": "Return a list of the words in the string, splitting from the right.", "type": "method" },
+        "strip": { "signature": "str.strip(chars=None) -> str", "description": "Return a copy with leading and trailing characters removed.", "type": "method" },
+        "lstrip": { "signature": "str.lstrip(chars=None) -> str", "description": "Return a copy with leading characters removed.", "type": "method" },
+        "rstrip": { "signature": "str.rstrip(chars=None) -> str", "description": "Return a copy with trailing characters removed.", "type": "method" },
+        "replace": { "signature": "str.replace(old, new, count=-1) -> str", "description": "Return a copy with all occurrences of substring old replaced by new. If count is given, only the first count occurrences are replaced.", "type": "method" },
+        "find": { "signature": "str.find(sub, start=0, end=len(str)) -> int", "description": "Return the lowest index where substring sub is found within the slice s[start:end]. Return -1 if not found.", "type": "method" },
+        "rfind": { "signature": "str.rfind(sub, start=0, end=len(str)) -> int", "description": "Return the highest index where substring sub is found. Return -1 if not found.", "type": "method" },
+        "index": { "signature": "str.index(sub, start=0, end=len(str)) -> int", "description": "Like find(), but raise ValueError when the substring is not found.", "type": "method" },
+        "count": { "signature": "str.count(sub, start=0, end=len(str)) -> int", "description": "Return the number of non-overlapping occurrences of substring sub.", "type": "method" },
+        "startswith": { "signature": "str.startswith(prefix, start=0, end=len(str)) -> bool", "description": "Return True if string starts with the prefix, otherwise return False. prefix can be a tuple of prefixes to look for.", "type": "method" },
+        "endswith": { "signature": "str.endswith(suffix, start=0, end=len(str)) -> bool", "description": "Return True if the string ends with the specified suffix, otherwise return False. suffix can be a tuple.", "type": "method" },
+        "upper": { "signature": "str.upper() -> str", "description": "Return a copy with all cased characters converted to uppercase.", "type": "method" },
+        "lower": { "signature": "str.lower() -> str", "description": "Return a copy with all cased characters converted to lowercase.", "type": "method" },
+        "title": { "signature": "str.title() -> str", "description": "Return a titlecased version of the string where words start with an upper case character.", "type": "method" },
+        "capitalize": { "signature": "str.capitalize() -> str", "description": "Return a copy with its first character capitalized and the rest lowercased.", "type": "method" },
+        "casefold": { "signature": "str.casefold() -> str", "description": "Return a casefolded copy of the string. Used for caseless matching.", "type": "method" },
+        "swapcase": { "signature": "str.swapcase() -> str", "description": "Return a copy with uppercase characters converted to lowercase and vice versa.", "type": "method" },
+        "encode": { "signature": "str.encode(encoding='utf-8', errors='strict') -> bytes", "description": "Return the string encoded to bytes using the specified encoding.", "type": "method" },
+        "isdigit": { "signature": "str.isdigit() -> bool", "description": "Return True if all characters in the string are digits.", "type": "method" },
+        "isalpha": { "signature": "str.isalpha() -> bool", "description": "Return True if all characters in the string are alphabetic.", "type": "method" },
+        "isalnum": { "signature": "str.isalnum() -> bool", "description": "Return True if all characters in the string are alphanumeric.", "type": "method" },
+        "isspace": { "signature": "str.isspace() -> bool", "description": "Return True if all characters are whitespace.", "type": "method" },
+        "isupper": { "signature": "str.isupper() -> bool", "description": "Return True if all cased characters are uppercase.", "type": "method" },
+        "islower": { "signature": "str.islower() -> bool", "description": "Return True if all cased characters are lowercase.", "type": "method" },
+        "zfill": { "signature": "str.zfill(width) -> str", "description": "Pad a numeric string on the left with zeros to fill a field of the given width.", "type": "method" },
+        "center": { "signature": "str.center(width, fillchar=' ') -> str", "description": "Return centered in a string of the given width, padded with fillchar.", "type": "method" },
+        "ljust": { "signature": "str.ljust(width, fillchar=' ') -> str", "description": "Return left-justified in a string of the given width.", "type": "method" },
+        "rjust": { "signature": "str.rjust(width, fillchar=' ') -> str", "description": "Return right-justified in a string of the given width.", "type": "method" },
+        "partition": { "signature": "str.partition(sep) -> tuple[str, str, str]", "description": "Split the string at the first occurrence of sep. Returns (before, sep, after) or (str, '', '') if sep not found.", "type": "method" },
+        "rpartition": { "signature": "str.rpartition(sep) -> tuple[str, str, str]", "description": "Split the string at the last occurrence of sep.", "type": "method" },
+        "removeprefix": { "signature": "str.removeprefix(prefix) -> str", "description": "If the string starts with prefix, return string[len(prefix):]. Otherwise return the original string. (3.9+)", "type": "method" },
+        "removesuffix": { "signature": "str.removesuffix(suffix) -> str", "description": "If the string ends with suffix, return string[:-len(suffix)]. Otherwise return the original string. (3.9+)", "type": "method" }
+      }
+    },
+    "list": {
+      "signature": "class list(iterable=())",
+      "description": "Mutable sequence type. Lists may be constructed with square brackets, the list() constructor, or list comprehensions.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "append": { "signature": "list.append(object) -> None", "description": "Append object to the end of the list.", "type": "method" },
+        "extend": { "signature": "list.extend(iterable) -> None", "description": "Extend list by appending elements from the iterable.", "type": "method" },
+        "insert": { "signature": "list.insert(index, object) -> None", "description": "Insert object before index.", "type": "method" },
+        "remove": { "signature": "list.remove(value) -> None", "description": "Remove first occurrence of value. Raises ValueError if the value is not present.", "type": "method" },
+        "pop": { "signature": "list.pop(index=-1) -> T", "description": "Remove and return item at index (default last). Raises IndexError if list is empty or index is out of range.", "type": "method" },
+        "clear": { "signature": "list.clear() -> None", "description": "Remove all items from the list.", "type": "method" },
+        "index": { "signature": "list.index(value, start=0, stop=len(list)) -> int", "description": "Return first index of value. Raises ValueError if the value is not present.", "type": "method" },
+        "count": { "signature": "list.count(value) -> int", "description": "Return number of occurrences of value.", "type": "method" },
+        "sort": { "signature": "list.sort(*, key=None, reverse=False) -> None", "description": "Sort the list in ascending order and return None. The sort is stable. key specifies a function of one argument used to extract a comparison key.", "type": "method" },
+        "reverse": { "signature": "list.reverse() -> None", "description": "Reverse the elements of the list in place.", "type": "method" },
+        "copy": { "signature": "list.copy() -> list", "description": "Return a shallow copy of the list.", "type": "method" }
+      }
+    },
+    "dict": {
+      "signature": "class dict(**kwargs) / class dict(mapping, **kwargs) / class dict(iterable, **kwargs)",
+      "description": "Mutable mapping type. Dictionaries map hashable keys to arbitrary values. Preserves insertion order (guaranteed since 3.7).",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "get": { "signature": "dict.get(key, default=None) -> V | None", "description": "Return the value for key if key is in the dictionary, else default.", "type": "method" },
+        "keys": { "signature": "dict.keys() -> dict_keys", "description": "Return a view object of the dictionary's keys.", "type": "method" },
+        "values": { "signature": "dict.values() -> dict_values", "description": "Return a view object of the dictionary's values.", "type": "method" },
+        "items": { "signature": "dict.items() -> dict_items", "description": "Return a view object of the dictionary's (key, value) pairs.", "type": "method" },
+        "update": { "signature": "dict.update([other], **kwargs) -> None", "description": "Update the dictionary with key/value pairs from other dict or iterable of key/value pairs.", "type": "method" },
+        "pop": { "signature": "dict.pop(key, default=...) -> V", "description": "Remove specified key and return the corresponding value. If key is not found, default is returned if given, otherwise KeyError is raised.", "type": "method" },
+        "popitem": { "signature": "dict.popitem() -> tuple[K, V]", "description": "Remove and return the last inserted (key, value) pair. Raises KeyError if the dict is empty.", "type": "method" },
+        "setdefault": { "signature": "dict.setdefault(key, default=None) -> V", "description": "If key is in the dictionary, return its value. If not, insert key with a value of default and return default.", "type": "method" },
+        "clear": { "signature": "dict.clear() -> None", "description": "Remove all items from the dictionary.", "type": "method" },
+        "copy": { "signature": "dict.copy() -> dict", "description": "Return a shallow copy of the dictionary.", "type": "method" },
+        "fromkeys": { "signature": "dict.fromkeys(iterable, value=None) -> dict", "description": "Create a new dictionary with keys from iterable and values set to value.", "type": "static method" }
+      }
+    },
+    "set": {
+      "signature": "class set(iterable=())",
+      "description": "Mutable unordered collection of unique hashable elements. Supports mathematical set operations: union, intersection, difference, symmetric difference.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "add": { "signature": "set.add(elem) -> None", "description": "Add element elem to the set.", "type": "method" },
+        "remove": { "signature": "set.remove(elem) -> None", "description": "Remove element elem from the set. Raises KeyError if elem is not contained.", "type": "method" },
+        "discard": { "signature": "set.discard(elem) -> None", "description": "Remove element elem from the set if it is present. Does not raise an error if absent.", "type": "method" },
+        "pop": { "signature": "set.pop() -> T", "description": "Remove and return an arbitrary element. Raises KeyError if the set is empty.", "type": "method" },
+        "clear": { "signature": "set.clear() -> None", "description": "Remove all elements from the set.", "type": "method" },
+        "update": { "signature": "set.update(*others) -> None", "description": "Update the set, adding elements from all others. Equivalent to s |= other.", "type": "method" },
+        "union": { "signature": "set.union(*others) -> set", "description": "Return a new set with elements from the set and all others. Equivalent to s | other.", "type": "method" },
+        "intersection": { "signature": "set.intersection(*others) -> set", "description": "Return a new set with elements common to the set and all others. Equivalent to s & other.", "type": "method" },
+        "intersection_update": { "signature": "set.intersection_update(*others) -> None", "description": "Update the set, keeping only elements found in it and all others. Equivalent to s &= other.", "type": "method" },
+        "difference": { "signature": "set.difference(*others) -> set", "description": "Return a new set with elements in the set that are not in the others. Equivalent to s - other.", "type": "method" },
+        "difference_update": { "signature": "set.difference_update(*others) -> None", "description": "Remove all elements of other sets from this set. Equivalent to s -= other.", "type": "method" },
+        "symmetric_difference": { "signature": "set.symmetric_difference(other) -> set", "description": "Return a new set with elements in either the set or other but not both. Equivalent to s ^ other.", "type": "method" },
+        "issubset": { "signature": "set.issubset(other) -> bool", "description": "Test whether every element in the set is in other. Equivalent to s <= other.", "type": "method" },
+        "issuperset": { "signature": "set.issuperset(other) -> bool", "description": "Test whether every element in other is in the set. Equivalent to s >= other.", "type": "method" },
+        "isdisjoint": { "signature": "set.isdisjoint(other) -> bool", "description": "Return True if the set has no elements in common with other.", "type": "method" },
+        "copy": { "signature": "set.copy() -> set", "description": "Return a shallow copy of the set.", "type": "method" }
+      }
+    },
+    "tuple": {
+      "signature": "class tuple(iterable=())",
+      "description": "Immutable sequence type. Tuples are commonly used for heterogeneous data and as dictionary keys (since they are hashable). Support indexing, slicing, packing/unpacking.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "count": { "signature": "tuple.count(value) -> int", "description": "Return number of occurrences of value.", "type": "method" },
+        "index": { "signature": "tuple.index(value, start=0, stop=len(tuple)) -> int", "description": "Return first index of value. Raises ValueError if the value is not present.", "type": "method" }
+      }
+    },
+    "int": {
+      "signature": "class int(x=0) / class int(x: str, base=10)",
+      "description": "Immutable arbitrary-precision integer type. Supports standard arithmetic, comparison, bitwise operations, and conversions.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "bit_length": { "signature": "int.bit_length() -> int", "description": "Return the number of bits necessary to represent the integer in binary, excluding the sign and leading zeros.", "type": "method" },
+        "bit_count": { "signature": "int.bit_count() -> int", "description": "Return the number of ones in the binary representation (popcount). (3.10+)", "type": "method" },
+        "to_bytes": { "signature": "int.to_bytes(length=1, byteorder='big', *, signed=False) -> bytes", "description": "Return an array of bytes representing the integer.", "type": "method" },
+        "from_bytes": { "signature": "int.from_bytes(bytes, byteorder='big', *, signed=False) -> int", "description": "Return the integer represented by the given array of bytes.", "type": "static method" },
+        "conjugate": { "signature": "int.conjugate() -> int", "description": "Returns self. Exists for compatibility with complex numbers.", "type": "method" },
+        "real": { "signature": "int.real -> int", "description": "The real part of the number (itself).", "type": "property" },
+        "imag": { "signature": "int.imag -> int", "description": "The imaginary part of the number (always 0).", "type": "property" }
+      }
+    },
+    "float": {
+      "signature": "class float(x=0.0)",
+      "description": "Immutable floating-point number implemented using C double (IEEE 754 double precision, 64-bit).",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "is_integer": { "signature": "float.is_integer() -> bool", "description": "Return True if the float instance is finite with integral value.", "type": "method" },
+        "hex": { "signature": "float.hex() -> str", "description": "Return a representation of a float as a hexadecimal string.", "type": "method" },
+        "fromhex": { "signature": "float.fromhex(s: str) -> float", "description": "Class method to return a float from a hexadecimal string.", "type": "static method" },
+        "as_integer_ratio": { "signature": "float.as_integer_ratio() -> tuple[int, int]", "description": "Return a pair of integers whose ratio is exactly equal to the float.", "type": "method" },
+        "conjugate": { "signature": "float.conjugate() -> float", "description": "Returns self. Exists for compatibility with complex numbers.", "type": "method" },
+        "real": { "signature": "float.real -> float", "description": "The real part of the number (itself).", "type": "property" },
+        "imag": { "signature": "float.imag -> float", "description": "The imaginary part of the number (always 0.0).", "type": "property" }
+      }
+    },
+    "bool": {
+      "signature": "class bool(x=False)",
+      "description": "Subclass of int with exactly two instances: True (== 1) and False (== 0). Falsy values: None, 0, '', [], {}, set(), b''.",
+      "type": "class",
+      "module": "builtins",
+      "members": {}
+    },
+    "bytes": {
+      "signature": "class bytes(source=b'') / class bytes(source: str, encoding: str) / class bytes(length: int)",
+      "description": "Immutable sequence of bytes (integers in range 0-255). Supports many str-like methods.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "decode": { "signature": "bytes.decode(encoding='utf-8', errors='strict') -> str", "description": "Decode the bytes using the given encoding and return the resulting string.", "type": "method" },
+        "hex": { "signature": "bytes.hex(sep=None, bytes_per_sep=1) -> str", "description": "Return a string containing two hexadecimal digits per byte.", "type": "method" },
+        "fromhex": { "signature": "bytes.fromhex(string) -> bytes", "description": "Create a bytes object from a string of hexadecimal digits.", "type": "static method" },
+        "split": { "signature": "bytes.split(sep=None, maxsplit=-1) -> list[bytes]", "description": "Return a list of the sections in the bytes, using sep as the delimiter.", "type": "method" },
+        "join": { "signature": "bytes.join(iterable) -> bytes", "description": "Concatenate bytes objects from the iterable, separated by this bytes object.", "type": "method" },
+        "replace": { "signature": "bytes.replace(old, new, count=-1) -> bytes", "description": "Return a copy with all occurrences of old replaced by new.", "type": "method" },
+        "startswith": { "signature": "bytes.startswith(prefix, start=0, end=len) -> bool", "description": "Return True if bytes starts with the prefix.", "type": "method" },
+        "endswith": { "signature": "bytes.endswith(suffix, start=0, end=len) -> bool", "description": "Return True if bytes ends with the suffix.", "type": "method" },
+        "find": { "signature": "bytes.find(sub, start=0, end=len) -> int", "description": "Return the lowest index where sub is found, or -1.", "type": "method" },
+        "strip": { "signature": "bytes.strip(bytes=None) -> bytes", "description": "Strip leading and trailing bytes.", "type": "method" },
+        "count": { "signature": "bytes.count(sub, start=0, end=len) -> int", "description": "Return the number of non-overlapping occurrences of sub.", "type": "method" }
+      }
+    },
+    "range": {
+      "signature": "class range(stop) / class range(start, stop, step=1)",
+      "description": "Immutable sequence of numbers. Commonly used for looping a specific number of times in for loops. Memory efficient: only stores start, stop, step regardless of range size.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "start": { "signature": "range.start -> int", "description": "The value of the start parameter (0 if not provided).", "type": "property" },
+        "stop": { "signature": "range.stop -> int", "description": "The value of the stop parameter.", "type": "property" },
+        "step": { "signature": "range.step -> int", "description": "The value of the step parameter (1 if not provided).", "type": "property" },
+        "count": { "signature": "range.count(value) -> int", "description": "Return number of occurrences of value.", "type": "method" },
+        "index": { "signature": "range.index(value) -> int", "description": "Return index of value. Raises ValueError if the value is not present.", "type": "method" }
+      }
+    },
+    "frozenset": {
+      "signature": "class frozenset(iterable=())",
+      "description": "Immutable version of set. Being immutable and hashable, frozensets can be used as dictionary keys or as elements of other sets.",
+      "type": "class",
+      "module": "builtins",
+      "members": {
+        "union": { "signature": "frozenset.union(*others) -> frozenset", "description": "Return a new frozenset with elements from the frozenset and all others.", "type": "method" },
+        "intersection": { "signature": "frozenset.intersection(*others) -> frozenset", "description": "Return a new frozenset with elements common to the frozenset and all others.", "type": "method" },
+        "difference": { "signature": "frozenset.difference(*others) -> frozenset", "description": "Return a new frozenset with elements in the frozenset that are not in the others.", "type": "method" },
+        "symmetric_difference": { "signature": "frozenset.symmetric_difference(other) -> frozenset", "description": "Return a new frozenset with elements in either set but not both.", "type": "method" },
+        "issubset": { "signature": "frozenset.issubset(other) -> bool", "description": "Test whether every element in the frozenset is in other.", "type": "method" },
+        "issuperset": { "signature": "frozenset.issuperset(other) -> bool", "description": "Test whether every element in other is in the frozenset.", "type": "method" },
+        "isdisjoint": { "signature": "frozenset.isdisjoint(other) -> bool", "description": "Return True if the frozenset has no elements in common with other.", "type": "method" },
+        "copy": { "signature": "frozenset.copy() -> frozenset", "description": "Return a shallow copy of the frozenset.", "type": "method" }
+      }
+    },
+    "print": {
+      "signature": "print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False) -> None",
+      "description": "Print objects to the text stream file, separated by sep and followed by end.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "*objects", "type": "Any", "description": "Values to print" },
+        { "name": "sep", "type": "str", "description": "String inserted between values, default a space", "optional": true },
+        { "name": "end", "type": "str", "description": "String appended after the last value, default a newline", "optional": true },
+        { "name": "file", "type": "IO", "description": "A file-like object (stream); defaults to sys.stdout", "optional": true },
+        { "name": "flush", "type": "bool", "description": "Whether to forcibly flush the stream", "optional": true }
+      ],
+      "returns": "None"
+    },
+    "len": {
+      "signature": "len(s) -> int",
+      "description": "Return the number of items in a container.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "s", "type": "Sized", "description": "An object with a __len__ method (sequence, mapping, set, etc.)" }
+      ],
+      "returns": "int"
+    },
+    "enumerate": {
+      "signature": "enumerate(iterable, start=0) -> Iterator[tuple[int, T]]",
+      "description": "Return an enumerate object. Yields pairs containing a count (from start) and the values obtained from iterating over iterable.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable[T]", "description": "An iterable to enumerate" },
+        { "name": "start", "type": "int", "description": "The starting count value", "optional": true }
+      ],
+      "returns": "Iterator[tuple[int, T]]"
+    },
+    "zip": {
+      "signature": "zip(*iterables, strict=False) -> Iterator[tuple[...]]",
+      "description": "Iterate over several iterables in parallel, producing tuples with an item from each one. Stops when the shortest iterable is exhausted (unless strict=True).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "*iterables", "type": "Iterable", "description": "One or more iterables to zip together" },
+        { "name": "strict", "type": "bool", "description": "If True, raise ValueError if iterables have different lengths (3.10+)", "optional": true }
+      ],
+      "returns": "Iterator[tuple[...]]"
+    },
+    "map": {
+      "signature": "map(function, iterable, *iterables) -> Iterator",
+      "description": "Return an iterator that applies function to every item of iterable, yielding the results.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "function", "type": "Callable", "description": "A function to apply to each element" },
+        { "name": "iterable", "type": "Iterable", "description": "Iterable(s) whose elements are passed to function" }
+      ],
+      "returns": "Iterator"
+    },
+    "filter": {
+      "signature": "filter(function, iterable) -> Iterator",
+      "description": "Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return items that are true.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "function", "type": "Callable[[T], bool] | None", "description": "A function that tests each element, or None for truth testing" },
+        { "name": "iterable", "type": "Iterable[T]", "description": "An iterable to filter" }
+      ],
+      "returns": "Iterator[T]"
+    },
+    "sorted": {
+      "signature": "sorted(iterable, /, *, key=None, reverse=False) -> list",
+      "description": "Return a new sorted list from the items in iterable. The sort is guaranteed to be stable.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable", "description": "The iterable to sort" },
+        { "name": "key", "type": "Callable | None", "description": "A function of one argument used to extract a comparison key", "optional": true },
+        { "name": "reverse", "type": "bool", "description": "If True, sort in descending order", "optional": true }
+      ],
+      "returns": "list"
+    },
+    "open": {
+      "signature": "open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) -> IO",
+      "description": "Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised. Should be used with a `with` statement for guaranteed cleanup.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "file", "type": "str | PathLike | int", "description": "Path to the file or a file descriptor" },
+        { "name": "mode", "type": "str", "description": "Open mode: 'r' (read), 'w' (write), 'a' (append), 'x' (create), 'b' (binary), 't' (text), '+' (update)", "optional": true },
+        { "name": "buffering", "type": "int", "description": "Buffering policy: 0=unbuffered, 1=line-buffered, >1=buffer size", "optional": true },
+        { "name": "encoding", "type": "str | None", "description": "Text encoding (e.g. 'utf-8'). Only used in text mode", "optional": true },
+        { "name": "errors", "type": "str | None", "description": "How encoding/decoding errors are handled", "optional": true },
+        { "name": "newline", "type": "str | None", "description": "How universal newlines mode works", "optional": true }
+      ],
+      "returns": "IO"
+    },
+    "isinstance": {
+      "signature": "isinstance(object, classinfo) -> bool",
+      "description": "Return True if the object argument is an instance of the classinfo argument, or of a (direct, indirect, or virtual) subclass thereof.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to check" },
+        { "name": "classinfo", "type": "type | tuple[type, ...] | UnionType", "description": "A type, tuple of types, or union type to check against" }
+      ],
+      "returns": "bool"
+    },
+    "type": {
+      "signature": "type(object) -> type / type(name, bases, dict, **kwds) -> type",
+      "description": "With one argument, return the type of an object. With three arguments, create a new type object (dynamic class creation).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "Object whose type to return (single-argument form)" },
+        { "name": "name", "type": "str", "description": "The class name (three-argument form)" },
+        { "name": "bases", "type": "tuple", "description": "Base classes (three-argument form)" },
+        { "name": "dict", "type": "dict", "description": "Namespace dict containing class body definitions (three-argument form)" }
+      ],
+      "returns": "type"
+    },
+    "super": {
+      "signature": "super() -> super / super(type, object_or_type) -> super",
+      "description": "Return a proxy object that delegates method calls to a parent or sibling class. The zero-argument form works inside a class definition.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "type", "type": "type", "description": "Starting type for MRO search", "optional": true },
+        { "name": "object_or_type", "type": "object | type", "description": "Determines the MRO to search and the binding", "optional": true }
+      ],
+      "returns": "super"
+    },
+    "abs": {
+      "signature": "abs(x) -> int | float",
+      "description": "Return the absolute value of a number. The argument may be an integer, float, or object implementing __abs__().",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "x", "type": "int | float | complex", "description": "A number" }
+      ],
+      "returns": "int | float"
+    },
+    "min": {
+      "signature": "min(iterable, *, key=None, default=...) / min(arg1, arg2, *args, key=None)",
+      "description": "Return the smallest item in an iterable or the smallest of two or more arguments.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable", "description": "An iterable of comparable items" },
+        { "name": "key", "type": "Callable | None", "description": "One-argument ordering function", "optional": true },
+        { "name": "default", "type": "Any", "description": "Value to return if the iterable is empty", "optional": true }
+      ],
+      "returns": "T"
+    },
+    "max": {
+      "signature": "max(iterable, *, key=None, default=...) / max(arg1, arg2, *args, key=None)",
+      "description": "Return the largest item in an iterable or the largest of two or more arguments.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable", "description": "An iterable of comparable items" },
+        { "name": "key", "type": "Callable | None", "description": "One-argument ordering function", "optional": true },
+        { "name": "default", "type": "Any", "description": "Value to return if the iterable is empty", "optional": true }
+      ],
+      "returns": "T"
+    },
+    "sum": {
+      "signature": "sum(iterable, /, start=0)",
+      "description": "Sums start and the items of an iterable from left to right and returns the total.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable[number]", "description": "An iterable of numbers" },
+        { "name": "start", "type": "number", "description": "Starting value for the summation", "optional": true }
+      ],
+      "returns": "number"
+    },
+    "round": {
+      "signature": "round(number, ndigits=None) -> int | float",
+      "description": "Round a number to a given precision in decimal digits. Uses banker's rounding (round-half-to-even).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "number", "type": "int | float", "description": "The number to round" },
+        { "name": "ndigits", "type": "int | None", "description": "Number of decimal digits. None returns an int.", "optional": true }
+      ],
+      "returns": "int | float"
+    },
+    "input": {
+      "signature": "input(prompt='') -> str",
+      "description": "Read a line from input, convert it to a string (stripping trailing newline), and return that.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "prompt", "type": "str", "description": "The prompt string written to standard output", "optional": true }
+      ],
+      "returns": "str"
+    },
+    "repr": {
+      "signature": "repr(object) -> str",
+      "description": "Return a string containing a printable representation of an object. For many types, this returns a string that would yield an object with the same value when passed to eval().",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to represent" }
+      ],
+      "returns": "str"
+    },
+    "hash": {
+      "signature": "hash(object) -> int",
+      "description": "Return the hash value of the object (if it has one). Hash values are integers used to quickly compare dictionary keys during lookup.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Hashable", "description": "An object implementing __hash__" }
+      ],
+      "returns": "int"
+    },
+    "id": {
+      "signature": "id(object) -> int",
+      "description": "Return the identity of an object — guaranteed unique integer for this object during its lifetime. In CPython, this is the memory address.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "Any object" }
+      ],
+      "returns": "int"
+    },
+    "dir": {
+      "signature": "dir(object=...) -> list[str]",
+      "description": "Without arguments, return the list of names in the current local scope. With an argument, return a list of valid attributes for that object.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "Object to inspect", "optional": true }
+      ],
+      "returns": "list[str]"
+    },
+    "getattr": {
+      "signature": "getattr(object, name, default=...) -> Any",
+      "description": "Return the value of the named attribute of object. If default is provided, it is returned if the attribute doesn't exist.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to inspect" },
+        { "name": "name", "type": "str", "description": "The attribute name" },
+        { "name": "default", "type": "Any", "description": "Value returned if attribute doesn't exist", "optional": true }
+      ],
+      "returns": "Any"
+    },
+    "setattr": {
+      "signature": "setattr(object, name, value) -> None",
+      "description": "Set the named attribute on the given object to the specified value.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to modify" },
+        { "name": "name", "type": "str", "description": "The attribute name" },
+        { "name": "value", "type": "Any", "description": "The value to set" }
+      ],
+      "returns": "None"
+    },
+    "hasattr": {
+      "signature": "hasattr(object, name) -> bool",
+      "description": "Return True if the string is the name of one of the object's attributes.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to check" },
+        { "name": "name", "type": "str", "description": "The attribute name" }
+      ],
+      "returns": "bool"
+    },
+    "callable": {
+      "signature": "callable(object) -> bool",
+      "description": "Return True if the object appears callable (has a __call__ method).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to check" }
+      ],
+      "returns": "bool"
+    },
+    "iter": {
+      "signature": "iter(object) -> Iterator / iter(callable, sentinel) -> Iterator",
+      "description": "Return an iterator object. The first form expects an iterable. The second form calls callable until sentinel is returned.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Iterable | Callable", "description": "An iterable, or a callable (sentinel form)" },
+        { "name": "sentinel", "type": "Any", "description": "Stop value for the callable form", "optional": true }
+      ],
+      "returns": "Iterator"
+    },
+    "next": {
+      "signature": "next(iterator, default=...) -> T",
+      "description": "Retrieve the next item from the iterator by calling __next__(). If the iterator is exhausted and default is given, return it instead of raising StopIteration.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterator", "type": "Iterator[T]", "description": "An iterator" },
+        { "name": "default", "type": "T", "description": "Default value if iterator is exhausted", "optional": true }
+      ],
+      "returns": "T"
+    },
+    "reversed": {
+      "signature": "reversed(sequence) -> Iterator",
+      "description": "Return a reverse iterator over the values of the given sequence.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "sequence", "type": "Sequence | Reversible", "description": "A sequence supporting __reversed__ or __len__ and __getitem__" }
+      ],
+      "returns": "Iterator"
+    },
+    "any": {
+      "signature": "any(iterable) -> bool",
+      "description": "Return True if any element of the iterable is true. If the iterable is empty, return False.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable", "description": "An iterable to test" }
+      ],
+      "returns": "bool"
+    },
+    "all": {
+      "signature": "all(iterable) -> bool",
+      "description": "Return True if all elements of the iterable are true (or if the iterable is empty).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "iterable", "type": "Iterable", "description": "An iterable to test" }
+      ],
+      "returns": "bool"
+    },
+    "breakpoint": {
+      "signature": "breakpoint(*args, **kws) -> None",
+      "description": "Call sys.breakpointhook(), which by default drops into pdb. Set PYTHONBREAKPOINT=0 to disable.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "*args", "type": "Any", "description": "Passed to sys.breakpointhook" },
+        { "name": "**kws", "type": "Any", "description": "Passed to sys.breakpointhook" }
+      ],
+      "returns": "None"
+    },
+    "pow": {
+      "signature": "pow(base, exp, mod=None)",
+      "description": "Return base to the power exp. If mod is present, return base**exp % mod (computed efficiently).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "base", "type": "int | float", "description": "The base number" },
+        { "name": "exp", "type": "int | float", "description": "The exponent" },
+        { "name": "mod", "type": "int | None", "description": "Optional modulus for modular exponentiation", "optional": true }
+      ],
+      "returns": "int | float"
+    },
+    "divmod": {
+      "signature": "divmod(a, b) -> tuple[int, int]",
+      "description": "Return the pair (a // b, a % b).",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "a", "type": "int | float", "description": "Dividend" },
+        { "name": "b", "type": "int | float", "description": "Divisor" }
+      ],
+      "returns": "tuple[int, int]"
+    },
+    "format": {
+      "signature": "format(value, format_spec='') -> str",
+      "description": "Convert a value to a formatted representation as controlled by format_spec.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "value", "type": "Any", "description": "The value to format" },
+        { "name": "format_spec", "type": "str", "description": "Format specification string", "optional": true }
+      ],
+      "returns": "str"
+    },
+    "vars": {
+      "signature": "vars(object=...) -> dict[str, Any]",
+      "description": "Return the __dict__ attribute of the given object. Without arguments, acts like locals().",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "Object whose __dict__ to return", "optional": true }
+      ],
+      "returns": "dict[str, Any]"
+    },
+    "globals": {
+      "signature": "globals() -> dict[str, Any]",
+      "description": "Return the dictionary implementing the current module namespace.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [],
+      "returns": "dict[str, Any]"
+    },
+    "locals": {
+      "signature": "locals() -> dict[str, Any]",
+      "description": "Return a mapping of the current local symbol table.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [],
+      "returns": "dict[str, Any]"
+    },
+    "exec": {
+      "signature": "exec(code, globals=None, locals=None) -> None",
+      "description": "Dynamically execute Python code. code can be a string or code object.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "code", "type": "str | code", "description": "Python code to execute" },
+        { "name": "globals", "type": "dict | None", "description": "Global namespace", "optional": true },
+        { "name": "locals", "type": "dict | None", "description": "Local namespace", "optional": true }
+      ],
+      "returns": "None"
+    },
+    "eval": {
+      "signature": "eval(expression, globals=None, locals=None) -> Any",
+      "description": "Evaluate a single Python expression and return its value.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "expression", "type": "str | code", "description": "A Python expression" },
+        { "name": "globals", "type": "dict | None", "description": "Global namespace", "optional": true },
+        { "name": "locals", "type": "dict | None", "description": "Local namespace", "optional": true }
+      ],
+      "returns": "Any"
+    },
+    "compile": {
+      "signature": "compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) -> code",
+      "description": "Compile source into a code or AST object.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "source", "type": "str | bytes | AST", "description": "The source code to compile" },
+        { "name": "filename", "type": "str", "description": "Name of the file the code was read from" },
+        { "name": "mode", "type": "str", "description": "'exec' for module, 'eval' for expression, 'single' for interactive" }
+      ],
+      "returns": "code"
+    },
+    "issubclass": {
+      "signature": "issubclass(class, classinfo) -> bool",
+      "description": "Return True if class is a subclass (direct, indirect, or virtual) of classinfo.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "class", "type": "type", "description": "The class to check" },
+        { "name": "classinfo", "type": "type | tuple[type, ...]", "description": "A type or tuple of types" }
+      ],
+      "returns": "bool"
+    },
+    "delattr": {
+      "signature": "delattr(object, name) -> None",
+      "description": "Delete the named attribute from the given object.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "object", "type": "Any", "description": "The object to modify" },
+        { "name": "name", "type": "str", "description": "The attribute name to delete" }
+      ],
+      "returns": "None"
+    },
+    "hex": {
+      "signature": "hex(x) -> str",
+      "description": "Convert an integer to a lowercase hexadecimal string prefixed with '0x'.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "x", "type": "int", "description": "An integer" }
+      ],
+      "returns": "str"
+    },
+    "oct": {
+      "signature": "oct(x) -> str",
+      "description": "Convert an integer to an octal string prefixed with '0o'.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "x", "type": "int", "description": "An integer" }
+      ],
+      "returns": "str"
+    },
+    "bin": {
+      "signature": "bin(x) -> str",
+      "description": "Convert an integer to a binary string prefixed with '0b'.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "x", "type": "int", "description": "An integer" }
+      ],
+      "returns": "str"
+    },
+    "ord": {
+      "signature": "ord(c) -> int",
+      "description": "Return the Unicode code point for a one-character string.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "c", "type": "str", "description": "A single character string" }
+      ],
+      "returns": "int"
+    },
+    "chr": {
+      "signature": "chr(i) -> str",
+      "description": "Return the string representing a character whose Unicode code point is the integer i.",
+      "type": "function",
+      "module": "builtins",
+      "parameters": [
+        { "name": "i", "type": "int", "description": "A Unicode code point (0-1114111)" }
+      ],
+      "returns": "str"
+    }
+  }
+}