avrae-ls 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

avrae_ls/symbols.py

@@ -1,266 +0,0 @@
-from __future__ import annotations
-
-import ast
-import logging
-from dataclasses import dataclass
-from typing import Dict, Iterable, List, Optional
-
-import draconic
-from lsprotocol import types
-
-from .argument_parsing import apply_argument_parsing
-from .parser import find_draconic_blocks
-
-log = logging.getLogger(__name__)
-
-
-@dataclass
-class SymbolEntry:
-    name: str
-    kind: types.SymbolKind
-    range: types.Range
-    selection_range: types.Range
-
-
-class SymbolTable:
-    def __init__(self, entries: List[SymbolEntry]):
-        self._entries = entries
-        self._index: Dict[str, SymbolEntry] = {entry.name: entry for entry in entries}
-
-    @property
-    def entries(self) -> List[SymbolEntry]:
-        return self._entries
-
-    def lookup(self, name: str) -> Optional[SymbolEntry]:
-        return self._index.get(name)
-
-
-def build_symbol_table(source: str) -> SymbolTable:
-    entries: list[SymbolEntry] = []
-    parsed_source = apply_argument_parsing(source)
-    blocks = find_draconic_blocks(parsed_source)
-    if not blocks:
-        entries.extend(_symbols_from_code(parsed_source, 0, 0))
-    else:
-        for block in blocks:
-            entries.extend(_symbols_from_code(block.code, block.line_offset, block.char_offset))
-    return SymbolTable(entries)
-
-
-def document_symbols(source: str) -> List[types.DocumentSymbol]:
-    table = build_symbol_table(source)
-    return [
-        types.DocumentSymbol(
-            name=entry.name,
-            kind=entry.kind,
-            range=entry.range,
-            selection_range=entry.selection_range,
-        )
-        for entry in table.entries
-    ]
-
-
-def find_definition_range(table: SymbolTable, name: str) -> types.Range | None:
-    entry = table.lookup(name)
-    if entry:
-        return entry.selection_range
-    return None
-
-
-def find_references(
-    table: SymbolTable, source: str, name: str, include_declaration: bool = True
-) -> List[types.Range]:
-    parsed_source = apply_argument_parsing(source)
-    ranges: list[types.Range] = []
-    entry = table.lookup(name)
-    include_stores = include_declaration and entry is None
-    if include_declaration:
-        if entry:
-            ranges.append(entry.selection_range)
-
-    blocks = find_draconic_blocks(parsed_source)
-    if not blocks:
-        ranges.extend(_references_from_code(parsed_source, name, 0, 0, include_stores))
-    else:
-        for block in blocks:
-            ranges.extend(
-                _references_from_code(block.code, name, block.line_offset, block.char_offset, include_stores)
-            )
-    return _dedupe_ranges(ranges)
-
-
-def range_for_word(source: str, position: types.Position) -> types.Range | None:
-    lines = source.splitlines()
-    if position.line >= len(lines):
-        return None
-    line = lines[position.line]
-    if position.character > len(line):
-        return None
-
-    def _is_ident(ch: str) -> bool:
-        return ch.isalnum() or ch == "_"
-
-    start_idx = position.character
-    while start_idx > 0 and _is_ident(line[start_idx - 1]):
-        start_idx -= 1
-
-    end_idx = position.character
-    while end_idx < len(line) and _is_ident(line[end_idx]):
-        end_idx += 1
-
-    if start_idx == end_idx:
-        return None
-
-    return types.Range(
-        start=types.Position(line=position.line, character=start_idx),
-        end=types.Position(line=position.line, character=end_idx),
-    )
-
-
-def _symbols_from_code(code: str, line_offset: int, char_offset: int) -> List[SymbolEntry]:
-    body, offset_adjust = _parse_draconic(code)
-    if not body:
-        return []
-
-    local_offset = line_offset + offset_adjust
-
-    entries: list[SymbolEntry] = []
-    for node in body:
-        entry = _entry_from_node(node, local_offset, char_offset)
-        if entry:
-            entries.append(entry)
-    return entries
-
-
-def _entry_from_node(node: ast.AST, line_offset: int = 0, char_offset: int = 0) -> SymbolEntry | None:
-    if isinstance(node, ast.FunctionDef):
-        kind = types.SymbolKind.Function
-        name = node.name
-    elif isinstance(node, ast.ClassDef):
-        kind = types.SymbolKind.Class
-        name = node.name
-    elif isinstance(node, ast.Assign) and node.targets:
-        target = node.targets[0]
-        if isinstance(target, ast.Name):
-            kind = types.SymbolKind.Variable
-            name = target.id
-            node = target
-        else:
-            return None
-    else:
-        return None
-
-    rng = _range_from_positions(
-        getattr(node, "lineno", 1),
-        getattr(node, "col_offset", 0),
-        getattr(node, "end_lineno", None),
-        getattr(node, "end_col_offset", None),
-    )
-    rng = _shift_range(rng, line_offset, char_offset)
-    return SymbolEntry(name=name, kind=kind, range=rng, selection_range=rng)
-
-
-class _ReferenceCollector(ast.NodeVisitor):
-    def __init__(self, target: str, include_stores: bool):
-        super().__init__()
-        self._target = target
-        self._include_stores = include_stores
-        self.ranges: list[types.Range] = []
-
-    def visit_Name(self, node: ast.Name):  # type: ignore[override]
-        if node.id == self._target:
-            if isinstance(node.ctx, ast.Store) and not self._include_stores:
-                return
-            rng = _range_from_positions(
-                getattr(node, "lineno", 1),
-                getattr(node, "col_offset", 0),
-                getattr(node, "end_lineno", None),
-                getattr(node, "end_col_offset", None),
-            )
-            self.ranges.append(rng)
-        self.generic_visit(node)
-
-
-def _references_from_code(
-    code: str,
-    name: str,
-    line_offset: int,
-    char_offset: int,
-    include_stores: bool,
-) -> List[types.Range]:
-    body, offset_adjust = _parse_draconic(code)
-    if not body:
-        return []
-
-    collector = _ReferenceCollector(name, include_stores)
-    for node in body:
-        collector.visit(node)
-
-    local_offset = line_offset + offset_adjust
-    return [_shift_range(rng, local_offset, char_offset) for rng in collector.ranges]
-
-
-def _parse_draconic(code: str) -> tuple[list[ast.AST], int]:
-    parser = draconic.DraconicInterpreter()
-    try:
-        return parser.parse(code), 0
-    except draconic.DraconicSyntaxError:
-        wrapped, added = _wrap_draconic(code)
-        try:
-            return parser.parse(wrapped), -added
-        except draconic.DraconicSyntaxError:
-            return [], 0
-    except Exception as exc:  # pragma: no cover - defensive
-        log.debug("Symbol extraction failed: %s", exc)
-        return [], 0
-
-
-def _range_from_positions(
-    lineno: int | None,
-    col_offset: int | None,
-    end_lineno: int | None,
-    end_col_offset: int | None,
-) -> types.Range:
-    start_line = max((lineno or 1) - 1, 0)
-    start_char = max(col_offset or 0, 0)
-    end_line = max(((end_lineno or lineno or 1) - 1), 0)
-    raw_end_char = end_col_offset if end_col_offset is not None else col_offset
-    end_char = max(raw_end_char or start_char, start_char)
-    if end_char <= start_char:
-        end_char = start_char + 1
-    return types.Range(
-        start=types.Position(line=start_line, character=start_char),
-        end=types.Position(line=end_line, character=end_char),
-    )
-
-
-def _shift_range(rng: types.Range, line_offset: int, char_offset: int = 0) -> types.Range:
-    start_char = rng.start.character + (char_offset if rng.start.line == 0 else 0)
-    end_char = rng.end.character + (char_offset if rng.end.line == 0 else 0)
-    if line_offset == 0:
-        return types.Range(
-            start=types.Position(line=rng.start.line, character=start_char),
-            end=types.Position(line=rng.end.line, character=end_char),
-        )
-    return types.Range(
-        start=types.Position(line=max(rng.start.line + line_offset, 0), character=max(start_char, 0)),
-        end=types.Position(line=max(rng.end.line + line_offset, 0), character=max(end_char, 0)),
-    )
-
-
-def _wrap_draconic(code: str) -> tuple[str, int]:
-    indented = "\n".join(f"    {line}" for line in code.splitlines())
-    wrapped = f"def __alias_main__():\n{indented}\n__alias_main__()"
-    return wrapped, 1
-
-
-def _dedupe_ranges(ranges: Iterable[types.Range]) -> List[types.Range]:
-    seen = set()
-    unique: list[types.Range] = []
-    for rng in ranges:
-        key = (rng.start.line, rng.start.character, rng.end.line, rng.end.character)
-        if key in seen:
-            continue
-        seen.add(key)
-        unique.append(rng)
-    return unique

