Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/nodes/BytesNodes.py

@@ -0,0 +1,829 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes that build and operate on bytes (Python3).
+
+"""
+
+from .BuiltinOperationNodeBasesGenerated import (
+    ExpressionBytesOperationCapitalizeBase,
+    ExpressionBytesOperationCenter2Base,
+    ExpressionBytesOperationCenter3Base,
+    ExpressionBytesOperationCount2Base,
+    ExpressionBytesOperationCount3Base,
+    ExpressionBytesOperationCount4Base,
+    ExpressionBytesOperationDecode1Base,
+    ExpressionBytesOperationDecode2Base,
+    ExpressionBytesOperationDecode3Base,
+    ExpressionBytesOperationEndswith2Base,
+    ExpressionBytesOperationEndswith3Base,
+    ExpressionBytesOperationEndswith4Base,
+    ExpressionBytesOperationExpandtabs1Base,
+    ExpressionBytesOperationExpandtabs2Base,
+    ExpressionBytesOperationFind2Base,
+    ExpressionBytesOperationFind3Base,
+    ExpressionBytesOperationFind4Base,
+    ExpressionBytesOperationIndex2Base,
+    ExpressionBytesOperationIndex3Base,
+    ExpressionBytesOperationIndex4Base,
+    ExpressionBytesOperationIsalnumBase,
+    ExpressionBytesOperationIsalphaBase,
+    ExpressionBytesOperationIsdigitBase,
+    ExpressionBytesOperationIslowerBase,
+    ExpressionBytesOperationIsspaceBase,
+    ExpressionBytesOperationIstitleBase,
+    ExpressionBytesOperationIsupperBase,
+    ExpressionBytesOperationJoinBase,
+    ExpressionBytesOperationLjust2Base,
+    ExpressionBytesOperationLjust3Base,
+    ExpressionBytesOperationLowerBase,
+    ExpressionBytesOperationLstrip1Base,
+    ExpressionBytesOperationLstrip2Base,
+    ExpressionBytesOperationPartitionBase,
+    ExpressionBytesOperationReplace3Base,
+    ExpressionBytesOperationReplace4Base,
+    ExpressionBytesOperationRfind2Base,
+    ExpressionBytesOperationRfind3Base,
+    ExpressionBytesOperationRfind4Base,
+    ExpressionBytesOperationRindex2Base,
+    ExpressionBytesOperationRindex3Base,
+    ExpressionBytesOperationRindex4Base,
+    ExpressionBytesOperationRjust2Base,
+    ExpressionBytesOperationRjust3Base,
+    ExpressionBytesOperationRpartitionBase,
+    ExpressionBytesOperationRsplit1Base,
+    ExpressionBytesOperationRsplit2Base,
+    ExpressionBytesOperationRsplit3Base,
+    ExpressionBytesOperationRstrip1Base,
+    ExpressionBytesOperationRstrip2Base,
+    ExpressionBytesOperationSplit1Base,
+    ExpressionBytesOperationSplit2Base,
+    ExpressionBytesOperationSplit3Base,
+    ExpressionBytesOperationSplitlines1Base,
+    ExpressionBytesOperationSplitlines2Base,
+    ExpressionBytesOperationStartswith2Base,
+    ExpressionBytesOperationStartswith3Base,
+    ExpressionBytesOperationStartswith4Base,
+    ExpressionBytesOperationStrip1Base,
+    ExpressionBytesOperationStrip2Base,
+    ExpressionBytesOperationSwapcaseBase,
+    ExpressionBytesOperationTitleBase,
+    ExpressionBytesOperationTranslate2Base,
+    ExpressionBytesOperationTranslate3Base,
+    ExpressionBytesOperationUpperBase,
+    ExpressionBytesOperationZfillBase,
+)
+from .ConstantRefNodes import makeConstantRefNode
+from .ExpressionShapeMixins import ExpressionStrOrUnicodeExactMixin
+from .NodeMetaClasses import NodeCheckMetaClass
+
+
+def getBytesOperationClasses():
+    """Return all bytes operation nodes, for use by code generation."""
+    return (
+        cls
+        for kind, cls in NodeCheckMetaClass.kinds.items()
+        if kind.startswith("EXPRESSION_BYTES_OPERATION_")
+    )
+
+
+class ExpressionBytesOperationJoin(ExpressionBytesOperationJoinBase):
+    """This operation represents b.join(iterable)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_JOIN"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationPartition(ExpressionBytesOperationPartitionBase):
+    """This operation represents b.partition(sep)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_PARTITION"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+    @staticmethod
+    def getIterationLength():
+        return 3
+
+
+class ExpressionBytesOperationRpartition(ExpressionBytesOperationRpartitionBase):
+    """This operation represents b.rpartition(sep)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RPARTITION"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+    @staticmethod
+    def getIterationLength():
+        return 3
+
+
+class ExpressionBytesOperationStrip1(ExpressionBytesOperationStrip1Base):
+    """This operation represents b.strip()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_STRIP1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationStrip2(ExpressionBytesOperationStrip2Base):
+    """This operation represents b.strip(chars)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_STRIP2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationLstrip1(ExpressionBytesOperationLstrip1Base):
+    """This operation represents b.lstrip(chars)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_LSTRIP1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationLstrip2(ExpressionBytesOperationLstrip2Base):
+    """This operation represents b.lstrip(chars)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_LSTRIP2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRstrip1(ExpressionBytesOperationRstrip1Base):
+    """This operation represents b.rstrip()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RSTRIP1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationRstrip2(ExpressionBytesOperationRstrip2Base):
+    """This operation represents b.rstrip(chars)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RSTRIP2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationFind2(ExpressionBytesOperationFind2Base):
+    """This operation represents b.find(sub)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_FIND2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationFind3(ExpressionBytesOperationFind3Base):
+    """This operation represents b.find(sub, start)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_FIND3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationFind4(ExpressionBytesOperationFind4Base):
+    """This operation represents b.find(sub, start, end)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_FIND4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRfind2(ExpressionBytesOperationRfind2Base):
+    """This operation represents b.rfind(sub)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RFIND2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRfind3(ExpressionBytesOperationRfind3Base):
+    """This operation represents b.rfind(sub, start)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RFIND3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRfind4(ExpressionBytesOperationRfind4Base):
+    """This operation represents b.rfind(sub, start, end)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RFIND4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationIndex2(ExpressionBytesOperationIndex2Base):
+    """This operation represents b.index(sub)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_INDEX2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationIndex3(ExpressionBytesOperationIndex3Base):
+    """This operation represents b.index(sub, start)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_INDEX3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationIndex4(ExpressionBytesOperationIndex4Base):
+    """This operation represents b.index(sub, start, end)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_INDEX4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRindex2(ExpressionBytesOperationRindex2Base):
+    """This operation represents b.rindex(sub)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RINDEX2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRindex3(ExpressionBytesOperationRindex3Base):
+    """This operation represents b.rindex(sub, start)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RINDEX3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRindex4(ExpressionBytesOperationRindex4Base):
+    """This operation represents b.rindex(sub, start, end)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RINDEX4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationCapitalize(ExpressionBytesOperationCapitalizeBase):
+    """This operation represents b.capitalize()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_CAPITALIZE"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationUpper(ExpressionBytesOperationUpperBase):
+    """This operation represents b.upper()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_UPPER"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationLower(ExpressionBytesOperationLowerBase):
+    """This operation represents b.lower()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_LOWER"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationSwapcase(ExpressionBytesOperationSwapcaseBase):
+    """This operation represents b.swapcase()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_SWAPCASE"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationTitle(ExpressionBytesOperationTitleBase):
+    """This operation represents b.title()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_TITLE"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIsalnum(ExpressionBytesOperationIsalnumBase):
+    """This operation represents b.isalnum()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISALNUM"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIsalpha(ExpressionBytesOperationIsalphaBase):
+    """This operation represents b.isalpha()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISALPHA"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIsdigit(ExpressionBytesOperationIsdigitBase):
+    """This operation represents b.isdigit()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISDIGIT"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIslower(ExpressionBytesOperationIslowerBase):
+    """This operation represents b.islower()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISLOWER"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIsupper(ExpressionBytesOperationIsupperBase):
+    """This operation represents b.isupper()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISUPPER"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIsspace(ExpressionBytesOperationIsspaceBase):
+    """This operation represents b.isspace()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISSPACE"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationIstitle(ExpressionBytesOperationIstitleBase):
+    """This operation represents b.istitle()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ISTITLE"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationSplit1(ExpressionBytesOperationSplit1Base):
+    """This operation represents b.split()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_SPLIT1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationSplit2(ExpressionBytesOperationSplit2Base):
+    """This operation represents b.split(sep)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_SPLIT2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+def makeExpressionBytesOperationSplit3(bytes_arg, sep, maxsplit, source_ref):
+    if sep is None:
+        sep = makeConstantRefNode(constant=None, source_ref=source_ref)
+
+    return ExpressionBytesOperationSplit3(
+        bytes_arg=bytes_arg,
+        sep=sep,
+        maxsplit=maxsplit,
+        source_ref=source_ref,
+    )
+
+
+class ExpressionBytesOperationSplit3(ExpressionBytesOperationSplit3Base):
+    """This operation represents b.split(sep, maxsplit)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_SPLIT3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+# TODO: This one could be eliminated in favor of simple ExpressionBytesOperationSplit1
+# since without an argument, there is no difference.
+class ExpressionBytesOperationRsplit1(ExpressionBytesOperationRsplit1Base):
+    """This operation represents b.rsplit()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RSPLIT1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationRsplit2(ExpressionBytesOperationRsplit2Base):
+    """This operation represents b.rsplit(sep)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RSPLIT2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+def makeExpressionBytesOperationRsplit3(bytes_arg, sep, maxsplit, source_ref):
+    if sep is None:
+        sep = makeConstantRefNode(constant=None, source_ref=source_ref)
+
+    return ExpressionBytesOperationRsplit3(
+        bytes_arg=bytes_arg,
+        sep=sep,
+        maxsplit=maxsplit,
+        source_ref=source_ref,
+    )
+
+
+class ExpressionBytesOperationRsplit3(ExpressionBytesOperationRsplit3Base):
+    """This operation represents b.rsplit(sep, maxsplit)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_RSPLIT3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationEndswith2(ExpressionBytesOperationEndswith2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_ENDSWITH2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationEndswith3(ExpressionBytesOperationEndswith3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_ENDSWITH3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationEndswith4(ExpressionBytesOperationEndswith4Base):
+    kind = "EXPRESSION_BYTES_OPERATION_ENDSWITH4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationStartswith2(ExpressionBytesOperationStartswith2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_STARTSWITH2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationStartswith3(ExpressionBytesOperationStartswith3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_STARTSWITH3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationStartswith4(ExpressionBytesOperationStartswith4Base):
+    kind = "EXPRESSION_BYTES_OPERATION_STARTSWITH4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationReplace3(ExpressionBytesOperationReplace3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_REPLACE3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationReplace4(ExpressionBytesOperationReplace4Base):
+    kind = "EXPRESSION_BYTES_OPERATION_REPLACE4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationDecodeMixin(ExpressionStrOrUnicodeExactMixin):
+    __slots__ = ()
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments cannot be decoded
+        return True
+
+
+class ExpressionBytesOperationDecode1(
+    ExpressionBytesOperationDecodeMixin, ExpressionBytesOperationDecode1Base
+):
+    kind = "EXPRESSION_BYTES_OPERATION_DECODE1"
+
+
+class ExpressionBytesOperationDecode2(
+    ExpressionBytesOperationDecodeMixin, ExpressionBytesOperationDecode2Base
+):
+    kind = "EXPRESSION_BYTES_OPERATION_DECODE2"
+
+    def computeExpression(self, trace_collection):
+        # TODO: Maybe demote for default values of encodings, e.g. UTF8, ASCII
+
+        # We cannot know what error handlers or encodings got registered.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
+def makeExpressionBytesOperationDecode3(bytes_arg, encoding, errors, source_ref):
+    if encoding is None:
+        encoding = makeConstantRefNode(constant="utf-8", source_ref=source_ref)
+
+    return ExpressionBytesOperationDecode3(
+        bytes_arg=bytes_arg,
+        encoding=encoding,
+        errors=errors,
+        source_ref=source_ref,
+    )
+
+
+class ExpressionBytesOperationDecode3(
+    ExpressionBytesOperationDecodeMixin, ExpressionBytesOperationDecode3Base
+):
+    kind = "EXPRESSION_BYTES_OPERATION_DECODE3"
+
+    def computeExpression(self, trace_collection):
+        # We cannot know what error handlers or encodings got registered.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
+class ExpressionBytesOperationCount2(ExpressionBytesOperationCount2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_COUNT2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationCount3(ExpressionBytesOperationCount3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_COUNT3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationCount4(ExpressionBytesOperationCount4Base):
+    kind = "EXPRESSION_BYTES_OPERATION_COUNT4"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationExpandtabs1(ExpressionBytesOperationExpandtabs1Base):
+    """This operation represents b.expandtabs()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_EXPANDTABS1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+class ExpressionBytesOperationExpandtabs2(ExpressionBytesOperationExpandtabs2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_EXPANDTABS2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationTranslate2(ExpressionBytesOperationTranslate2Base):
+    """This operation represents b.translate(table)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_TRANSLATE2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationTranslate3(ExpressionBytesOperationTranslate3Base):
+    """This operation represents b.translate(table, delete)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_TRANSLATE3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationZfill(ExpressionBytesOperationZfillBase):
+    """This operation represents b.zfill(width)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_ZFILL"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationCenter2(ExpressionBytesOperationCenter2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_CENTER2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationCenter3(ExpressionBytesOperationCenter3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_CENTER3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationLjust2(ExpressionBytesOperationLjust2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_LJUST2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationLjust3(ExpressionBytesOperationLjust3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_LJUST3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRjust2(ExpressionBytesOperationRjust2Base):
+    kind = "EXPRESSION_BYTES_OPERATION_RJUST2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationRjust3(ExpressionBytesOperationRjust3Base):
+    kind = "EXPRESSION_BYTES_OPERATION_RJUST3"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+class ExpressionBytesOperationSplitlines1(ExpressionBytesOperationSplitlines1Base):
+    """This operation represents b.splitlines()."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_SPLITLINES1"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # We do not count MemoryError
+        return False
+
+
+class ExpressionBytesOperationSplitlines2(ExpressionBytesOperationSplitlines2Base):
+    """This operation represents b.splitlines(keepends)."""
+
+    kind = "EXPRESSION_BYTES_OPERATION_SPLITLINES2"
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        # TODO: Only if the arguments have wrong shapes, code generation needs to use this too.
+        return True
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.