# encoding: utf-8
# module bitarray._bitarray
# from C:\Programs\Python\Python313\Lib\site-packages\bitarray\_bitarray.cp313-win_amd64.pyd
# by generator 1.147
# no doc
# no imports

# Variables with simple values

__version__ = '3.4.2'

# functions

def bits2bytes(n, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    bits2bytes(n, /) -> int
    
    Return the number of bytes necessary to store n bits.
    """
    pass

def get_default_endian(): # real signature unknown; restored from __doc__
    """
    get_default_endian() -> str
    
    Return the default bit-endianness for new bitarray objects being created.
    Unless `_set_default_endian('little')` was called, the default
    bit-endianness is `big`.
    """
    return ""

def _bitarray_reconstructor(*args, **kwargs): # real signature unknown
    """ Internal. Used for pickling support. """
    pass

def _set_default_endian(endian, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    _set_default_endian(endian, /)
    
    Set the default bit-endianness for new bitarray objects being created.
    """
    pass

def _sysinfo(): # real signature unknown; restored from __doc__
    """
    _sysinfo() -> tuple
    
    Return tuple containing:
    
    0. sizeof(void *)
    1. sizeof(size_t)
    2. sizeof(bitarrayobject)
    3. sizeof(decodetreeobject)
    4. sizeof(binode)
    5. HAVE_BUILTIN_BSWAP64
    6. NDEBUG not defined
    7. PY_LITTLE_ENDIAN
    8. PY_BIG_ENDIAN
    """
    return ()

# classes

class bitarray(object):
    """
    bitarray(initializer=0, /, endian='big', buffer=None) -> bitarray
    
    Return a new bitarray object whose items are bits initialized from
    the optional initializer, and bit-endianness.
    The initializer may be one of the following types:
    a.) `int` bitarray, initialized to zeros, of given length
    b.) `bytes` or `bytearray` to initialize buffer directly
    c.) `str` of 0s and 1s, ignoring whitespace and "_"
    d.) iterable of integers 0 or 1.
    
    Optional keyword arguments:
    
    `endian`: Specifies the bit-endianness of the created bitarray object.
    Allowed values are `big` and `little` (the default is `big`).
    The bit-endianness effects the buffer representation of the bitarray.
    
    `buffer`: Any object which exposes a buffer.  When provided, `initializer`
    cannot be present (or has to be `None`).  The imported buffer may be
    read-only or writable, depending on the object type.
    """
    def all(self): # real signature unknown; restored from __doc__
        """
        all() -> bool
        
        Return True when all bits in bitarray are True.
        Note that `a.all()` is faster than `all(a)`.
        """
        return False

    def any(self): # real signature unknown; restored from __doc__
        """
        any() -> bool
        
        Return True when any bit in bitarray is True.
        Note that `a.any()` is faster than `any(a)`.
        """
        return False

    def append(self, item, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        append(item, /)
        
        Append `item` to the end of the bitarray.
        """
        pass

    def buffer_info(self): # real signature unknown; restored from __doc__
        """
        buffer_info() -> tuple
        
        Return a tuple containing:
        
        0. memory address of buffer
        1. buffer size (in bytes)
        2. bit-endianness as a Unicode string
        3. number of pad bits
        4. allocated memory for the buffer (in bytes)
        5. memory is read-only
        6. buffer is imported
        7. number of buffer exports
        """
        return ()

    def bytereverse(self, start=0, stop, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        bytereverse(start=0, stop=<end of buffer>, /)
        
        For each byte in byte-range(start, stop) reverse bits in-place.
        The start and stop indices are given in terms of bytes (not bits).
        Also note that this method only changes the buffer; it does not change the
        bit-endianness of the bitarray object.  Pad bits are left unchanged such
        that two consecutive calls will always leave the bitarray unchanged.
        """
        pass

    def clear(self): # real signature unknown; restored from __doc__
        """
        clear()
        
        Remove all items from the bitarray.
        """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """
        copy() -> bitarray
        
        Return a copy of the bitarray.
        """
        return bitarray

    def count(self, value=1, start=0, stop, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        count(value=1, start=0, stop=<end>, step=1, /) -> int
        
        Number of occurrences of `value` bitarray within `[start:stop:step]`.
        Optional arguments `start`, `stop` and `step` are interpreted in
        slice notation, meaning `a.count(value, start, stop, step)` equals
        `a[start:stop:step].count(value)`.
        The `value` may also be a sub-bitarray.  In this case non-overlapping
        occurrences are counted within `[start:stop]` (`step` must be 1).
        """
        pass

    def decode(self, code, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        decode(code, /) -> iterator
        
        Given a prefix code (a dict mapping symbols to bitarrays, or `decodetree`
        object), decode content of bitarray and return an iterator over
        corresponding symbols.
        """
        pass

    def encode(self, code, iterable, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        encode(code, iterable, /)
        
        Given a prefix code (a dict mapping symbols to bitarrays),
        iterate over the iterable object with symbols, and extend bitarray
        with corresponding bitarray for each symbol.
        """
        pass

    def extend(self, iterable, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        extend(iterable, /)
        
        Append items from to the end of the bitarray.
        If `iterable` is a Unicode string, each `0` and `1` are appended as
        bits (ignoring whitespace and underscore).
        """
        pass

    def fill(self): # real signature unknown; restored from __doc__
        """
        fill() -> int
        
        Add zeros to the end of the bitarray, such that the length will be
        a multiple of 8, and return the number of bits added [0..7].
        """
        return 0

    def find(self, sub_bitarray, start=0, stop, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        find(sub_bitarray, start=0, stop=<end>, /, right=False) -> int
        
        Return lowest (or rightmost when `right=True`) index where sub_bitarray
        is found, such that sub_bitarray is contained within `[start:stop]`.
        Return -1 when sub_bitarray is not found.
        """
        pass

    def frombytes(self, bytes, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        frombytes(bytes, /)
        
        Extend bitarray with raw bytes from a bytes-like object.
        Each added byte will add eight bits to the bitarray.
        """
        pass

    def fromfile(self, f, n=-1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        fromfile(f, n=-1, /)
        
        Extend bitarray with up to `n` bytes read from file object `f` (or any
        other binary stream what supports a `.read()` method, e.g. `io.BytesIO`).
        Each read byte will add eight bits to the bitarray.  When `n` is omitted or
        negative, all bytes until EOF is reached.  When `n` is non-negative but
        exceeds the data available, `EOFError` is raised (but the available data
        is still read and appended).
        """
        pass

    def index(self, sub_bitarray, start=0, stop, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        index(sub_bitarray, start=0, stop=<end>, /, right=False) -> int
        
        Return lowest (or rightmost when `right=True`) index where sub_bitarray
        is found, such that sub_bitarray is contained within `[start:stop]`.
        Raises `ValueError` when the sub_bitarray is not present.
        """
        pass

    def insert(self, index, value, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        insert(index, value, /)
        
        Insert `value` into bitarray before `index`.
        """
        pass

    def invert(self, index, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        invert(index=<all bits>, /)
        
        Invert all bits in bitarray (in-place).
        When the optional `index` is given, only invert the single bit at index.
        """
        pass

    def pack(self, bytes, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        pack(bytes, /)
        
        Extend bitarray from a bytes-like object, where each byte corresponds
        to a single bit.  The byte `b'\x00'` maps to bit 0 and all other bytes
        map to bit 1.
        """
        pass

    def pop(self, index=-1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        pop(index=-1, /) -> item
        
        Remove and return item at `index` (default last).
        Raises `IndexError` if index is out of range.
        """
        pass

    def remove(self, value, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        remove(value, /)
        
        Remove the first occurrence of `value`.
        Raises `ValueError` if value is not present.
        """
        pass

    def reverse(self): # real signature unknown; restored from __doc__
        """
        reverse()
        
        Reverse all bits in bitarray (in-place).
        """
        pass

    def search(self, sub_bitarray, start=0, stop, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        search(sub_bitarray, start=0, stop=<end>, /, right=False) -> iterator
        
        Return iterator over indices where sub_bitarray is found, such that
        sub_bitarray is contained within `[start:stop]`.
        The indices are iterated in ascending order (from lowest to highest),
        unless `right=True`, which will iterate in descending order (starting with
        rightmost match).
        """
        pass

    def setall(self, value, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        setall(value, /)
        
        Set all elements in bitarray to `value`.
        Note that `a.setall(value)` is equivalent to `a[:] = value`.
        """
        pass

    def sort(self, reverse=False): # real signature unknown; restored from __doc__
        """
        sort(reverse=False)
        
        Sort all bits in bitarray (in-place).
        """
        pass

    def to01(self, group=0, sep=' '): # real signature unknown; restored from __doc__
        """
        to01(group=0, sep=' ') -> str
        
        Return bitarray as Unicode string of '0's and '1's.
        The bits are grouped into `group` bits (default is no grouping).
        When grouped, the string `sep` is inserted between groups
        of `group` characters, default is a space.
        """
        return ""

    def tobytes(self): # real signature unknown; restored from __doc__
        """
        tobytes() -> bytes
        
        Return the bitarray buffer in bytes (pad bits are set to zero).
        """
        return b""

    def tofile(self, f, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        tofile(f, /)
        
        Write byte representation of bitarray to file object f.
        """
        pass

    def tolist(self): # real signature unknown; restored from __doc__
        """
        tolist() -> list
        
        Return bitarray as list of integers.
        `a.tolist()` equals `list(a)`.
        """
        return []

    def unpack(self, zero=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        unpack(zero=b'\x00', one=b'\x01') -> bytes
        
        Return bytes that contain one byte for each bit in the bitarray,
        using specified mapping.
        """
        pass

    def _freeze(self, *args, **kwargs): # real signature unknown
        pass

    def __add__(self, *args, **kwargs): # real signature unknown
        """ Return self+value. """
        pass

    def __and__(self, *args, **kwargs): # real signature unknown
        """ Return self&value. """
        pass

    def __buffer__(self, *args, **kwargs): # real signature unknown
        """ Return a buffer object that exposes the underlying memory of the object. """
        pass

    def __contains__(self, *args, **kwargs): # real signature unknown
        """ Return bool(key in self). """
        pass

    def __copy__(self, *args, **kwargs): # real signature unknown
        """
        copy() -> bitarray
        
        Return a copy of the bitarray.
        """
        pass

    def __deepcopy__(self, *args, **kwargs): # real signature unknown
        """
        copy() -> bitarray
        
        Return a copy of the bitarray.
        """
        pass

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __iadd__(self, *args, **kwargs): # real signature unknown
        """ Implement self+=value. """
        pass

    def __iand__(self, *args, **kwargs): # real signature unknown
        """ Return self&=value. """
        pass

    def __ilshift__(self, *args, **kwargs): # real signature unknown
        """ Return self<<=value. """
        pass

    def __imul__(self, *args, **kwargs): # real signature unknown
        """ Implement self*=value. """
        pass

    def __init__(self, initializer=0, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    def __invert__(self, *args, **kwargs): # real signature unknown
        """ ~self """
        pass

    def __ior__(self, *args, **kwargs): # real signature unknown
        """ Return self|=value. """
        pass

    def __irshift__(self, *args, **kwargs): # real signature unknown
        """ Return self>>=value. """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __ixor__(self, *args, **kwargs): # real signature unknown
        """ Return self^=value. """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lshift__(self, *args, **kwargs): # real signature unknown
        """ Return self<<value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    def __mul__(self, *args, **kwargs): # real signature unknown
        """ Return self*value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __or__(self, *args, **kwargs): # real signature unknown
        """ Return self|value. """
        pass

    def __rand__(self, *args, **kwargs): # real signature unknown
        """ Return value&self. """
        pass

    def __reduce__(self, *args, **kwargs): # real signature unknown
        """ Internal. Used for pickling support. """
        pass

    def __release_buffer__(self, *args, **kwargs): # real signature unknown
        """ Release the buffer object that exposes the underlying memory of the object. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __rlshift__(self, *args, **kwargs): # real signature unknown
        """ Return value<<self. """
        pass

    def __rmul__(self, *args, **kwargs): # real signature unknown
        """ Return value*self. """
        pass

    def __ror__(self, *args, **kwargs): # real signature unknown
        """ Return value|self. """
        pass

    def __rrshift__(self, *args, **kwargs): # real signature unknown
        """ Return value>>self. """
        pass

    def __rshift__(self, *args, **kwargs): # real signature unknown
        """ Return self>>value. """
        pass

    def __rxor__(self, *args, **kwargs): # real signature unknown
        """ Return value^self. """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __sizeof__(self, *args, **kwargs): # real signature unknown
        """ Return size of bitarray object in bytes. """
        pass

    def __xor__(self, *args, **kwargs): # real signature unknown
        """ Return self^value. """
        pass

    endian = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """bit-endianness as Unicode string"""

    nbytes = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """buffer size in bytes"""

    padbits = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """number of pad bits"""

    readonly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """bool indicating whether buffer is read-only"""



class decodetree(object):
    """
    decodetree(code, /) -> decodetree
    
    Given a prefix code (a dict mapping symbols to bitarrays),
    create a binary tree object to be passed to `.decode()`.
    """
    def complete(self): # real signature unknown; restored from __doc__
        """
        complete() -> bool
        
        Return whether tree is complete.  That is, whether or not all
        nodes have both children (unless they are symbols nodes).
        """
        return False

    def nodes(self): # real signature unknown; restored from __doc__
        """
        nodes() -> int
        
        Return number of nodes in tree (internal and symbol nodes).
        """
        return 0

    def todict(self): # real signature unknown; restored from __doc__
        """
        todict() -> dict
        
        Return a dict mapping the symbols to bitarrays.  This dict is a
        reconstruction of the code dict which the object was created with.
        """
        return {}

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, code, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __sizeof__(self, *args, **kwargs): # real signature unknown
        pass


# variables with complex values

__loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x000001F0A9479480>'

__spec__ = None # (!) real value is "ModuleSpec(name='bitarray._bitarray', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000001F0A9479480>, origin='C:\\\\Programs\\\\Python\\\\Python313\\\\Lib\\\\site-packages\\\\bitarray\\\\_bitarray.cp313-win_amd64.pyd')"