avrae_ls-0.4.1.dist-info/RECORD

@@ -1,34 +0,0 @@
-avrae_ls/__init__.py,sha256=BmjrnksGkbG7TPqwbyQvgYj9uei8pFSFpfkRpaGVdJU,63
-avrae_ls/__main__.py,sha256=ch287lWe11go5xHAE9OkVppixt0vRF401E4zTs2tqQ0,3557
-avrae_ls/alias_preview.py,sha256=YFUiY36runNe6R0k-9YrbGff4l3evgEsoWbVc8WT5nU,11462
-avrae_ls/api.py,sha256=_AHvIEIlz34YeWdZDpXd1EwgdQUGk8-nqNIEN4qdNR8,65093
-avrae_ls/argparser.py,sha256=DRptXGyK4f0r7NsuV1Sg4apG-qihIClOX408jgk4HH4,13762
-avrae_ls/argument_parsing.py,sha256=ezKl65VwuNEDxt6KlYwVQcpy1110UDvf4BqZqgZTcqk,2122
-avrae_ls/code_actions.py,sha256=CYl3nMzCaE9k35p5fWAmzsTOVfcv2RrkA3SbtyCdcsI,9423
-avrae_ls/codes.py,sha256=iPRPQ6i9DZheae4_ra1y29vCw3Y4SEu6Udf5WiZj_RY,136
-avrae_ls/completions.py,sha256=CvwKp3f20RsPFPnjUv03xCbuaGKIyIF7VgVhYNbig4U,51180
-avrae_ls/config.py,sha256=ULEfWbzIO05cllHBLUeGY_CHLpX6tHyCJYIEQgKSoXc,17383
-avrae_ls/context.py,sha256=KcCKqzqJCG2xlEtou5HWz1OWISApGl8IfwOvVnNi9nc,8464
-avrae_ls/cvars.py,sha256=0tcVbUHx_CKJ6aou3kEsKX37LRWAjkUWlqqIuSRFlXk,3197
-avrae_ls/diagnostics.py,sha256=wq5sBjI11NyTNtnjoZTGm1vdcvOvW7OoPHbCDAbF308,24914
-avrae_ls/dice.py,sha256=DY7V7L-EwAXaCgddgVe9xU1s9lVtiw5Zc2reipNgdTk,874
-avrae_ls/parser.py,sha256=UQDwjupuJVU6KvoF4D8r3azPT7ksP_nTZsm5FUhGnWE,1395
-avrae_ls/runtime.py,sha256=PDnjZXcU5DqM9jKSc4S0jHObBE7SWKte17PWWXGQ34M,23356
-avrae_ls/server.py,sha256=s3Cl6Ta0954FqBUh9pM326TwdUBLb7ZuyzR8vjQqs5c,15101
-avrae_ls/signature_help.py,sha256=sVQncCeLNCD3UBVPZu9ZFw0b-8wq64n3qFPLtWSy_Cs,8827
-avrae_ls/symbols.py,sha256=Lm5LH-F60JYNuAtSjRhHeyHEWAWxpnNb0w6KR0u1Zac,8422
-avrae_ls-0.4.1.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
-draconic/LICENSE,sha256=Fzvu32_DafLKKn2mzxhEdlmrKZzAsigDZ87O7uoVqZI,1067
-draconic/__init__.py,sha256=YPH420Pcn_nTkfB62hJy_YqC5kpJdzSa78jP8n4z_xY,109
-draconic/exceptions.py,sha256=siahnHIsumbaUhKBDSrw_DmLZ-0oZks8L5oytPH8hD4,3753
-draconic/helpers.py,sha256=jY-f9KHWP0ey2q09g6QsbtVxxet8LoQoZ8mAfju1E5c,9470
-draconic/interpreter.py,sha256=ksL7qHwXmXsvSqf685xFEnzVLng6AZ2ewk1z7ymbKtc,42004
-draconic/string.py,sha256=kGrRc6wNHRq1y5xw8Os-fBhfINDtIY2nBWQWkyLSfQI,2858
-draconic/types.py,sha256=1Lsr6z8bW5agglGI4hLt_nPtYuZOIf_ueSpPDB4WDrs,13686
-draconic/utils.py,sha256=D4vJ-txqS2-rlqsEpXAC46_j1sZX4UjY-9zIgElo96k,3122
-draconic/versions.py,sha256=CUEsgUWjAmjez0432WwiBwZlIzWPIObwZUf8Yld18EE,84
-avrae_ls-0.4.1.dist-info/METADATA,sha256=4kw6QJtVMqp_8pHBPra7sJXjchuCQdSOYiwj_dt7j1k,4713
-avrae_ls-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avrae_ls-0.4.1.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
-avrae_ls-0.4.1.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
-avrae_ls-0.4.1.dist-info/RECORD,,

