crosshair-tool 0.0.95__cp311-cp311-musllinux_1_2_x86_64.whl → 0.0.97__cp311-cp311-musllinux_1_2_x86_64.whl

crosshair/__init__.py

@@ -15,7 +15,7 @@ from crosshair.statespace import StateSpace
 from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import IgnoreAttempt, debug
 
-__version__ = "0.0.95"  # Do not forget to update in setup.py!
+__version__ = "0.0.97"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

crosshair/_tracers_test.py

@@ -19,19 +19,19 @@ class ExampleModule:
 
 def test_CTracer_module_refcounts_dont_leak():
     mod = ExampleModule()
-    assert sys.getrefcount(mod) == 2
+    base_count = sys.getrefcount(mod)
     tracer = CTracer()
     tracer.push_module(mod)
-    assert sys.getrefcount(mod) == 3
+    assert sys.getrefcount(mod) == base_count + 1
     tracer.push_module(mod)
     tracer.start()
     tracer.stop()
-    assert sys.getrefcount(mod) == 4
+    assert sys.getrefcount(mod) == base_count + 2
     tracer.pop_module(mod)
-    assert sys.getrefcount(mod) == 3
+    assert sys.getrefcount(mod) == base_count + 1
     del tracer
     gc.collect()
-    assert sys.getrefcount(mod) == 2
+    assert sys.getrefcount(mod) == base_count
 
 
 def _get_depths(fn):

crosshair/codeconfig.py

@@ -1,4 +1,5 @@
 """Configure analysis options at different levels."""
+
 import importlib.resources
 import inspect
 import re
@@ -25,7 +26,7 @@ def get_directives(source_text: str) -> Iterable[Tuple[int, int, str]]:
     ret = []
     tokens = tokenize.generate_tokens(StringIO(source_text).readline)
     # TODO catch tokenize.TokenError ... just in case?
-    for (toktyp, tokval, begin, _, _) in tokens:
+    for toktyp, tokval, begin, _, _ in tokens:
         linenum, colnum = begin
         if toktyp == tokenize.COMMENT:
             directive = _COMMENT_TOKEN_RE.sub(r"\1", tokval)
@@ -39,7 +40,7 @@ class InvalidDirective(Exception):
 
 
 def parse_directives(
-    directive_lines: Iterable[Tuple[int, int, str]]
+    directive_lines: Iterable[Tuple[int, int, str]],
 ) -> AnalysisOptionSet:
     """
     Parse options from directives in comments.

crosshair/condition_parser.py

@@ -520,6 +520,7 @@ class ConcreteConditionParser(ConditionParser):
                 "__delattr__",
                 "__replace__",  # Will raise an exception with most arbitrary **kwargs.
                 "__annotate__",  # a staticmethod, but not isinstance(staticmethod)
+                "__annotate_func__",
             ):
                 pass
             elif method_name == "__del__":

crosshair/condition_parser_test.py

@@ -1,8 +1,6 @@
 import inspect
 import json
 import sys
-import textwrap
-import unittest
 from typing import List
 
 import pytest

crosshair/core.py

@@ -377,7 +377,8 @@ def with_symbolic_self(symbolic_cls: Type, fn: Callable):
             elif any(isinstance(a, CrossHairValue) for a in args) or (
                 kwargs and any(isinstance(a, CrossHairValue) for a in kwargs.values())
             ):
-                self = symbolic_cls._smt_promote_literal(self)
+                # NOTE: _ch_create_from_literal is suppoerted for very few types right now
+                self = symbolic_cls._ch_create_from_literal(self)
                 target_fn = getattr(symbolic_cls, fn.__name__)
             else:
                 args = map(realize, args)
@@ -562,12 +563,12 @@ class SymbolicFactory:
     @overload
     def __call__(
         self, typ: Callable[..., _T], suffix: str = "", allow_subtypes: bool = True
-    ) -> _T:
-        ...
+    ) -> _T: ...
 
     @overload
-    def __call__(self, typ: Any, suffix: str = "", allow_subtypes: bool = True) -> Any:
-        ...
+    def __call__(
+        self, typ: Any, suffix: str = "", allow_subtypes: bool = True
+    ) -> Any: ...
 
     def __call__(self, typ, suffix: str = "", allow_subtypes: bool = True):
         """
