@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/python.json

@@ -0,0 +1,1427 @@
+{
+  "language": "python",
+  "completions": [
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Print objects to the text stream",
+      "documentation": { "value": "Prints the given objects to `sys.stdout` (or another stream).\n\n```python\nprint('Hello, world!')\nprint('x =', x, sep='', end='\\n')\nprint(*items, sep=', ', file=sys.stderr)\n```" },
+      "insertText": "print(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_print"
+    },
+    {
+      "label": "len",
+      "kind": 1,
+      "detail": "Return the length of an object",
+      "documentation": { "value": "Return the number of items in a container.\n\n```python\nlen([1, 2, 3])   # 3\nlen('hello')      # 5\nlen({'a': 1})     # 1\n```" },
+      "insertText": "len(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "00_len"
+    },
+    {
+      "label": "range",
+      "kind": 1,
+      "detail": "Generate a sequence of numbers",
+      "documentation": { "value": "Returns an immutable sequence of numbers.\n\n```python\nrange(10)          # 0..9\nrange(1, 11)       # 1..10\nrange(0, 20, 2)    # 0, 2, 4, …, 18\nlist(range(5))     # [0, 1, 2, 3, 4]\n```" },
+      "insertText": "range(${1:stop})",
+      "insertTextRules": 4,
+      "sortText": "00_range"
+    },
+    {
+      "label": "enumerate",
+      "kind": 1,
+      "detail": "Return an enumerate object",
+      "documentation": { "value": "Yields pairs of `(index, element)` from an iterable.\n\n```python\nfor i, val in enumerate(['a', 'b', 'c']):\n    print(i, val)\n\nfor i, val in enumerate(items, start=1):\n    print(i, val)\n```" },
+      "insertText": "enumerate(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_enumerate"
+    },
+    {
+      "label": "zip",
+      "kind": 1,
+      "detail": "Iterate over several iterables in parallel",
+      "documentation": { "value": "Yields tuples pairing elements from each iterable.\n\n```python\nfor a, b in zip([1, 2], ['x', 'y']):\n    print(a, b)\n\ndict(zip(keys, values))\nlist(zip(a, b, strict=True))  # 3.10+\n```" },
+      "insertText": "zip(${1:iter1}, ${2:iter2})",
+      "insertTextRules": 4,
+      "sortText": "00_zip"
+    },
+    {
+      "label": "map",
+      "kind": 1,
+      "detail": "Apply function to every item of iterable",
+      "documentation": { "value": "Returns an iterator that applies *function* to every item of *iterable*.\n\n```python\nlist(map(str.upper, ['hello', 'world']))\nlist(map(lambda x: x ** 2, [1, 2, 3]))\n```" },
+      "insertText": "map(${1:function}, ${2:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_map"
+    },
+    {
+      "label": "filter",
+      "kind": 1,
+      "detail": "Filter elements from iterable",
+      "documentation": { "value": "Return an iterator yielding items for which `function(item)` is true.\n\n```python\nlist(filter(lambda x: x > 0, [-1, 0, 2, 5]))\nlist(filter(None, [0, '', 'a', 1]))  # truthy values\n```" },
+      "insertText": "filter(${1:function}, ${2:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_filter"
+    },
+    {
+      "label": "sorted",
+      "kind": 1,
+      "detail": "Return a new sorted list",
+      "documentation": { "value": "Return a new list containing all items from the iterable in ascending order.\n\n```python\nsorted([3, 1, 2])                        # [1, 2, 3]\nsorted(words, key=str.lower)             # case-insensitive\nsorted(data, key=lambda x: x['age'], reverse=True)\n```" },
+      "insertText": "sorted(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_sorted"
+    },
+    {
+      "label": "reversed",
+      "kind": 1,
+      "detail": "Return a reverse iterator",
+      "documentation": { "value": "Return a reverse iterator over the sequence.\n\n```python\nlist(reversed([1, 2, 3]))  # [3, 2, 1]\nfor ch in reversed('abc'):\n    print(ch)\n```" },
+      "insertText": "reversed(${1:sequence})",
+      "insertTextRules": 4,
+      "sortText": "00_reversed"
+    },
+    {
+      "label": "any",
+      "kind": 1,
+      "detail": "Return True if any element is true",
+      "documentation": { "value": "Return `True` if any element of the iterable is true.\n\n```python\nany([False, False, True])   # True\nany(x > 0 for x in nums)   # generator expression\n```" },
+      "insertText": "any(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_any"
+    },
+    {
+      "label": "all",
+      "kind": 1,
+      "detail": "Return True if all elements are true",
+      "documentation": { "value": "Return `True` if all elements of the iterable are true (or iterable is empty).\n\n```python\nall([True, True, True])     # True\nall(x > 0 for x in nums)   # generator expression\n```" },
+      "insertText": "all(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_all"
+    },
+    {
+      "label": "isinstance",
+      "kind": 1,
+      "detail": "Check if object is an instance of a class",
+      "documentation": { "value": "Return `True` if the object is an instance of the classinfo argument.\n\n```python\nisinstance(42, int)                # True\nisinstance('hi', (str, bytes))     # True (tuple of types)\nisinstance(obj, MyProtocol)        # runtime-checkable protocol\n```" },
+      "insertText": "isinstance(${1:obj}, ${2:classinfo})",
+      "insertTextRules": 4,
+      "sortText": "00_isinstance"
+    },
+    {
+      "label": "issubclass",
+      "kind": 1,
+      "detail": "Check if a class is a subclass of another",
+      "documentation": { "value": "Return `True` if *class* is a subclass of *classinfo*.\n\n```python\nissubclass(bool, int)           # True\nissubclass(str, (int, float))   # False\n```" },
+      "insertText": "issubclass(${1:cls}, ${2:classinfo})",
+      "insertTextRules": 4,
+      "sortText": "00_issubclass"
+    },
+    {
+      "label": "type",
+      "kind": 1,
+      "detail": "Return the type of an object",
+      "documentation": { "value": "With one argument, return the type of an object. With three arguments, create a new type.\n\n```python\ntype(42)          # <class 'int'>\ntype('hello')     # <class 'str'>\nMyClass = type('MyClass', (Base,), {'x': 10})\n```" },
+      "insertText": "type(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_type"
+    },
+    {
+      "label": "id",
+      "kind": 1,
+      "detail": "Return the identity of an object",
+      "documentation": { "value": "Return the identity of an object — guaranteed unique integer for its lifetime.\n\n```python\nid(obj)\na is b  # equivalent to id(a) == id(b)\n```" },
+      "insertText": "id(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_id"
+    },
+    {
+      "label": "hash",
+      "kind": 1,
+      "detail": "Return the hash value of an object",
+      "documentation": { "value": "Return the hash value of the object (if it has one).\n\n```python\nhash('hello')    # deterministic within a process\nhash((1, 2, 3)) # tuples are hashable\n```" },
+      "insertText": "hash(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_hash"
+    },
+    {
+      "label": "dir",
+      "kind": 1,
+      "detail": "List names in the current scope or object attributes",
+      "documentation": { "value": "Without arguments, return names in the current scope. With an argument, return a list of valid attributes for that object.\n\n```python\ndir()          # current scope names\ndir([])        # list attributes\ndir(str)       # string class attributes\n```" },
+      "insertText": "dir(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_dir"
+    },
+    {
+      "label": "vars",
+      "kind": 1,
+      "detail": "Return __dict__ of an object",
+      "documentation": { "value": "Return the `__dict__` attribute for a module, class, instance, or any other object.\n\n```python\nvars()       # same as locals()\nvars(obj)    # obj.__dict__\n```" },
+      "insertText": "vars(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_vars"
+    },
+    {
+      "label": "getattr",
+      "kind": 1,
+      "detail": "Get a named attribute from an object",
+      "documentation": { "value": "Return the value of the named attribute of object. An optional default is returned if the attribute doesn't exist.\n\n```python\ngetattr(obj, 'name')\ngetattr(obj, 'name', 'default_value')\n```" },
+      "insertText": "getattr(${1:object}, ${2:'attribute'})",
+      "insertTextRules": 4,
+      "sortText": "00_getattr"
+    },
+    {
+      "label": "setattr",
+      "kind": 1,
+      "detail": "Set a named attribute on an object",
+      "documentation": { "value": "Set the named attribute on the given object to the specified value.\n\n```python\nsetattr(obj, 'name', value)\n# equivalent to: obj.name = value\n```" },
+      "insertText": "setattr(${1:object}, ${2:'attribute'}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "00_setattr"
+    },
+    {
+      "label": "hasattr",
+      "kind": 1,
+      "detail": "Check if an object has an attribute",
+      "documentation": { "value": "Return `True` if the string is the name of one of the object's attributes.\n\n```python\nhasattr(obj, 'name')  # True or False\n```" },
+      "insertText": "hasattr(${1:object}, ${2:'attribute'})",
+      "insertTextRules": 4,
+      "sortText": "00_hasattr"
+    },
+    {
+      "label": "delattr",
+      "kind": 1,
+      "detail": "Delete a named attribute from an object",
+      "documentation": { "value": "Delete the named attribute from the object (if the object allows it).\n\n```python\ndelattr(obj, 'name')\n# equivalent to: del obj.name\n```" },
+      "insertText": "delattr(${1:object}, ${2:'attribute'})",
+      "insertTextRules": 4,
+      "sortText": "00_delattr"
+    },
+    {
+      "label": "property",
+      "kind": 5,
+      "detail": "Built-in property descriptor",
+      "documentation": { "value": "Return a property attribute. Typically used as a decorator.\n\n```python\nclass C:\n    @property\n    def x(self) -> int:\n        return self._x\n\n    @x.setter\n    def x(self, value: int) -> None:\n        self._x = value\n```" },
+      "insertText": "@property\ndef ${1:name}(self) -> ${2:type}:\n    return self._${1:name}",
+      "insertTextRules": 4,
+      "sortText": "00_property"
+    },
+    {
+      "label": "classmethod",
+      "kind": 14,
+      "detail": "Declare a class method",
+      "documentation": { "value": "Transform a method into a class method. Receives the class as the first argument instead of an instance.\n\n```python\nclass MyClass:\n    @classmethod\n    def from_string(cls, s: str) -> 'MyClass':\n        return cls(s)\n```" },
+      "insertText": "@classmethod\ndef ${1:name}(cls${2:, args}) -> ${3:type}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "00_classmethod"
+    },
+    {
+      "label": "staticmethod",
+      "kind": 14,
+      "detail": "Declare a static method",
+      "documentation": { "value": "Transform a method into a static method. Does not receive an implicit first argument.\n\n```python\nclass Math:\n    @staticmethod\n    def add(a: int, b: int) -> int:\n        return a + b\n```" },
+      "insertText": "@staticmethod\ndef ${1:name}(${2:args}) -> ${3:type}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "00_staticmethod"
+    },
+    {
+      "label": "super",
+      "kind": 1,
+      "detail": "Return a proxy object for parent class",
+      "documentation": { "value": "Return a proxy object that delegates method calls to a parent or sibling class.\n\n```python\nclass Child(Parent):\n    def __init__(self):\n        super().__init__()\n```" },
+      "insertText": "super()",
+      "insertTextRules": 4,
+      "sortText": "00_super"
+    },
+    {
+      "label": "abs",
+      "kind": 1,
+      "detail": "Return absolute value",
+      "documentation": { "value": "Return the absolute value of a number.\n\n```python\nabs(-5)      # 5\nabs(3.14)    # 3.14\nabs(-2+3j)   # 3.605551275…\n```" },
+      "insertText": "abs(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_abs"
+    },
+    {
+      "label": "min",
+      "kind": 1,
+      "detail": "Return the smallest item",
+      "documentation": { "value": "Return the smallest item in an iterable or the smallest of two or more arguments.\n\n```python\nmin([3, 1, 2])              # 1\nmin('hello', key=ord)       # 'e'\nmin(a, b, default=0)\n```" },
+      "insertText": "min(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_min"
+    },
+    {
+      "label": "max",
+      "kind": 1,
+      "detail": "Return the largest item",
+      "documentation": { "value": "Return the largest item in an iterable or the largest of two or more arguments.\n\n```python\nmax([3, 1, 2])              # 3\nmax(words, key=len)         # longest word\nmax(a, b, default=0)\n```" },
+      "insertText": "max(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_max"
+    },
+    {
+      "label": "sum",
+      "kind": 1,
+      "detail": "Sum items of an iterable",
+      "documentation": { "value": "Sums *start* and the items of an iterable from left to right.\n\n```python\nsum([1, 2, 3])          # 6\nsum(range(100))         # 4950\nsum(prices, start=0.0)\n```" },
+      "insertText": "sum(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_sum"
+    },
+    {
+      "label": "round",
+      "kind": 1,
+      "detail": "Round a number to a given precision",
+      "documentation": { "value": "Round a number to a given precision in decimal digits.\n\n```python\nround(3.14159, 2)   # 3.14\nround(2.5)          # 2 (banker's rounding)\nround(1234, -2)     # 1200\n```" },
+      "insertText": "round(${1:number}, ${2:ndigits})",
+      "insertTextRules": 4,
+      "sortText": "00_round"
+    },
+    {
+      "label": "pow",
+      "kind": 1,
+      "detail": "Return base to the power exp",
+      "documentation": { "value": "Return `base ** exp`; if `mod` is present, return `base ** exp % mod`.\n\n```python\npow(2, 10)        # 1024\npow(2, 10, 1000)  # 24  (modular exponentiation)\n```" },
+      "insertText": "pow(${1:base}, ${2:exp})",
+      "insertTextRules": 4,
+      "sortText": "00_pow"
+    },
+    {
+      "label": "divmod",
+      "kind": 1,
+      "detail": "Return quotient and remainder",
+      "documentation": { "value": "Return a pair `(quotient, remainder)` of the division.\n\n```python\ndivmod(17, 5)   # (3, 2)\nq, r = divmod(a, b)\n```" },
+      "insertText": "divmod(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "00_divmod"
+    },
+    {
+      "label": "int",
+      "kind": 5,
+      "detail": "Integer type / convert to integer",
+      "documentation": { "value": "Return an integer from a number or string.\n\n```python\nint('42')        # 42\nint(3.9)         # 3 (truncates)\nint('ff', 16)    # 255\n```" },
+      "insertText": "int(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_int"
+    },
+    {
+      "label": "float",
+      "kind": 5,
+      "detail": "Floating point type / convert to float",
+      "documentation": { "value": "Return a floating point number from a number or string.\n\n```python\nfloat('3.14')      # 3.14\nfloat('inf')       # inf\nfloat.fromhex('0x1.0p10')  # 1024.0\n```" },
+      "insertText": "float(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_float"
+    },
+    {
+      "label": "str",
+      "kind": 5,
+      "detail": "String type / convert to string",
+      "documentation": { "value": "Return a string version of the object.\n\n```python\nstr(42)          # '42'\nstr(b'hi', 'utf-8')  # 'hi'\n```" },
+      "insertText": "str(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_str"
+    },
+    {
+      "label": "bool",
+      "kind": 5,
+      "detail": "Boolean type / convert to boolean",
+      "documentation": { "value": "Return a Boolean value. Falsy values: `None`, `False`, `0`, `''`, `[]`, `{}`, etc.\n\n```python\nbool(0)      # False\nbool([1])    # True\nbool('')     # False\n```" },
+      "insertText": "bool(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_bool"
+    },
+    {
+      "label": "list",
+      "kind": 5,
+      "detail": "List type / convert to list",
+      "documentation": { "value": "Return a list. With no argument returns an empty list. With an iterable argument returns a list of its items.\n\n```python\nlist()               # []\nlist(range(5))       # [0, 1, 2, 3, 4]\nlist('abc')          # ['a', 'b', 'c']\n```" },
+      "insertText": "list(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_list"
+    },
+    {
+      "label": "dict",
+      "kind": 5,
+      "detail": "Dictionary type / create a dict",
+      "documentation": { "value": "Create a new dictionary.\n\n```python\ndict()                       # {}\ndict(a=1, b=2)               # {'a': 1, 'b': 2}\ndict(zip(keys, values))\ndict.fromkeys(['a', 'b'], 0) # {'a': 0, 'b': 0}\n```" },
+      "insertText": "dict(${1:})",
+      "insertTextRules": 4,
+      "sortText": "00_dict"
+    },
+    {
+      "label": "set",
+      "kind": 5,
+      "detail": "Set type / create a set",
+      "documentation": { "value": "Return a new set object. Supports union `|`, intersection `&`, difference `-`, symmetric difference `^`.\n\n```python\nset()                # set()\nset([1, 2, 2, 3])   # {1, 2, 3}\n{1, 2} | {3}         # {1, 2, 3}\n```" },
+      "insertText": "set(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_set"
+    },
+    {
+      "label": "tuple",
+      "kind": 5,
+      "detail": "Tuple type / create a tuple",
+      "documentation": { "value": "Return an immutable sequence.\n\n```python\ntuple()             # ()\ntuple([1, 2, 3])    # (1, 2, 3)\na, b = (1, 2)       # unpacking\n```" },
+      "insertText": "tuple(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_tuple"
+    },
+    {
+      "label": "frozenset",
+      "kind": 5,
+      "detail": "Immutable set type",
+      "documentation": { "value": "Return a new frozenset object — an immutable version of a set.\n\n```python\nfrozenset([1, 2, 3])\nfrozenset('abc')  # frozenset({'a', 'b', 'c'})\n```" },
+      "insertText": "frozenset(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "00_frozenset"
+    },
+    {
+      "label": "bytes",
+      "kind": 5,
+      "detail": "Immutable bytes sequence",
+      "documentation": { "value": "Return a new bytes object.\n\n```python\nbytes(5)                   # b'\\x00\\x00\\x00\\x00\\x00'\nbytes([72, 101, 108])      # b'Hel'\n'hello'.encode('utf-8')    # b'hello'\n```" },
+      "insertText": "bytes(${1:source})",
+      "insertTextRules": 4,
+      "sortText": "00_bytes"
+    },
+    {
+      "label": "bytearray",
+      "kind": 5,
+      "detail": "Mutable bytes sequence",
+      "documentation": { "value": "Return a new array of bytes. Unlike `bytes`, `bytearray` is mutable.\n\n```python\nba = bytearray(b'hello')\nba[0] = 72\nba.extend(b' world')\n```" },
+      "insertText": "bytearray(${1:source})",
+      "insertTextRules": 4,
+      "sortText": "00_bytearray"
+    },
+    {
+      "label": "memoryview",
+      "kind": 5,
+      "detail": "Memory view object",
+      "documentation": { "value": "Create a memoryview that references a buffer without copying.\n\n```python\nmv = memoryview(b'hello')\nmv[1:3]   # memory view of b'el'\nbytes(mv) # b'hello'\n```" },
+      "insertText": "memoryview(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "00_memoryview"
+    },
+    {
+      "label": "complex",
+      "kind": 5,
+      "detail": "Complex number type",
+      "documentation": { "value": "Return a complex number.\n\n```python\ncomplex(1, 2)      # (1+2j)\ncomplex('1+2j')    # (1+2j)\n(3+4j).conjugate() # (3-4j)\n```" },
+      "insertText": "complex(${1:real}, ${2:imag})",
+      "insertTextRules": 4,
+      "sortText": "00_complex"
+    },
+    {
+      "label": "hex",
+      "kind": 1,
+      "detail": "Convert integer to hexadecimal string",
+      "documentation": { "value": "Convert an integer to a lowercase hexadecimal string prefixed with `0x`.\n\n```python\nhex(255)   # '0xff'\nhex(42)    # '0x2a'\n```" },
+      "insertText": "hex(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_hex"
+    },
+    {
+      "label": "oct",
+      "kind": 1,
+      "detail": "Convert integer to octal string",
+      "documentation": { "value": "Convert an integer to an octal string prefixed with `0o`.\n\n```python\noct(8)   # '0o10'\noct(255) # '0o377'\n```" },
+      "insertText": "oct(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_oct"
+    },
+    {
+      "label": "bin",
+      "kind": 1,
+      "detail": "Convert integer to binary string",
+      "documentation": { "value": "Convert an integer to a binary string prefixed with `0b`.\n\n```python\nbin(10)   # '0b1010'\nbin(255)  # '0b11111111'\n```" },
+      "insertText": "bin(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_bin"
+    },
+    {
+      "label": "ord",
+      "kind": 1,
+      "detail": "Return Unicode code point for a character",
+      "documentation": { "value": "Return the Unicode code point for a one-character string.\n\n```python\nord('A')   # 65\nord('€')   # 8364\n```" },
+      "insertText": "ord(${1:c})",
+      "insertTextRules": 4,
+      "sortText": "00_ord"
+    },
+    {
+      "label": "chr",
+      "kind": 1,
+      "detail": "Return character from Unicode code point",
+      "documentation": { "value": "Return the string of one character whose Unicode code point is the integer.\n\n```python\nchr(65)    # 'A'\nchr(8364)  # '€'\n```" },
+      "insertText": "chr(${1:i})",
+      "insertTextRules": 4,
+      "sortText": "00_chr"
+    },
+    {
+      "label": "repr",
+      "kind": 1,
+      "detail": "Return printable representation of an object",
+      "documentation": { "value": "Return a string containing a printable representation of an object.\n\n```python\nrepr('hello')   # \"'hello'\"\nrepr([1, 2])    # '[1, 2]'\n```" },
+      "insertText": "repr(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_repr"
+    },
+    {
+      "label": "format",
+      "kind": 1,
+      "detail": "Format a value using a format spec",
+      "documentation": { "value": "Convert a value to a formatted representation controlled by *format_spec*.\n\n```python\nformat(3.14159, '.2f')   # '3.14'\nformat(42, '08b')        # '00101010'\nformat(1000000, ',')     # '1,000,000'\n```" },
+      "insertText": "format(${1:value}, ${2:format_spec})",
+      "insertTextRules": 4,
+      "sortText": "00_format"
+    },
+    {
+      "label": "input",
+      "kind": 1,
+      "detail": "Read a line from input",
+      "documentation": { "value": "Read a line from input, optionally printing a prompt.\n\n```python\nname = input('Enter your name: ')\nage = int(input('Enter your age: '))\n```" },
+      "insertText": "input(${1:'prompt'})",
+      "insertTextRules": 4,
+      "sortText": "00_input"
+    },
+    {
+      "label": "open",
+      "kind": 1,
+      "detail": "Open a file and return a file object",
+      "documentation": { "value": "Open file and return a corresponding file object.\n\n```python\nwith open('file.txt') as f:\n    content = f.read()\n\nwith open('out.txt', 'w', encoding='utf-8') as f:\n    f.write('hello')\n\nwith open('data.bin', 'rb') as f:\n    data = f.read()\n```" },
+      "insertText": "open(${1:'filename'}, ${2:'r'}, encoding=${3:'utf-8'})",
+      "insertTextRules": 4,
+      "sortText": "00_open"
+    },
+    {
+      "label": "iter",
+      "kind": 1,
+      "detail": "Return an iterator object",
+      "documentation": { "value": "Return an iterator object. With two arguments, call `callable` until `sentinel` is returned.\n\n```python\nit = iter([1, 2, 3])\nnext(it)  # 1\n\n# sentinel form\nfor chunk in iter(lambda: f.read(8192), b''):\n    process(chunk)\n```" },
+      "insertText": "iter(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_iter"
+    },
+    {
+      "label": "next",
+      "kind": 1,
+      "detail": "Retrieve the next item from an iterator",
+      "documentation": { "value": "Retrieve the next item from the iterator by calling its `__next__()` method.\n\n```python\nit = iter([1, 2, 3])\nnext(it)             # 1\nnext(it, 'default')  # with default value\n```" },
+      "insertText": "next(${1:iterator})",
+      "insertTextRules": 4,
+      "sortText": "00_next"
+    },
+    {
+      "label": "callable",
+      "kind": 1,
+      "detail": "Check if an object is callable",
+      "documentation": { "value": "Return `True` if the object appears callable.\n\n```python\ncallable(print)      # True\ncallable(42)         # False\ncallable(lambda: 0)  # True\n```" },
+      "insertText": "callable(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_callable"
+    },
+    {
+      "label": "eval",
+      "kind": 1,
+      "detail": "Evaluate a Python expression",
+      "documentation": { "value": "Evaluate a Python expression string and return the result.\n\n```python\neval('2 + 3')             # 5\neval('len(x)', {'x': [1, 2]})\n```\n\n⚠️ Avoid with untrusted input." },
+      "insertText": "eval(${1:expression})",
+      "insertTextRules": 4,
+      "sortText": "00_eval"
+    },
+    {
+      "label": "exec",
+      "kind": 1,
+      "detail": "Execute Python code dynamically",
+      "documentation": { "value": "Execute dynamically created Python code.\n\n```python\nexec('x = 10')\nexec(open('script.py').read())\n```\n\n⚠️ Avoid with untrusted input." },
+      "insertText": "exec(${1:code})",
+      "insertTextRules": 4,
+      "sortText": "00_exec"
+    },
+    {
+      "label": "compile",
+      "kind": 1,
+      "detail": "Compile source into a code object",
+      "documentation": { "value": "Compile the source into a code or AST object.\n\n```python\ncode = compile('x + 1', '<string>', 'eval')\nresult = eval(code, {'x': 5})  # 6\n```" },
+      "insertText": "compile(${1:source}, ${2:filename}, ${3:mode})",
+      "insertTextRules": 4,
+      "sortText": "00_compile"
+    },
+    {
+      "label": "globals",
+      "kind": 1,
+      "detail": "Return dictionary of global symbol table",
+      "documentation": { "value": "Return the dictionary implementing the current module namespace.\n\n```python\nglobals()['my_var'] = 42\n```" },
+      "insertText": "globals()",
+      "insertTextRules": 4,
+      "sortText": "00_globals"
+    },
+    {
+      "label": "locals",
+      "kind": 1,
+      "detail": "Return dictionary of local symbol table",
+      "documentation": { "value": "Return a mapping of the current local symbol table.\n\n```python\ndef f():\n    x = 10\n    print(locals())  # {'x': 10}\n```" },
+      "insertText": "locals()",
+      "insertTextRules": 4,
+      "sortText": "00_locals"
+    },
+    {
+      "label": "breakpoint",
+      "kind": 1,
+      "detail": "Drop into the debugger",
+      "documentation": { "value": "Call `sys.breakpointhook()`, dropping into the debugger (pdb by default).\n\n```python\ndef buggy():\n    x = compute()\n    breakpoint()   # opens pdb here\n    return x\n```" },
+      "insertText": "breakpoint()",
+      "insertTextRules": 4,
+      "sortText": "00_breakpoint"
+    },
+    {
+      "label": ".format",
+      "kind": 0,
+      "detail": "str.format — Format string with positional/keyword args",
+      "documentation": { "value": "Perform a string formatting operation.\n\n```python\n'{} is {}'.format('Python', 'great')\n'{name} is {age}'.format(name='Alice', age=30)\n'{0:.2f}'.format(3.14159)  # '3.14'\n```" },
+      "insertText": ".format(${1:args})",
+      "insertTextRules": 4,
+      "sortText": "01_str_format"
+    },
+    {
+      "label": ".join",
+      "kind": 0,
+      "detail": "str.join — Concatenate strings from an iterable",
+      "documentation": { "value": "Return a string which is the concatenation of the strings in *iterable*, separated by the string providing this method.\n\n```python\n', '.join(['a', 'b', 'c'])   # 'a, b, c'\n'\\n'.join(lines)\n```" },
+      "insertText": ".join(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "01_str_join"
+    },
+    {
+      "label": ".split",
+      "kind": 0,
+      "detail": "str.split — Split string into a list",
+      "documentation": { "value": "Return a list of the words in the string, using *sep* as the delimiter.\n\n```python\n'a,b,c'.split(',')       # ['a', 'b', 'c']\n'hello world'.split()    # ['hello', 'world']\n'a::b::c'.split('::', 1) # ['a', 'b::c']\n```" },
+      "insertText": ".split(${1:sep})",
+      "insertTextRules": 4,
+      "sortText": "01_str_split"
+    },
+    {
+      "label": ".strip",
+      "kind": 0,
+      "detail": "str.strip — Remove leading/trailing characters",
+      "documentation": { "value": "Return a copy with leading and trailing characters removed.\n\n```python\n'  hello  '.strip()        # 'hello'\n'xxhelloxx'.strip('x')     # 'hello'\n```" },
+      "insertText": ".strip(${1:chars})",
+      "insertTextRules": 4,
+      "sortText": "01_str_strip"
+    },
+    {
+      "label": ".replace",
+      "kind": 0,
+      "detail": "str.replace — Replace occurrences of a substring",
+      "documentation": { "value": "Return a copy with all occurrences of *old* replaced by *new*.\n\n```python\n'hello world'.replace('world', 'Python')  # 'hello Python'\n'aaa'.replace('a', 'b', 2)                # 'bba'\n```" },
+      "insertText": ".replace(${1:old}, ${2:new})",
+      "insertTextRules": 4,
+      "sortText": "01_str_replace"
+    },
+    {
+      "label": ".startswith",
+      "kind": 0,
+      "detail": "str.startswith — Test string prefix",
+      "documentation": { "value": "Return `True` if the string starts with the prefix.\n\n```python\n'hello'.startswith('hel')         # True\n'hello'.startswith(('he', 'Hi'))  # True (tuple of prefixes)\n```" },
+      "insertText": ".startswith(${1:prefix})",
+      "insertTextRules": 4,
+      "sortText": "01_str_startswith"
+    },
+    {
+      "label": ".endswith",
+      "kind": 0,
+      "detail": "str.endswith — Test string suffix",
+      "documentation": { "value": "Return `True` if the string ends with the suffix.\n\n```python\n'hello.py'.endswith('.py')           # True\n'file.tar.gz'.endswith(('.gz', '.bz2'))  # True\n```" },
+      "insertText": ".endswith(${1:suffix})",
+      "insertTextRules": 4,
+      "sortText": "01_str_endswith"
+    },
+    {
+      "label": ".find",
+      "kind": 0,
+      "detail": "str.find — Find the lowest index of a substring",
+      "documentation": { "value": "Return the lowest index where substring is found, or -1 if not found.\n\n```python\n'hello world'.find('world')  # 6\n'hello'.find('xyz')          # -1\n```" },
+      "insertText": ".find(${1:sub})",
+      "insertTextRules": 4,
+      "sortText": "01_str_find"
+    },
+    {
+      "label": ".upper",
+      "kind": 0,
+      "detail": "str.upper — Return uppercased string",
+      "documentation": { "value": "Return a copy of the string with all cased characters converted to uppercase.\n\n```python\n'hello'.upper()  # 'HELLO'\n```" },
+      "insertText": ".upper()",
+      "insertTextRules": 4,
+      "sortText": "01_str_upper"
+    },
+    {
+      "label": ".lower",
+      "kind": 0,
+      "detail": "str.lower — Return lowercased string",
+      "documentation": { "value": "Return a copy of the string with all cased characters converted to lowercase.\n\n```python\n'HELLO'.lower()  # 'hello'\n```" },
+      "insertText": ".lower()",
+      "insertTextRules": 4,
+      "sortText": "01_str_lower"
+    },
+    {
+      "label": ".title",
+      "kind": 0,
+      "detail": "str.title — Return titlecased string",
+      "documentation": { "value": "Return a titlecased version: words start with uppercase, remaining lowercase.\n\n```python\n'hello world'.title()  # 'Hello World'\n```" },
+      "insertText": ".title()",
+      "insertTextRules": 4,
+      "sortText": "01_str_title"
+    },
+    {
+      "label": ".encode",
+      "kind": 0,
+      "detail": "str.encode — Encode string to bytes",
+      "documentation": { "value": "Return the string encoded to bytes.\n\n```python\n'hello'.encode('utf-8')   # b'hello'\n'€'.encode('utf-8')       # b'\\xe2\\x82\\xac'\n```" },
+      "insertText": ".encode(${1:'utf-8'})",
+      "insertTextRules": 4,
+      "sortText": "01_str_encode"
+    },
+    {
+      "label": ".decode",
+      "kind": 0,
+      "detail": "bytes.decode — Decode bytes to string",
+      "documentation": { "value": "Decode the bytes to a string.\n\n```python\nb'hello'.decode('utf-8')  # 'hello'\nb'\\xc3\\xa9'.decode()      # 'é'\n```" },
+      "insertText": ".decode(${1:'utf-8'})",
+      "insertTextRules": 4,
+      "sortText": "01_bytes_decode"
+    },
+    {
+      "label": "f-string",
+      "kind": 15,
+      "detail": "Formatted string literal (f-string)",
+      "documentation": { "value": "Create a formatted string literal using `f'...'` syntax.\n\n```python\nname = 'World'\nf'Hello, {name}!'\nf'{value:.2f}'\nf'{items!r}'\nf'{x + 1 = }'   # 3.8+ debug format\n```" },
+      "insertText": "f'${1:text {${2:expr}}}$0'",
+      "insertTextRules": 4,
+      "sortText": "01_fstring"
+    },
+    {
+      "label": ".append",
+      "kind": 0,
+      "detail": "list.append — Add item to end of list",
+      "documentation": { "value": "Append object to the end of the list.\n\n```python\nitems = [1, 2]\nitems.append(3)  # [1, 2, 3]\n```" },
+      "insertText": ".append(${1:item})",
+      "insertTextRules": 4,
+      "sortText": "01_list_append"
+    },
+    {
+      "label": ".extend",
+      "kind": 0,
+      "detail": "list.extend — Extend list with items from iterable",
+      "documentation": { "value": "Extend list by appending elements from the iterable.\n\n```python\na = [1, 2]\na.extend([3, 4])  # [1, 2, 3, 4]\n```" },
+      "insertText": ".extend(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "01_list_extend"
+    },
+    {
+      "label": ".pop",
+      "kind": 0,
+      "detail": "list.pop — Remove and return item at index",
+      "documentation": { "value": "Remove and return item at index (default last).\n\n```python\nitems = [1, 2, 3]\nitems.pop()    # 3, items = [1, 2]\nitems.pop(0)   # 1, items = [2]\n```" },
+      "insertText": ".pop(${1:index})",
+      "insertTextRules": 4,
+      "sortText": "01_list_pop"
+    },
+    {
+      "label": ".insert",
+      "kind": 0,
+      "detail": "list.insert — Insert item at index",
+      "documentation": { "value": "Insert object before index.\n\n```python\nitems = [1, 3]\nitems.insert(1, 2)  # [1, 2, 3]\n```" },
+      "insertText": ".insert(${1:index}, ${2:item})",
+      "insertTextRules": 4,
+      "sortText": "01_list_insert"
+    },
+    {
+      "label": ".remove",
+      "kind": 0,
+      "detail": "list.remove — Remove first occurrence of value",
+      "documentation": { "value": "Remove first occurrence of value. Raises `ValueError` if not found.\n\n```python\nitems = [1, 2, 3, 2]\nitems.remove(2)  # [1, 3, 2]\n```" },
+      "insertText": ".remove(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_list_remove"
+    },
+    {
+      "label": ".sort",
+      "kind": 0,
+      "detail": "list.sort — Sort list in place",
+      "documentation": { "value": "Sort the list in place.\n\n```python\nitems = [3, 1, 2]\nitems.sort()                # [1, 2, 3]\nitems.sort(reverse=True)    # [3, 2, 1]\nitems.sort(key=len)\n```" },
+      "insertText": ".sort(${1:key=${2:None}, reverse=${3:False}})",
+      "insertTextRules": 4,
+      "sortText": "01_list_sort"
+    },
+    {
+      "label": ".reverse",
+      "kind": 0,
+      "detail": "list.reverse — Reverse list in place",
+      "documentation": { "value": "Reverse the elements of the list in place.\n\n```python\nitems = [1, 2, 3]\nitems.reverse()  # [3, 2, 1]\n```" },
+      "insertText": ".reverse()",
+      "insertTextRules": 4,
+      "sortText": "01_list_reverse"
+    },
+    {
+      "label": ".copy",
+      "kind": 0,
+      "detail": "list.copy / dict.copy — Return a shallow copy",
+      "documentation": { "value": "Return a shallow copy of the list or dict.\n\n```python\noriginal = [1, 2, 3]\nclone = original.copy()\n\nd = {'a': 1}\nd2 = d.copy()\n```" },
+      "insertText": ".copy()",
+      "insertTextRules": 4,
+      "sortText": "01_copy"
+    },
+    {
+      "label": ".update",
+      "kind": 0,
+      "detail": "dict.update / set.update — Update with items",
+      "documentation": { "value": "For dict: update with key/value pairs. For set: update with elements.\n\n```python\nd = {'a': 1}\nd.update({'b': 2, 'c': 3})\nd.update(x=10)\n\ns = {1, 2}\ns.update([3, 4])\n```" },
+      "insertText": ".update(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "01_update"
+    },
+    {
+      "label": ".get",
+      "kind": 0,
+      "detail": "dict.get — Get item with default",
+      "documentation": { "value": "Return the value for key if key is in the dictionary, else default.\n\n```python\nd = {'a': 1, 'b': 2}\nd.get('a')          # 1\nd.get('z', 'N/A')   # 'N/A'\n```" },
+      "insertText": ".get(${1:key}, ${2:default})",
+      "insertTextRules": 4,
+      "sortText": "01_dict_get"
+    },
+    {
+      "label": ".items",
+      "kind": 0,
+      "detail": "dict.items — Return view of (key, value) pairs",
+      "documentation": { "value": "Return a view object that displays dict's (key, value) tuple pairs.\n\n```python\nfor key, value in d.items():\n    print(key, value)\n```" },
+      "insertText": ".items()",
+      "insertTextRules": 4,
+      "sortText": "01_dict_items"
+    },
+    {
+      "label": ".keys",
+      "kind": 0,
+      "detail": "dict.keys — Return view of dictionary keys",
+      "documentation": { "value": "Return a view object of the dictionary's keys.\n\n```python\nfor key in d.keys():\n    print(key)\n\nif 'name' in d.keys():\n    ...\n```" },
+      "insertText": ".keys()",
+      "insertTextRules": 4,
+      "sortText": "01_dict_keys"
+    },
+    {
+      "label": ".values",
+      "kind": 0,
+      "detail": "dict.values — Return view of dictionary values",
+      "documentation": { "value": "Return a view object of the dictionary's values.\n\n```python\nfor val in d.values():\n    print(val)\n\ntotal = sum(d.values())\n```" },
+      "insertText": ".values()",
+      "insertTextRules": 4,
+      "sortText": "01_dict_values"
+    },
+    {
+      "label": ".add",
+      "kind": 0,
+      "detail": "set.add — Add an element to the set",
+      "documentation": { "value": "Add an element to the set.\n\n```python\ns = {1, 2}\ns.add(3)  # {1, 2, 3}\ns.add(2)  # {1, 2, 3} (no duplicate)\n```" },
+      "insertText": ".add(${1:elem})",
+      "insertTextRules": 4,
+      "sortText": "01_set_add"
+    },
+    {
+      "label": ".discard",
+      "kind": 0,
+      "detail": "set.discard — Remove element if present",
+      "documentation": { "value": "Remove an element from the set if it is present. Does NOT raise an error if absent.\n\n```python\ns = {1, 2, 3}\ns.discard(2)   # {1, 3}\ns.discard(99)  # no error\n```" },
+      "insertText": ".discard(${1:elem})",
+      "insertTextRules": 4,
+      "sortText": "01_set_discard"
+    },
+    {
+      "label": "if",
+      "kind": 15,
+      "detail": "if / elif / else statement",
+      "documentation": { "value": "Conditional branching.\n\n```python\nif condition:\n    ...\nelif other:\n    ...\nelse:\n    ...\n```" },
+      "insertText": "if ${1:condition}:\n    ${2:pass}\nelif ${3:condition}:\n    ${4:pass}\nelse:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_if"
+    },
+    {
+      "label": "if (simple)",
+      "kind": 15,
+      "detail": "Simple if statement",
+      "documentation": { "value": "```python\nif condition:\n    do_something()\n```" },
+      "insertText": "if ${1:condition}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_if_simple"
+    },
+    {
+      "label": "for",
+      "kind": 15,
+      "detail": "for loop",
+      "documentation": { "value": "Iterate over an iterable.\n\n```python\nfor item in iterable:\n    print(item)\n\nfor i, val in enumerate(items):\n    print(i, val)\n```" },
+      "insertText": "for ${1:item} in ${2:iterable}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_for"
+    },
+    {
+      "label": "for enumerate",
+      "kind": 15,
+      "detail": "for loop with enumerate",
+      "documentation": { "value": "```python\nfor i, item in enumerate(items):\n    print(i, item)\n```" },
+      "insertText": "for ${1:i}, ${2:item} in enumerate(${3:iterable}):\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_for_enum"
+    },
+    {
+      "label": "while",
+      "kind": 15,
+      "detail": "while loop",
+      "documentation": { "value": "```python\nwhile condition:\n    do_something()\n```" },
+      "insertText": "while ${1:condition}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_while"
+    },
+    {
+      "label": "try/except",
+      "kind": 15,
+      "detail": "try / except / finally block",
+      "documentation": { "value": "Exception handling.\n\n```python\ntry:\n    risky()\nexcept ValueError as e:\n    handle(e)\nexcept (TypeError, KeyError):\n    ...\nfinally:\n    cleanup()\n```" },
+      "insertText": "try:\n    ${1:pass}\nexcept ${2:Exception} as ${3:e}:\n    ${4:raise}\nfinally:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_try"
+    },
+    {
+      "label": "try/except (simple)",
+      "kind": 15,
+      "detail": "Simple try / except block",
+      "documentation": { "value": "```python\ntry:\n    ...\nexcept Exception as e:\n    ...\n```" },
+      "insertText": "try:\n    ${1:pass}\nexcept ${2:Exception} as ${3:e}:\n    ${0:raise}",
+      "insertTextRules": 4,
+      "sortText": "02_try_simple"
+    },
+    {
+      "label": "with",
+      "kind": 15,
+      "detail": "with (context manager) statement",
+      "documentation": { "value": "Context manager — ensures cleanup.\n\n```python\nwith open('file.txt') as f:\n    data = f.read()\n\nwith lock:\n    shared_resource.update()\n```" },
+      "insertText": "with ${1:expression} as ${2:var}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_with"
+    },
+    {
+      "label": "class",
+      "kind": 15,
+      "detail": "Class definition",
+      "documentation": { "value": "Define a class.\n\n```python\nclass MyClass:\n    def __init__(self, name: str) -> None:\n        self.name = name\n\n    def greet(self) -> str:\n        return f'Hello, {self.name}'\n```" },
+      "insertText": "class ${1:ClassName}${2:(${3:BaseClass})}:\n    def __init__(self${4:, args}) -> None:\n        ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_class"
+    },
+    {
+      "label": "def",
+      "kind": 15,
+      "detail": "Function definition",
+      "documentation": { "value": "Define a function.\n\n```python\ndef greet(name: str) -> str:\n    \"\"\"Return a greeting.\"\"\"\n    return f'Hello, {name}'\n```" },
+      "insertText": "def ${1:function_name}(${2:params}) -> ${3:None}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_def"
+    },
+    {
+      "label": "async def",
+      "kind": 15,
+      "detail": "Async function definition",
+      "documentation": { "value": "Define an asynchronous coroutine.\n\n```python\nasync def fetch(url: str) -> bytes:\n    async with aiohttp.ClientSession() as session:\n        async with session.get(url) as resp:\n            return await resp.read()\n```" },
+      "insertText": "async def ${1:function_name}(${2:params}) -> ${3:None}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_async_def"
+    },
+    {
+      "label": "list comprehension",
+      "kind": 15,
+      "detail": "List comprehension",
+      "documentation": { "value": "Create a list from an expression applied to each item.\n\n```python\nsquares = [x ** 2 for x in range(10)]\nevens = [x for x in range(20) if x % 2 == 0]\npairs = [(x, y) for x in a for y in b]\n```" },
+      "insertText": "[${1:expr} for ${2:item} in ${3:iterable}${4: if ${5:condition}}]",
+      "insertTextRules": 4,
+      "sortText": "02_listcomp"
+    },
+    {
+      "label": "dict comprehension",
+      "kind": 15,
+      "detail": "Dictionary comprehension",
+      "documentation": { "value": "Create a dict from key-value expressions.\n\n```python\n{k: v for k, v in pairs}\n{x: x**2 for x in range(5)}\n{k: v for k, v in d.items() if v > 0}\n```" },
+      "insertText": "{${1:key}: ${2:value} for ${3:item} in ${4:iterable}}",
+      "insertTextRules": 4,
+      "sortText": "02_dictcomp"
+    },
+    {
+      "label": "set comprehension",
+      "kind": 15,
+      "detail": "Set comprehension",
+      "documentation": { "value": "Create a set from an expression.\n\n```python\n{x % 3 for x in range(10)}  # {0, 1, 2}\n```" },
+      "insertText": "{${1:expr} for ${2:item} in ${3:iterable}}",
+      "insertTextRules": 4,
+      "sortText": "02_setcomp"
+    },
+    {
+      "label": "lambda",
+      "kind": 15,
+      "detail": "Lambda (anonymous function)",
+      "documentation": { "value": "Create a small anonymous function.\n\n```python\nsquare = lambda x: x ** 2\nsorted(data, key=lambda item: item['name'])\n```" },
+      "insertText": "lambda ${1:params}: ${0:expression}",
+      "insertTextRules": 4,
+      "sortText": "02_lambda"
+    },
+    {
+      "label": "decorator",
+      "kind": 15,
+      "detail": "Decorator function definition",
+      "documentation": { "value": "Define a decorator that wraps a function.\n\n```python\nimport functools\n\ndef my_decorator(func):\n    @functools.wraps(func)\n    def wrapper(*args, **kwargs):\n        # before\n        result = func(*args, **kwargs)\n        # after\n        return result\n    return wrapper\n```" },
+      "insertText": "import functools\n\ndef ${1:decorator}(func):\n    @functools.wraps(func)\n    def wrapper(*args, **kwargs):\n        ${2:# before}\n        result = func(*args, **kwargs)\n        ${3:# after}\n        return result\n    return wrapper",
+      "insertTextRules": 4,
+      "sortText": "02_decorator"
+    },
+    {
+      "label": "@dataclass",
+      "kind": 15,
+      "detail": "Dataclass definition",
+      "documentation": { "value": "Generate special methods automatically (3.7+).\n\n```python\nfrom dataclasses import dataclass, field\n\n@dataclass\nclass Point:\n    x: float\n    y: float\n    label: str = 'origin'\n    tags: list[str] = field(default_factory=list)\n```" },
+      "insertText": "from dataclasses import dataclass\n\n@dataclass\nclass ${1:ClassName}:\n    ${2:name}: ${3:str}\n    ${0:}",
+      "insertTextRules": 4,
+      "sortText": "02_dataclass"
+    },
+    {
+      "label": "match/case",
+      "kind": 15,
+      "detail": "Structural pattern matching (3.10+)",
+      "documentation": { "value": "Pattern matching with `match`/`case` (Python 3.10+).\n\n```python\nmatch command:\n    case 'quit':\n        quit()\n    case 'go' | 'move':\n        move()\n    case ['go', direction]:\n        go(direction)\n    case {'action': action, **rest}:\n        do(action, rest)\n    case _:\n        unknown()\n```" },
+      "insertText": "match ${1:subject}:\n    case ${2:pattern}:\n        ${3:pass}\n    case _:\n        ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_match"
+    },
+    {
+      "label": "type alias (3.12+)",
+      "kind": 15,
+      "detail": "Type alias statement (3.12+)",
+      "documentation": { "value": "Explicit type alias using the `type` statement (Python 3.12+).\n\n```python\ntype Vector = list[float]\ntype Matrix[T] = list[list[T]]\n```" },
+      "insertText": "type ${1:Name} = ${0:type}",
+      "insertTextRules": 4,
+      "sortText": "02_type_alias"
+    },
+    {
+      "label": "type hints (variable)",
+      "kind": 15,
+      "detail": "Variable annotation with type hint",
+      "documentation": { "value": "```python\nname: str = 'Alice'\ncount: int = 0\nitems: list[str] = []\ndata: dict[str, Any] = {}\n```" },
+      "insertText": "${1:name}: ${2:type} = ${0:value}",
+      "insertTextRules": 4,
+      "sortText": "02_type_var"
+    },
+    {
+      "label": "from typing import",
+      "kind": 15,
+      "detail": "Import from typing module",
+      "documentation": { "value": "Import commonly used typing constructs.\n\n```python\nfrom typing import Optional, Union, Any, TypeVar\nfrom typing import Protocol, TypeAlias, Self\nfrom typing import Final, Literal, TypeGuard\n```" },
+      "insertText": "from typing import ${0:Any}",
+      "insertTextRules": 4,
+      "sortText": "03_import_typing"
+    },
+    {
+      "label": "import json",
+      "kind": 9,
+      "detail": "Import json module",
+      "documentation": { "value": "JSON encoder and decoder.\n\n```python\nimport json\n\ndata = json.loads('{\"key\": \"value\"}')\ntext = json.dumps(data, indent=2)\n\nwith open('data.json') as f:\n    data = json.load(f)\n```" },
+      "insertText": "import json",
+      "insertTextRules": 1,
+      "sortText": "03_import_json"
+    },
+    {
+      "label": "import os",
+      "kind": 9,
+      "detail": "Import os module",
+      "documentation": { "value": "Miscellaneous operating system interfaces.\n\n```python\nimport os\n\nos.path.join('dir', 'file.txt')\nos.environ.get('HOME')\nos.listdir('.')\nos.makedirs('path/to/dir', exist_ok=True)\n```" },
+      "insertText": "import os",
+      "insertTextRules": 1,
+      "sortText": "03_import_os"
+    },
+    {
+      "label": "import sys",
+      "kind": 9,
+      "detail": "Import sys module",
+      "documentation": { "value": "System-specific parameters and functions.\n\n```python\nimport sys\n\nsys.argv          # command-line arguments\nsys.path          # module search path\nsys.exit(0)       # exit the program\nsys.version_info  # Python version\n```" },
+      "insertText": "import sys",
+      "insertTextRules": 1,
+      "sortText": "03_import_sys"
+    },
+    {
+      "label": "from pathlib import Path",
+      "kind": 9,
+      "detail": "Import pathlib.Path",
+      "documentation": { "value": "Object-oriented filesystem paths.\n\n```python\nfrom pathlib import Path\n\np = Path('data') / 'file.txt'\np.read_text(encoding='utf-8')\np.exists()\np.mkdir(parents=True, exist_ok=True)\nlist(Path('.').glob('**/*.py'))\n```" },
+      "insertText": "from pathlib import Path",
+      "insertTextRules": 1,
+      "sortText": "03_import_pathlib"
+    },
+    {
+      "label": "import asyncio",
+      "kind": 9,
+      "detail": "Import asyncio module",
+      "documentation": { "value": "Asynchronous I/O framework.\n\n```python\nimport asyncio\n\nasync def main():\n    await asyncio.sleep(1)\n    tasks = [asyncio.create_task(coro()) for coro in coros]\n    results = await asyncio.gather(*tasks)\n\nasyncio.run(main())\n```" },
+      "insertText": "import asyncio",
+      "insertTextRules": 1,
+      "sortText": "03_import_asyncio"
+    },
+    {
+      "label": "from dataclasses import dataclass",
+      "kind": 9,
+      "detail": "Import dataclass decorator",
+      "documentation": { "value": "```python\nfrom dataclasses import dataclass, field\n```" },
+      "insertText": "from dataclasses import dataclass",
+      "insertTextRules": 1,
+      "sortText": "03_import_dataclasses"
+    },
+    {
+      "label": "import collections",
+      "kind": 9,
+      "detail": "Import collections module",
+      "documentation": { "value": "High-performance container datatypes.\n\n```python\nimport collections\n\ncollections.Counter('abracadabra')\ncollections.defaultdict(list)\ncollections.OrderedDict()\ncollections.deque([1, 2, 3])\ncollections.namedtuple('Point', ['x', 'y'])\n```" },
+      "insertText": "import collections",
+      "insertTextRules": 1,
+      "sortText": "03_import_collections"
+    },
+    {
+      "label": "import itertools",
+      "kind": 9,
+      "detail": "Import itertools module",
+      "documentation": { "value": "Functions creating iterators for efficient looping.\n\n```python\nimport itertools\n\nitertools.chain([1, 2], [3, 4])\nitertools.product('AB', '12')\nitertools.combinations([1, 2, 3], 2)\nitertools.islice(range(100), 5)\n```" },
+      "insertText": "import itertools",
+      "insertTextRules": 1,
+      "sortText": "03_import_itertools"
+    },
+    {
+      "label": "import functools",
+      "kind": 9,
+      "detail": "Import functools module",
+      "documentation": { "value": "Higher-order functions and operations on callable objects.\n\n```python\nimport functools\n\n@functools.lru_cache(maxsize=128)\ndef fib(n): ...\n\nfunctools.reduce(lambda a, b: a + b, [1, 2, 3])\nfunctools.partial(func, arg1)\n```" },
+      "insertText": "import functools",
+      "insertTextRules": 1,
+      "sortText": "03_import_functools"
+    },
+    {
+      "label": "import re",
+      "kind": 9,
+      "detail": "Import re (regular expressions) module",
+      "documentation": { "value": "Regular expression operations.\n\n```python\nimport re\n\nre.search(r'\\d+', 'abc123')       # Match object\nre.findall(r'\\w+', 'hello world')  # ['hello', 'world']\nre.sub(r'\\s+', ' ', text)\npattern = re.compile(r'^\\d{3}-\\d{4}$')\n```" },
+      "insertText": "import re",
+      "insertTextRules": 1,
+      "sortText": "03_import_re"
+    },
+    {
+      "label": "Optional",
+      "kind": 5,
+      "detail": "typing.Optional — Optional type hint",
+      "documentation": { "value": "Equivalent to `Union[X, None]`. Prefer `X | None` in 3.10+.\n\n```python\nfrom typing import Optional\n\ndef find(name: str) -> Optional[int]:\n    ...  # returns int or None\n\n# 3.10+ equivalent:\ndef find(name: str) -> int | None: ...\n```" },
+      "insertText": "Optional[${1:type}]",
+      "insertTextRules": 4,
+      "sortText": "04_Optional"
+    },
+    {
+      "label": "Union",
+      "kind": 5,
+      "detail": "typing.Union — Union type hint",
+      "documentation": { "value": "Union of several types. Prefer `X | Y` in 3.10+.\n\n```python\nfrom typing import Union\n\ndef process(value: Union[str, int]) -> None: ...\n\n# 3.10+ equivalent:\ndef process(value: str | int) -> None: ...\n```" },
+      "insertText": "Union[${1:type1}, ${2:type2}]",
+      "insertTextRules": 4,
+      "sortText": "04_Union"
+    },
+    {
+      "label": "List (typing)",
+      "kind": 5,
+      "detail": "typing.List — Generic list type",
+      "documentation": { "value": "Generic version of `list`. Prefer `list[X]` in 3.9+.\n\n```python\nfrom typing import List\n\ndef get_names() -> List[str]: ...\n\n# 3.9+ equivalent:\ndef get_names() -> list[str]: ...\n```" },
+      "insertText": "List[${1:type}]",
+      "insertTextRules": 4,
+      "sortText": "04_List"
+    },
+    {
+      "label": "Dict (typing)",
+      "kind": 5,
+      "detail": "typing.Dict — Generic dict type",
+      "documentation": { "value": "Generic version of `dict`. Prefer `dict[K, V]` in 3.9+.\n\n```python\nfrom typing import Dict\n\ndef get_config() -> Dict[str, Any]: ...\n\n# 3.9+ equivalent:\ndef get_config() -> dict[str, Any]: ...\n```" },
+      "insertText": "Dict[${1:key_type}, ${2:value_type}]",
+      "insertTextRules": 4,
+      "sortText": "04_Dict"
+    },
+    {
+      "label": "Set (typing)",
+      "kind": 5,
+      "detail": "typing.Set — Generic set type",
+      "documentation": { "value": "Generic version of `set`. Prefer `set[X]` in 3.9+.\n\n```python\nfrom typing import Set\ndef unique(items: list[str]) -> Set[str]: ...\n```" },
+      "insertText": "Set[${1:type}]",
+      "insertTextRules": 4,
+      "sortText": "04_Set"
+    },
+    {
+      "label": "Tuple (typing)",
+      "kind": 5,
+      "detail": "typing.Tuple — Generic tuple type",
+      "documentation": { "value": "Generic version of `tuple`. Prefer `tuple[X, Y]` in 3.9+.\n\n```python\nfrom typing import Tuple\ndef get_pair() -> Tuple[str, int]: ...\nTuple[int, ...]  # variable length\n```" },
+      "insertText": "Tuple[${1:types}]",
+      "insertTextRules": 4,
+      "sortText": "04_Tuple"
+    },
+    {
+      "label": "Any",
+      "kind": 5,
+      "detail": "typing.Any — Unconstrained type",
+      "documentation": { "value": "Special form indicating an unconstrained type.\n\n```python\nfrom typing import Any\n\ndef process(data: Any) -> Any: ...\n```" },
+      "insertText": "Any",
+      "insertTextRules": 1,
+      "sortText": "04_Any"
+    },
+    {
+      "label": "TypeVar",
+      "kind": 5,
+      "detail": "typing.TypeVar — Type variable",
+      "documentation": { "value": "Create a type variable for generics.\n\n```python\nfrom typing import TypeVar\n\nT = TypeVar('T')\nT = TypeVar('T', bound=Comparable)\n\ndef first(items: list[T]) -> T:\n    return items[0]\n```\n\nPython 3.12+ syntax:\n```python\ndef first[T](items: list[T]) -> T:\n    return items[0]\n```" },
+      "insertText": "${1:T} = TypeVar('${1:T}')",
+      "insertTextRules": 4,
+      "sortText": "04_TypeVar"
+    },
+    {
+      "label": "Generic",
+      "kind": 5,
+      "detail": "typing.Generic — Base class for generics",
+      "documentation": { "value": "Abstract base class for generic types.\n\n```python\nfrom typing import TypeVar, Generic\n\nT = TypeVar('T')\n\nclass Stack(Generic[T]):\n    def push(self, item: T) -> None: ...\n    def pop(self) -> T: ...\n```" },
+      "insertText": "Generic[${1:T}]",
+      "insertTextRules": 4,
+      "sortText": "04_Generic"
+    },
+    {
+      "label": "Protocol",
+      "kind": 5,
+      "detail": "typing.Protocol — Structural subtyping",
+      "documentation": { "value": "Define structural (duck-typing) interfaces.\n\n```python\nfrom typing import Protocol\n\nclass Readable(Protocol):\n    def read(self) -> str: ...\n\ndef process(src: Readable) -> None:\n    data = src.read()  # works for any object with .read()\n```" },
+      "insertText": "class ${1:Name}(Protocol):\n    def ${2:method}(self${3:, args}) -> ${4:type}: ...",
+      "insertTextRules": 4,
+      "sortText": "04_Protocol"
+    },
+    {
+      "label": "TypeAlias",
+      "kind": 5,
+      "detail": "typing.TypeAlias — Explicit type alias",
+      "documentation": { "value": "Mark a variable as a type alias (3.10+).\n\n```python\nfrom typing import TypeAlias\n\nVector: TypeAlias = list[float]\nJSON: TypeAlias = dict[str, 'JSON'] | list['JSON'] | str | int | float | bool | None\n```" },
+      "insertText": "${1:Name}: TypeAlias = ${0:type}",
+      "insertTextRules": 4,
+      "sortText": "04_TypeAlias"
+    },
+    {
+      "label": "Literal",
+      "kind": 5,
+      "detail": "typing.Literal — Literal type",
+      "documentation": { "value": "Restrict a value to specific literal values.\n\n```python\nfrom typing import Literal\n\ndef set_mode(mode: Literal['r', 'w', 'a']) -> None: ...\nDirection = Literal['north', 'south', 'east', 'west']\n```" },
+      "insertText": "Literal[${1:values}]",
+      "insertTextRules": 4,
+      "sortText": "04_Literal"
+    },
+    {
+      "label": "Final",
+      "kind": 5,
+      "detail": "typing.Final — Constant declaration",
+      "documentation": { "value": "Declare that a name cannot be reassigned.\n\n```python\nfrom typing import Final\n\nMAX_SIZE: Final = 100\nMAX_SIZE: Final[int] = 100\n```" },
+      "insertText": "Final[${1:type}]",
+      "insertTextRules": 4,
+      "sortText": "04_Final"
+    },
+    {
+      "label": "TypeGuard",
+      "kind": 5,
+      "detail": "typing.TypeGuard — Type narrowing",
+      "documentation": { "value": "Use in return type of user-defined type guards (3.10+).\n\n```python\nfrom typing import TypeGuard\n\ndef is_str_list(val: list[object]) -> TypeGuard[list[str]]:\n    return all(isinstance(x, str) for x in val)\n```" },
+      "insertText": "TypeGuard[${1:type}]",
+      "insertTextRules": 4,
+      "sortText": "04_TypeGuard"
+    },
+    {
+      "label": "Self",
+      "kind": 5,
+      "detail": "typing.Self — Self type (3.11+)",
+      "documentation": { "value": "Refer to the enclosing class in return annotations.\n\n```python\nfrom typing import Self\n\nclass Builder:\n    def set_name(self, name: str) -> Self:\n        self.name = name\n        return self\n```" },
+      "insertText": "Self",
+      "insertTextRules": 1,
+      "sortText": "04_Self"
+    },
+    {
+      "label": "Never",
+      "kind": 5,
+      "detail": "typing.Never — Bottom type (3.11+)",
+      "documentation": { "value": "The bottom type — a function returning `Never` never returns normally.\n\n```python\nfrom typing import Never\n\ndef fail(msg: str) -> Never:\n    raise RuntimeError(msg)\n```" },
+      "insertText": "Never",
+      "insertTextRules": 1,
+      "sortText": "04_Never"
+    },
+    {
+      "label": "Unpack",
+      "kind": 5,
+      "detail": "typing.Unpack — Unpack type (3.11+)",
+      "documentation": { "value": "Unpack a TypedDict for `**kwargs` typing.\n\n```python\nfrom typing import TypedDict, Unpack\n\nclass Options(TypedDict):\n    timeout: int\n    retries: int\n\ndef request(url: str, **kwargs: Unpack[Options]) -> None: ...\n```" },
+      "insertText": "Unpack[${1:TypedDict}]",
+      "insertTextRules": 4,
+      "sortText": "04_Unpack"
+    },
+    {
+      "label": "TypeVarTuple",
+      "kind": 5,
+      "detail": "typing.TypeVarTuple — Variadic type variable (3.11+)",
+      "documentation": { "value": "Type variable tuple for variadic generics.\n\n```python\nfrom typing import TypeVarTuple\n\nTs = TypeVarTuple('Ts')\n\ndef compose(*funcs: *Ts) -> None: ...\n```" },
+      "insertText": "${1:Ts} = TypeVarTuple('${1:Ts}')",
+      "insertTextRules": 4,
+      "sortText": "04_TypeVarTuple"
+    },
+    {
+      "label": "ExceptionGroup",
+      "kind": 5,
+      "detail": "ExceptionGroup (3.11+)",
+      "documentation": { "value": "Group multiple exceptions together for concurrent error handling.\n\n```python\ntry:\n    async with asyncio.TaskGroup() as tg:\n        tg.create_task(task1())\n        tg.create_task(task2())\nexcept* ValueError as eg:\n    for e in eg.exceptions:\n        print(e)\nexcept* TypeError as eg:\n    ...\n```" },
+      "insertText": "ExceptionGroup('${1:message}', [${2:exceptions}])",
+      "insertTextRules": 4,
+      "sortText": "04_ExceptionGroup"
+    },
+    {
+      "label": "__init__",
+      "kind": 0,
+      "detail": "Constructor method",
+      "documentation": { "value": "Instance initializer.\n\n```python\ndef __init__(self, name: str, value: int = 0) -> None:\n    self.name = name\n    self.value = value\n```" },
+      "insertText": "def __init__(self, ${1:params}) -> None:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02___init__"
+    },
+    {
+      "label": "__repr__",
+      "kind": 0,
+      "detail": "Official string representation",
+      "documentation": { "value": "Return a developer-friendly string representation.\n\n```python\ndef __repr__(self) -> str:\n    return f'{type(self).__name__}({self.name!r})'\n```" },
+      "insertText": "def __repr__(self) -> str:\n    return f'${1:{type(self).__name__}(${2:})}'",
+      "insertTextRules": 4,
+      "sortText": "02___repr__"
+    },
+    {
+      "label": "__str__",
+      "kind": 0,
+      "detail": "Informal string representation",
+      "documentation": { "value": "Return a user-friendly string representation.\n\n```python\ndef __str__(self) -> str:\n    return self.name\n```" },
+      "insertText": "def __str__(self) -> str:\n    return ${0:self.name}",
+      "insertTextRules": 4,
+      "sortText": "02___str__"
+    },
+    {
+      "label": "__enter__ / __exit__",
+      "kind": 15,
+      "detail": "Context manager protocol",
+      "documentation": { "value": "Implement the context manager protocol.\n\n```python\nclass MyContext:\n    def __enter__(self) -> 'MyContext':\n        return self\n\n    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:\n        # cleanup\n        return False  # don't suppress exceptions\n```" },
+      "insertText": "def __enter__(self) -> '${1:Self}':\n    return self\n\ndef __exit__(self, exc_type, exc_val, exc_tb) -> bool:\n    ${0:return False}",
+      "insertTextRules": 4,
+      "sortText": "02___enter__"
+    },
+    {
+      "label": "if __name__ == '__main__'",
+      "kind": 15,
+      "detail": "Main entry point guard",
+      "documentation": { "value": "Guard for code that should only run when the module is executed directly.\n\n```python\nif __name__ == '__main__':\n    main()\n```" },
+      "insertText": "if __name__ == '__main__':\n    ${0:main()}",
+      "insertTextRules": 4,
+      "sortText": "02_main_guard"
+    },
+    {
+      "label": "async for",
+      "kind": 15,
+      "detail": "Async for loop",
+      "documentation": { "value": "Iterate over an asynchronous iterable.\n\n```python\nasync for item in aiter:\n    await process(item)\n```" },
+      "insertText": "async for ${1:item} in ${2:aiter}:\n    ${0:await process(item)}",
+      "insertTextRules": 4,
+      "sortText": "02_async_for"
+    },
+    {
+      "label": "async with",
+      "kind": 15,
+      "detail": "Async context manager",
+      "documentation": { "value": "Use an asynchronous context manager.\n\n```python\nasync with aiohttp.ClientSession() as session:\n    async with session.get(url) as resp:\n        data = await resp.json()\n```" },
+      "insertText": "async with ${1:expression} as ${2:var}:\n    ${0:pass}",
+      "insertTextRules": 4,
+      "sortText": "02_async_with"
+    },
+    {
+      "label": "yield",
+      "kind": 14,
+      "detail": "Yield a value from a generator",
+      "documentation": { "value": "Produce a value in a generator function.\n\n```python\ndef count_up(n):\n    for i in range(n):\n        yield i\n\ndef delegator():\n    yield from sub_generator()\n```" },
+      "insertText": "yield ${0:value}",
+      "insertTextRules": 4,
+      "sortText": "02_yield"
+    },
+    {
+      "label": "raise",
+      "kind": 14,
+      "detail": "Raise an exception",
+      "documentation": { "value": "Raise an exception.\n\n```python\nraise ValueError('invalid input')\nraise TypeError(f'expected str, got {type(x).__name__}')\nraise  # re-raise current exception\nraise NewError() from original_error\n```" },
+      "insertText": "raise ${1:ValueError}(${2:'message'})",
+      "insertTextRules": 4,
+      "sortText": "02_raise"
+    },
+    {
+      "label": "assert",
+      "kind": 14,
+      "detail": "Assert a condition",
+      "documentation": { "value": "Debug assertion — removed when running with `-O`.\n\n```python\nassert x > 0, f'x must be positive, got {x}'\nassert isinstance(obj, MyClass)\n```" },
+      "insertText": "assert ${1:condition}, ${2:'message'}",
+      "insertTextRules": 4,
+      "sortText": "02_assert"
+    },
+    {
+      "label": ".setdefault",
+      "kind": 0,
+      "detail": "dict.setdefault — Get or set default value for key",
+      "documentation": { "value": "If key is in the dictionary, return its value. If not, insert key with a value of default and return default.\n\n```python\nd = {'a': 1}\nd.setdefault('b', 0)   # 0, d = {'a': 1, 'b': 0}\nd.setdefault('a', 99)  # 1 (unchanged)\n```" },
+      "insertText": ".setdefault(${1:key}, ${2:default})",
+      "insertTextRules": 4,
+      "sortText": "01_dict_setdefault"
+    },
+    {
+      "label": ".pop (dict)",
+      "kind": 0,
+      "detail": "dict.pop — Remove and return value for key",
+      "documentation": { "value": "Remove specified key and return its value. If key is not found, return default or raise KeyError.\n\n```python\nd = {'a': 1, 'b': 2}\nd.pop('a')          # 1\nd.pop('z', None)    # None\n```" },
+      "insertText": ".pop(${1:key}, ${2:default})",
+      "insertTextRules": 4,
+      "sortText": "01_dict_pop"
+    },
+    {
+      "label": ".intersection",
+      "kind": 0,
+      "detail": "set.intersection — Return common elements",
+      "documentation": { "value": "Return a new set with elements common to the set and all others.\n\n```python\n{1, 2, 3}.intersection({2, 3, 4})  # {2, 3}\n# equivalent: {1, 2, 3} & {2, 3, 4}\n```" },
+      "insertText": ".intersection(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "01_set_intersection"
+    },
+    {
+      "label": ".union",
+      "kind": 0,
+      "detail": "set.union — Return all elements from both sets",
+      "documentation": { "value": "Return a new set with elements from the set and all others.\n\n```python\n{1, 2}.union({2, 3})  # {1, 2, 3}\n# equivalent: {1, 2} | {2, 3}\n```" },
+      "insertText": ".union(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "01_set_union"
+    },
+    {
+      "label": ".difference",
+      "kind": 0,
+      "detail": "set.difference — Return elements not in other set",
+      "documentation": { "value": "Return a new set with elements in the set that are not in the others.\n\n```python\n{1, 2, 3}.difference({2, 3, 4})  # {1}\n# equivalent: {1, 2, 3} - {2, 3, 4}\n```" },
+      "insertText": ".difference(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "01_set_difference"
+    }
+  ]
+}