avrae_ls-0.4.1.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-avrae_ls
-draconic

draconic/__init__.py

@@ -1,4 +0,0 @@
-from .exceptions import *
-from .helpers import DraconicConfig
-from .interpreter import *
-from . import utils

draconic/exceptions.py

@@ -1,157 +0,0 @@
-import abc
-import ast
-
-from .versions import PY_310
-
-__all__ = (
-    "DraconicException",
-    "DraconicSyntaxError",
-    "InvalidExpression",
-    "NotDefined",
-    "FeatureNotAvailable",
-    "DraconicValueError",
-    "LimitException",
-    "NumberTooHigh",
-    "IterableTooLong",
-    "TooManyStatements",
-    "TooMuchRecursion",
-    "WrappedException",
-    "AnnotatedException",
-    "NestedException",
-    "_PostponedRaise",
-    "_raise_in_context",
-)
-
-
-class DraconicException(Exception):
-    """Base exception for all exceptions in this library."""
-
-    __drac_context__: str = None
-
-    def __init__(self, msg):
-        super().__init__(msg)
-        self.msg = msg
-
-
-class DraconicSyntaxError(DraconicException):
-    """Bad syntax."""
-
-    def __init__(self, original: SyntaxError, expr):
-        super().__init__(original.msg)
-        self.lineno = original.lineno
-        self.offset = original.offset
-        self.end_lineno = None
-        self.end_offset = None
-        self.expr = expr
-
-        if PY_310:
-            self.end_lineno = original.end_lineno
-            self.end_offset = original.end_offset
-
-    @classmethod
-    def from_node(cls, node: ast.AST, msg: str, expr):
-        if PY_310:
-            inner = SyntaxError(
-                msg, ("<string>", node.lineno, node.col_offset + 1, expr, node.end_lineno, node.end_col_offset + 1)
-            )
-        else:
-            inner = SyntaxError(msg, ("<string>", node.lineno, node.col_offset + 1, expr))
-        return cls(inner, expr)
-
-
-class InvalidExpression(DraconicException):
-    """Base exception for all exceptions during run-time."""
-
-    def __init__(self, msg, node, expr):
-        super().__init__(msg)
-        self.node = node
-        self.expr = expr
-
-
-class NotDefined(InvalidExpression):
-    """Some name is not defined."""
-
-    pass
-
-
-class FeatureNotAvailable(InvalidExpression):
-    """What you're trying to do is not allowed."""
-
-    pass
-
-
-class DraconicValueError(InvalidExpression):
-    """Bad value passed to some function."""
-
-    pass
-
-
-class LimitException(InvalidExpression):
-    """
-    Something exceeded execution limits.
-    """
-
-    pass
-
-
-class NumberTooHigh(LimitException):
-    """Some number is way too big."""
-
-    pass
-
-
-class IterableTooLong(LimitException):
-    """Some iterable is way too big."""
-
-    pass
-
-
-class TooManyStatements(LimitException):
-    """Tried to execute too many statements."""
-
-    pass
-
-
-class TooMuchRecursion(LimitException):
-    """Too deep in recursion."""
-
-    pass
-
-
-class WrappedException(InvalidExpression, abc.ABC):
-    """abstract base exception for a lib exception that wraps some other exception"""
-
-    original: BaseException
-
-
-class AnnotatedException(WrappedException):
-    """A wrapper for another exception to handle lineno info."""
-
-    def __init__(self, original, node, expr):
-        super().__init__(str(original), node, expr)
-        self.original = original
-
-
-class NestedException(WrappedException):
-    """An exception occurred in a user-defined function call."""
-
-    def __init__(self, msg, node, expr, last_exc):
-        super().__init__(msg, node, expr)
-        self.last_exc = last_exc  # type: DraconicException  # used for tracebacking
-        # keep a reference to the end of the chain for easy comparison
-        if isinstance(last_exc, WrappedException):
-            self.original = last_exc.original
-        else:
-            self.original = last_exc
-
-
-# we need to raise some exception, but don't have the node context right now
-class _PostponedRaise(Exception):
-    def __init__(self, cls, *args, **kwargs):
-        self.cls = cls
-        self.args = args
-        self.kwargs = kwargs
-
-
-def _raise_in_context(cls, *args, **kwargs):
-    raise _PostponedRaise(cls, *args, **kwargs)