@@ -652,8 +653,7 @@ def proxy_for_type(
     typ: Callable[..., _T],
     varname: str,
     allow_subtypes: bool = False,
-) -> _T:
-    ...
+) -> _T: ...
 
 
 @overload
@@ -661,8 +661,7 @@ def proxy_for_type(
     typ: Any,
     varname: str,
     allow_subtypes: bool = False,
-) -> Any:
-    ...
+) -> Any: ...
 
 
 def proxy_for_type(

crosshair/core_test.py

@@ -5,7 +5,6 @@ import re
 import sys
 import time
 from typing import *
-from unittest import skipIf
 
 import pytest  # type: ignore
 
@@ -736,7 +735,7 @@ def test_newtype() -> None:
     assert isinstance(x, SymbolicInt)
 
 
-@skipIf(sys.version_info < (3, 12), "type statements added in 3.12")
+@pytest.mark.skipif(sys.version_info < (3, 12), reason="type statements added in 3.12")
 def test_type_statement() -> None:
     env: dict[str, Any] = {}
     exec("type MyIntNew = int\n", env)
@@ -747,7 +746,7 @@ def test_type_statement() -> None:
     assert isinstance(x, SymbolicInt)
 
 
-@skipIf(sys.version_info < (3, 12), "type statements added in 3.12")
+@pytest.mark.skipif(sys.version_info < (3, 12), reason="type statements added in 3.12")
 def test_parameterized_type_statement() -> None:
     env: dict[str, Any] = {}
     exec("type Pair[A, B] = tuple[B, A]\n", env)

crosshair/diff_behavior_test.py

@@ -1,5 +1,3 @@
-import sys
-import unittest
 from typing import Callable, List, Optional
 
 from crosshair.diff_behavior import (

crosshair/dynamic_typing.py

@@ -59,7 +59,7 @@ def unify_callable_args(
         return True
     if len(value_types) != len(recv_types):
         return False
-    for (varg, rarg) in zip(value_types, recv_types):
+    for varg, rarg in zip(value_types, recv_types):
         # note reversal here: Callable is contravariant in argument types
         if not unify(rarg, varg, bindings):
             return False
@@ -206,7 +206,7 @@ def unify(
                 vargs = [object for _ in rargs]
             else:
                 return False
-        for (varg, targ) in zip(vargs, rargs):
+        for varg, targ in zip(vargs, rargs):
             if not unify(varg, targ, bindings):
                 return False
         return True
@@ -302,7 +302,7 @@ def intersect_signatures(
     is_squishy1 = var_pos1 is not None or var_key1 is not None
     is_squishy2 = var_pos2 is not None or var_key2 is not None
     out_params: Dict[str, Parameter] = {}
-    for (p1, p2) in zip_longest(pos1, pos2):
+    for p1, p2 in zip_longest(pos1, pos2):
         if p1 is None:
             if is_squishy1:
                 out_params[p2.name] = p2

crosshair/enforce.py

@@ -36,6 +36,7 @@ def WithEnforcement(fn: Callable) -> Callable:
     Enforcement is normally disabled when calling from some internal files, for
     performance reasons. Use WithEnforcement to ensure it is enabled anywhere.
     """
+
     # This local function has a special name that we look for while tracing
     # (see the wants_codeobj method below):
     def _crosshair_with_enforcement(*a, **kw):

crosshair/examples/check_examples_test.py

@@ -1,4 +1,5 @@
 """Run functional tests of the tool on all the examples."""
+
 import argparse
 import os
 import pathlib

crosshair/fnutil.py

@@ -41,8 +41,7 @@ if sys.version_info >= (3, 8):
     from typing import Protocol
 
     class Descriptor(Protocol):
-        def __get__(self, instance: object, cls: type) -> Any:
-            ...
+        def __get__(self, instance: object, cls: type) -> Any: ...
 
 else:
     Descriptor = Any
@@ -344,7 +343,7 @@ def walk_paths(paths: Iterable[Path], ignore_missing=False) -> Iterable[Path]:
             else:
                 raise FileNotFoundError(str(path))
         if path.is_dir():
-            for (dirpath, _dirs, files) in os.walk(str(path)):
+            for dirpath, _dirs, files in os.walk(str(path)):
                 for curfile in files:
                     if analyzable_filename(curfile):
                         yield Path(dirpath) / curfile

crosshair/fnutil_test.py

@@ -26,10 +26,7 @@ def test_fn_globals_on_builtin() -> None:
 
 def test_resolve_signature_invalid_annotations() -> None:
     sig = resolve_signature(with_invalid_type_annotation)
-    if sys.version_info >= (3, 14):
-        assert sig == "TypeThatIsNotDefined"
-    else:
-        assert sig == "name 'TypeThatIsNotDefined' is not defined"
+    assert sig == "name 'TypeThatIsNotDefined' is not defined"
 
 
 @pytest.mark.skipif(

crosshair/fuzz_core_test.py

@@ -47,7 +47,7 @@ from crosshair.statespace import (
 from crosshair.stubs_parser import signature_from_stubs
 from crosshair.test_util import flexible_equal
 from crosshair.tracers import COMPOSITE_TRACER, NoTracing, ResumedTracing
-from crosshair.util import CrosshairUnsupported, debug, type_args_of
+from crosshair.util import CrosshairUnsupported, debug, is_iterable, type_args_of
 
 FUZZ_SEED = 1348
 
@@ -267,6 +267,14 @@ class FuzzTester:
         ) -> object:
             for name in typed_args.keys():
                 literal, symbolic = literal_args[name], symbolic_args[name]
+                with NoTracing():
+                    # TODO: transition into general purpose SMT expr extractor
+                    # for equality with constant
+                    if hasattr(symbolic, "_smt_promote_literal"):
+                        symbolic.var = symbolic._smt_promote_literal(literal)  # type: ignore
+                    elif is_iterable(literal) and is_iterable(symbolic):
+                        with ResumedTracing():
+                            space.add(len(literal) == len(symbolic))  # type: ignore
                 if literal != symbolic:
                     raise IgnoreAttempt(
                         f'symbolic "{name}" not equal to literal "{name}"'

crosshair/libimpl/arraylib.py

@@ -32,7 +32,7 @@ INT_TYPE_SIZE = {c: array(c).itemsize for c in INT_TYPE_BOUNDS.keys()}
 
 def pick_code(space: StateSpace) -> Tuple[str, int, int]:
     last_idx = len(INT_TYPE_BOUNDS) - 1
-    for (idx, (code, rng)) in enumerate(INT_TYPE_BOUNDS.items()):
+    for idx, (code, rng) in enumerate(INT_TYPE_BOUNDS.items()):
         if idx < last_idx:
             if space.smt_fork(desc=f"not_{code}_array"):
                 continue

crosshair/libimpl/builtinslib.py

@@ -189,6 +189,7 @@ def smt_not(x: object) -> Union[bool, "SymbolicBool"]:
 
 _NONHEAP_PYTYPES = set([int, float, bool, NoneType, complex])
 
+
 # TODO: isn't this pretty close to isinstance(typ, AtomicSymbolicValue)?
 def pytype_uses_heap(typ: Type) -> bool:
     return not (typ in _NONHEAP_PYTYPES)
@@ -346,7 +347,7 @@ class AtomicSymbolicValue(SymbolicValue):
         raise CrossHairInternal(f"_pytype not implemented in {cls}")
 
     @classmethod
-    def _smt_promote_literal(cls, val: object) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal: object) -> Optional[z3.ExprRef]:
         raise CrossHairInternal(f"_smt_promote_literal not implemented in {cls}")
 
     @classmethod
@@ -900,6 +901,7 @@ def setup_binops():
                 if isinstance(a, FiniteFloat)
                 else a.var
             )
+            assert smt_a is not None
             if isinstance(b, NonFiniteFloat):
                 if isnan(b.val):
                     return (nan, nan)
@@ -912,6 +914,7 @@ def setup_binops():
                     return (-1.0, b.val)
                 else:
                     return (0.0, a.val if isinstance(a, FiniteFloat) else a)
+            assert smt_b is not None
 
             remainder = z3.Real(f"remainder{space.uniq()}")
             modproduct = z3.Int(f"modproduct{space.uniq()}")
@@ -1120,7 +1123,7 @@ class SymbolicBool(SymbolicIntable, AtomicSymbolicValue):
         return bool
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, bool):
             return z3.BoolVal(literal)
         return None
@@ -1189,7 +1192,7 @@ class SymbolicInt(SymbolicIntable, AtomicSymbolicValue):
         return int
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, int):
             return z3IntVal(literal)
         return None
@@ -1410,7 +1413,7 @@ class PreciseIeeeSymbolicFloat(SymbolicFloat):
         return _PRECISE_IEEE_FLOAT_SORT
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, float):
             return z3.FPVal(literal, cls._ch_smt_sort())
         return None
@@ -1533,7 +1536,7 @@ class RealBasedSymbolicFloat(SymbolicFloat):
         return z3.RealSort()
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, float) and isfinite(literal):
             return z3.RealVal(literal)
         return None
@@ -1591,6 +1594,7 @@ class RealBasedSymbolicFloat(SymbolicFloat):
             denominator = SymbolicInt("denominator" + space.uniq())
             space.add(denominator.var > 0)
             space.add(numerator.var == denominator.var * self.var)
+
         # There are many valid integer ratios to return. Experimentally, both
         # z3 and CPython tend to pick the same ones. But verify this, while
         # deferring materialization:
@@ -2330,7 +2334,7 @@ class SymbolicRange:
             return False
         if len(self) != len(other):
             return False
-        for (v1, v2) in zip(self, other):
+        for v1, v2 in zip(self, other):
             if v1 != v2:
                 return False
         return True
@@ -2447,7 +2451,7 @@ class SymbolicType(AtomicSymbolicValue, SymbolicValue, Untracable):
         return type
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, type):
             return context_statespace().extra(SymbolicTypeRepository).get_type(literal)
         return None
@@ -2668,10 +2672,25 @@ class SymbolicCallable:
     __annotations__: dict = {}
 
     def __init__(self, values: list):
+        """
+        A function that will ignore its arguments and produce return values
+        from the list given.
+        If the given list is exhausted, the function will just repeatedly
+        return the final value in the list.
+
+        If `values` is concrete, it must be non-mepty.
+        If `values` is a symbolic list, it will be forced to be non-empty
+        (the caller must enure that's possible).
+        """
         assert not is_tracing()
         with ResumedTracing():
-            if not values:
-                raise IgnoreAttempt
+            has_values = len(values) > 0
+        if isinstance(values, CrossHairValue):
+            space = context_statespace()
+            assert space.is_possible(has_values)
+            space.add(has_values)
+        else:
+            assert has_values
         self.values = values
         self.idx = 0
 
@@ -2695,6 +2714,7 @@ class SymbolicCallable:
         if idx >= len(values):
             return values[-1]
         else:
+            self.idx += 1
             return values[idx]
 
     def __bool__(self):
@@ -2767,7 +2787,7 @@ class SymbolicBoundedIntTuple(collections.abc.Sequence):
         with NoTracing():
             self._create_up_to(realize(otherlen))
             constraints = []
-            for (int1, int2) in zip(self._created_vars, tracing_iter(other)):
+            for int1, int2 in zip(self._created_vars, tracing_iter(other)):
                 smtint2 = force_to_smt_sort(int2, SymbolicInt)
                 constraints.append(int1.var == smtint2)
             return SymbolicBool(z3.And(*constraints))
@@ -2894,7 +2914,7 @@ class AnySymbolicStr(AbcString):
             raise TypeError
         if self == other:
             return True if op in (ops.le, ops.ge) else False
-        for (mych, otherch) in zip_longest(iter(self), iter(other)):
+        for mych, otherch in zip_longest(iter(self), iter(other)):
             if mych == otherch:
                 continue
             if mych is None:
@@ -3156,7 +3176,7 @@ class AnySymbolicStr(AbcString):
 
         else:
             raise TypeError
-        for (idx, ch) in enumerate(self):
+        for idx, ch in enumerate(self):
             if not filter(ch):
                 return self[idx:]
         return ""
@@ -3168,7 +3188,7 @@ class AnySymbolicStr(AbcString):
         mylen = self.__len__()
         if mylen == 0:
             return []
-        for (idx, ch) in enumerate(self):
+        for idx, ch in enumerate(self):
             codepoint = ord(ch)
             with NoTracing():
                 space = context_statespace()
@@ -3406,6 +3426,26 @@ class AnySymbolicStr(AbcString):
             return "0" * fill_length + self
 
 
+def _unfindable_range(start: Optional[int], end: Optional[int], mylen: int) -> bool:
+    """
+    Emulates some preliminary checks that CPython makes before searching
+    for substrings within some bounds. (in e.g. str.find, str.startswith, etc)
+    """
+    if start is None or start == 0 or start <= -mylen:
+        return False
+
+    # At this point, we know that `start` is defined and points to an index after 0
+    if end is None or end >= mylen:
+        return start > mylen
+
+    # At this point, we know that `end` is defined and points to an index before the end of the string
+    if start < 0:
+        start += mylen
+    if end < 0:
+        end += mylen
+    return end < start
+
+
 class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
     """
     A symbolic string that lazily generates SymbolicInt-based characters as needed.
@@ -3444,10 +3484,8 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
             codepoints = tuple(self._codepoints)
         return "".join(chr(realize(x)) for x in codepoints)
 
-    # This is normally an AtomicSymbolicValue method, but sometimes it's used in a
-    # duck-typing way.
     @classmethod
-    def _smt_promote_literal(cls, val: object) -> Optional[z3.SortRef]:
+    def _ch_create_from_literal(cls, val: object) -> Optional[CrossHairValue]:
         if isinstance(val, str):
             return LazyIntSymbolicStr(list(map(ord, val)))
         return None
@@ -3481,6 +3519,10 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         with NoTracing():
             if not isinstance(i, (Integral, slice)):
                 raise TypeError(type(i))
+            # This could/should? be symbolic by naming all the possibilities.
+            # Note the slice case still must realize the return length.
+            # Especially because we no longer explore realization trees except
+            # as a last resort.
             i = deep_realize(i)
             with ResumedTracing():
                 newcontents = self._codepoints[i]
@@ -3561,11 +3603,15 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
             return any(self.endswith(s, start, end) for s in substr)
         if not isinstance(substr, str):
             raise TypeError
+        substrlen = len(substr)
         if start is None and end is None:
             matchable = self
         else:
             matchable = self[start:end]
-        return matchable[-len(substr) :] == substr
+        if substrlen == 0:
+            return not _unfindable_range(start, end, len(self))
+        else:
+            return matchable[-substrlen:] == substr
 
     def startswith(self, substr, start=None, end=None):
         if isinstance(substr, tuple):
@@ -3575,6 +3621,10 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         if start is None and end is None:
             matchable = self
         else:
+            # Wacky special case: the empty string is findable off the left
+            # side but not the right!
+            if _unfindable_range(start, end, len(self)):
+                return False
             matchable = self[start:end]
         return matchable[: len(substr)] == substr
 
@@ -3615,7 +3665,7 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
             end += mylen
         matchstr = self[start:end] if start != 0 or end is not mylen else self
         if len(substr) == 0:
-            # Add oddity of CPython. We can find the empty string when over-slicing
+            # An oddity of CPython. We can find the empty string when over-slicing
             # off the left side of the string, but not off the right:
             # ''.find('', 3, 4) == -1
             # ''.find('', -4, -3) == 0
@@ -3962,7 +4012,7 @@ class SymbolicByteArray(BytesLike, ShellMutableSequence):  # type: ignore
 
 
 class SymbolicMemoryView(BytesLike):
-    format = "B"
+    format = "B"  # type: ignore
     itemsize = 1
     ndim = 1
     strides = (1,)
@@ -4771,11 +4821,11 @@ def _str_percent_format(self, other):
     return self.__mod__(deep_realize(other))
 
 
-def _bytes_join(self, itr) -> str:
+def _bytes_join(self, itr) -> bytes:
     return _join(self, itr, self_type=bytes, item_type=Buffer)
 
 
-def _bytearray_join(self, itr) -> str:
+def _bytearray_join(self, itr) -> bytes:
     return _join(self, itr, self_type=bytearray, item_type=Buffer)
 
 
@@ -4790,14 +4840,17 @@ def _str_format_map(self, map) -> Union[AnySymbolicStr, str]:
 
 
 def _str_startswith(self, substr, start=None, end=None) -> bool:
-    if not isinstance(self, str):
-        raise TypeError
     with NoTracing():
+        if isinstance(self, LazyIntSymbolicStr):
+            with ResumedTracing():
+                return self.startswith(substr, start, end)
+        elif not isinstance(self, str):
+            raise TypeError
         # Handle native values with native implementation:
         if type(substr) is str:
             return self.startswith(substr, start, end)
         if type(substr) is tuple:
-            if all(type(i) is str for i in substr):
+            if all(type(s) is str for s in substr):
                 return self.startswith(substr, start, end)
         symbolic_self = LazyIntSymbolicStr([ord(c) for c in self])
     return symbolic_self.startswith(substr, start, end)

crosshair/libimpl/builtinslib_ch_test.py

@@ -178,7 +178,7 @@ def check_iter(obj: Union[str, List[int], Dict[int, int]]) -> ResultComparison:
 
 
 def check_len(
-    s: Union[Dict[int, int], Tuple[int, ...], str, List[int], Set[int]]
+    s: Union[Dict[int, int], Tuple[int, ...], str, List[int], Set[int]],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(len, s)
@@ -606,9 +606,14 @@ def check_str_endswith(
     string: str, suffix: str, start: Optional[int], end: Optional[int]
 ) -> ResultComparison:
     """post: _"""
+    # crosshair: max_uninteresting_iterations=100
+
+    for i in (len(string), len(suffix), start, end):
+        if i is not None and abs(i) >= 1:
+            pass
+
     return compare_results(
-        lambda s, *a: s.endswith(*a),
-        string,
+        lambda s, *a, **kw: s.endswith(*a, **kw), string, suffix, start, end
     )
 
 
@@ -825,6 +830,11 @@ def check_str_startswith(
     end: Optional[int],
 ) -> ResultComparison:
     """post: _"""
+    # crosshair: max_uninteresting_iterations=100
+
+    for i in (len(string), len(prefix), start, end):
+        if i is not None and abs(i) >= 1:
+            pass
     return compare_results(
         lambda s, *a, **kw: s.startswith(*a, **kw), string, prefix, start, end
     )
@@ -974,7 +984,7 @@ def check_bytes___init__(source: Union[int, List[int], bytes, bytearray, memoryv
 
 
 def check_bytearray___init__(
-    source: Union[int, List[int], bytes, bytearray, memoryview]
+    source: Union[int, List[int], bytes, bytearray, memoryview],
 ):
     """
     post: _
@@ -984,7 +994,7 @@ def check_bytearray___init__(
 
 
 def check_memoryview___init__(
-    source: Union[int, List[int], bytes, bytearray, memoryview]
+    source: Union[int, List[int], bytes, bytearray, memoryview],
 ):
     """
     post: _