draconic/helpers.py

@@ -1,236 +0,0 @@
-import ast
-import operator as op
-from typing import Sequence
-
-from .exceptions import *
-from .types import *
-
-__all__ = ("DraconicConfig", "OperatorMixin", "zip_star")
-
-# ===== config =====
-DISALLOW_PREFIXES = ["_", "func_"]
-DISALLOW_METHODS = ["format", "format_map", "mro", "tb_frame", "gi_frame", "ag_frame", "cr_frame", "exec"]
-
-
-class DraconicConfig:
-    """A configuration object to pass into the Draconic interpreter."""
-
-    def __init__(
-        self,
-        max_const_len=200_000,
-        max_loops=10_000,
-        max_statements=100_000,
-        max_power_base=1_000_000,
-        max_power=1_000,
-        disallow_prefixes=None,
-        disallow_methods=None,
-        default_names=None,
-        builtins_extend_default=True,
-        max_int_size=64,
-        max_recursion_depth=50,
-    ):
-        """
-        Configuration object for the Draconic interpreter.
-
-        :param int max_const_len: The maximum length literal that should be allowed to be constructed.
-        :param int max_loops: The maximum total number of loops allowed per execution.
-        :param int max_statements: The maximum total number of statements allowed per execution.
-        :param int max_power_base: The maximum power base (x in x ** y)
-        :param int max_power: The maximum power (y in x ** y)
-        :param list disallow_prefixes: A list of str - attributes starting with any of these will be inaccessible
-        :param list disallow_methods: A list of str - methods named these will not be callable
-        :param dict default_names: A dict of str: Any - default names in the runtime
-        :param bool builtins_extend_default: If False, ``builtins`` to the interpreter overrides default names
-        :param int max_int_size: The maximum allowed size of integers (-2^(pow-1) to 2^(pow-1)-1). Default 64.
-                                 Integers can technically reach up to double this size before size check.
-                                 *Not* the max value!
-        :param int max_recursion_depth: The maximum allowed recursion depth.
-        """
-        if disallow_prefixes is None:
-            disallow_prefixes = DISALLOW_PREFIXES
-        if disallow_methods is None:
-            disallow_methods = DISALLOW_METHODS
-
-        self.max_const_len = max_const_len
-        self.max_loops = max_loops
-        self.max_statements = max_statements
-        self.max_power_base = max_power_base
-        self.max_power = max_power
-        self.max_int_size = max_int_size
-        self.min_int = -(2 ** (max_int_size - 1))
-        self.max_int = (2 ** (max_int_size - 1)) - 1
-        self.disallow_prefixes = disallow_prefixes
-        self.disallow_methods = disallow_methods
-        self.builtins_extend_default = builtins_extend_default
-        self.max_recursion_depth = max_recursion_depth
-
-        # types
-        self._list = safe_list(self)
-        self._dict = safe_dict(self)
-        self._set = safe_set(self)
-        self._str = safe_str(self)
-
-        # default names
-        if default_names is None:
-            default_names = self._default_names()
-        self.default_names = default_names
-
-    @property
-    def list(self):
-        return self._list
-
-    @property
-    def dict(self):
-        return self._dict
-
-    @property
-    def set(self):
-        return self._set
-
-    @property
-    def str(self):
-        return self._str
-
-    def _default_names(self):
-        return {
-            "True": True,
-            "False": False,
-            "None": None,
-            # functions
-            "bool": bool,
-            "int": int,
-            "float": float,
-            "str": self.str,
-            "tuple": tuple,
-            "dict": self.dict,
-            "list": self.list,
-            "set": self.set,
-        }
-
-
-# ===== operators =====
-class OperatorMixin:
-    """A mixin class to provide the operators."""
-
-    def __init__(self, config):
-        """
-        :type config: draconic.helpers.DraconicConfig
-        """
-        self._config = config
-
-        self.operators = {
-            # binary
-            ast.Add: self._safe_add,
-            ast.Sub: self._safe_sub,
-            ast.Mult: self._safe_mult,
-            ast.Div: op.truediv,
-            ast.FloorDiv: op.floordiv,
-            ast.Pow: self._safe_power,
-            ast.Mod: op.mod,
-            ast.LShift: self._safe_lshift,
-            ast.RShift: op.rshift,
-            ast.BitOr: op.or_,
-            ast.BitXor: op.xor,
-            ast.BitAnd: op.and_,
-            ast.Invert: op.invert,
-            # unary
-            ast.Not: op.not_,
-            ast.USub: op.neg,
-            ast.UAdd: op.pos,
-            # comparison
-            ast.Eq: op.eq,
-            ast.NotEq: op.ne,
-            ast.Gt: op.gt,
-            ast.Lt: op.lt,
-            ast.GtE: op.ge,
-            ast.LtE: op.le,
-            ast.In: lambda x, y: op.contains(y, x),
-            ast.NotIn: lambda x, y: not op.contains(y, x),
-            ast.Is: lambda x, y: x is y,
-            ast.IsNot: lambda x, y: x is not y,
-        }
-
-    def _safe_power(self, a, b):
-        """Exponent: limit power base and power to prevent CPU-locking computation"""
-        if abs(a) > self._config.max_power_base or abs(b) > self._config.max_power:
-            _raise_in_context(NumberTooHigh, f"{a} ** {b} is too large of an exponent")
-        result = a**b
-        if isinstance(result, int) and (result < self._config.min_int or result > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "This exponent would create a number too large")
-        return result
-
-    def _safe_mult(self, a, b):
-        """Multiplication: limit the size of iterables that can be created, and the max size of ints"""
-        # sequences can only be multiplied by ints, so this is safe
-        self._check_binop_operands(a, b)
-        if isinstance(b, int) and b * approx_len_of(a) > self._config.max_const_len:
-            _raise_in_context(IterableTooLong, "Multiplying these two would create something too long")
-        if isinstance(a, int) and a * approx_len_of(b) > self._config.max_const_len:
-            _raise_in_context(IterableTooLong, "Multiplying these two would create something too long")
-        result = a * b
-        if isinstance(result, int) and (result < self._config.min_int or result > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "Multiplying these two would create a number too large")
-        return result
-
-    def _safe_add(self, a, b):
-        """Addition: limit the size of iterables that can be created, and the max size of ints"""
-        self._check_binop_operands(a, b)
-        if approx_len_of(a) + approx_len_of(b) > self._config.max_const_len:
-            _raise_in_context(IterableTooLong, "Adding these two would create something too long")
-        result = a + b
-        if isinstance(result, int) and (result < self._config.min_int or result > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "Adding these two would create a number too large")
-        return result
-
-    def _safe_sub(self, a, b):
-        """Addition: limit the max size of ints"""
-        self._check_binop_operands(a, b)
-        result = a - b
-        if isinstance(result, int) and (result < self._config.min_int or result > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "Subtracting these two would create a number too large")
-        return result
-
-    def _safe_lshift(self, a, b):
-        """Left Bit-Shift: limit the size of integers/floats to prevent CPU-locking computation"""
-        self._check_binop_operands(a, b)
-
-        if isinstance(b, int) and b > self._config.max_int_size - 2:
-            _raise_in_context(NumberTooHigh, f"{a} << {b} is too large of a shift")
-
-        result = a << b
-        if isinstance(result, int) and (result < self._config.min_int or result > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "Shifting these two would create a number too large")
-
-        return a << b
-
-    def _check_binop_operands(self, a, b):
-        """Ensures both operands of a binary operation are safe (int limit)."""
-        if isinstance(a, int) and (a < self._config.min_int or a > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "This number is too large")
-        if isinstance(b, int) and (b < self._config.min_int or b > self._config.max_int):
-            _raise_in_context(NumberTooHigh, "This number is too large")
-
-
-# ==== other utils ====
-def zip_star(a: Sequence, b: Sequence, star_index: int):
-    """
-    Like zip(a, b), but zips the element at ``a[star_index]`` with a list of 0..len(b) elements such that every other
-    element of ``a`` maps to exactly one element of ``b``.
-
-    >>> zip_star(['a', 'b', 'c'], [1, 2, 3, 4], star_index=1)  # like a, *b, c = [1, 2, 3, 4]
-    [('a', 1), ('b', [2, 3]), ('c', 4)]
-    >>> zip_star(['a', 'b', 'c'], [1, 2], star_index=1)  # like a, *b, c = [1, 2]
-    [('a', 1), ('b', []), ('c', 2)]
-
-    Requires ``len(b) >= len(a) - 1`` and ``star_index < len(a)``.
-    """
-    if not 0 <= star_index < len(a):
-        raise IndexError("'star_index' must be a valid index of 'a'")
-    if not len(b) >= len(a) - 1:
-        raise ValueError("'b' must be no more than 1 shorter than 'a'")
-
-    length_difference = len(b) - (len(a) - 1)
-
-    yield from zip(a[:star_index], b[:star_index])
-    yield a[star_index], b[star_index : star_index + length_difference]
-    yield from zip(a[star_index + 1 :], b[star_index + length_difference :])