Print to stderr.

Read a block of PIC compressed data from BitStream *bs*. Reading will stop when *want_size* output bytes can be provided, or

Read *bits* bits from bitstream and increment position accordingly. The pure-python implementation supports reading arbitrarily many

Append output bytes *buf* to dictionary.

Convert arbitrary integer to c unsigned char type range as if casted in c. >>> c_uchar(0x12345678) 120 >>> (c_uchar(-123), c_uchar(-

Rotate *i* left by *n* bits within the uint32 value range. >>> c_rot32(0xF0000000, 4) 15 >>> c_rot32(0xF0, -4) 15

Add *a* and *b* within the uint32 value range. >>> c_add32(0xFFFFFFFF, 1) 0 >>> c_add32(0xFFFFFFFF, 0xFFFFFFFF) 4294967294

Return a list of :class:`AceMember` objects for the members of the archive. The objects are in the same order as they are in

True iff :class:`AceMember` instance describes an encrypted archive member.

Read a single Huffman symbol from BitStream *bs* by peeking the maximum code length in bits from the bit stream, looking up t

True iff :class:`AceMember` instance describes a directory.

Test an archive member. Returns False if any corruption was found, True if the header and decompression was okay. *Member* c

The blowfish round function operating on an integer.

Convert DOS format 32bit timestamp to datetime object. Timestamps with illegal values out of the allowed range are ignored and a datetime

Returns message string *msg* wrapped in a plain ASCII box. If *title* is given, add *title* in the top horizontal bar. Lines will be padd

Add all elements of *args* within the uint32 value range. >>> c_sum32(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF) 4294967293

Read a Huffman tree consisting of codes and their widths from BitStream *bs*. The caller specifies the maximum width of a single

Reinitialize the PIC decompression engine. Read width and planes from BitStream *bs* and reset all data dependent state to in

Parse a single header from self.__file at the current file position. Raises CorruptedArchiveError if the header cannot be parsed.

Refill the internal buffer with data read from file.

Returns the current absolute position in the file and asserts that it lies within the defined file segment.

Return the ACE CRC-16 checksum of the bytes in *buf*. >>> ace_crc16(b"123456789") 50905

Convert arbitrary integer to c signed char type range as if casted in c. >>> c_schar(0x12345678) 120 >>> (c_schar(-128), c_schar(-12

Close the underlying file object for this volume. Can safely be called multiple times.

Register bytes in *buf* produced by other decompression modes into the LZ77 dictionary.

Set the required dictionary size for the next LZ77 decompression run.

Dump ACE headers in this archive volume to *file*.

Return an :class:`AceMember` object corresponding to archive member *member*. Raise :class:`KeyError` or :class:`IndexError`

Return True iff archive is a solid archive, i.e. iff the archive members are linked to each other by sharing the same LZ77 dictionary

Read a Golomb-Rice code with *r_bits* remainder bits and an arbitrary number of quotient bits from bitstream and return the represent

Read the archive member by yielding blocks of decompressed bytes. *Member* can refer to an :class:`AceMember` object, a member name o

Encrypt a single block consisting of integers *l* and *r*.

Return *length* bits from byte *value*, starting at position *start*. Behaviour is undefined for start < 0, length < 0 or start + len

Calculate the list of Huffman codes corresponding to the symbols implicitly described by the list of *widths* and maximal width

With X being the current position, the predictors use the pixels above (A), to the left (B) and in the corner (C):

Read the Huffman trees as well as the blocksize from BitStream *bs*; essentially this starts reading into a next block of sym

Close the archive and all open files. No other methods may be called after having called :meth:`AceArchive.close`, but callin

ACE CRC-32 checksum of decompressed data as recorded in the archive, as :class:`int`. ACE CRC-32 is the bitwise inverse of st

Timestamp as recorded in the archive, as :class:`datetime.datetime` instance.

Decompress an ACE MAIN or FILE comment from bytes *buf* and return the decompressed bytes.

Extract an archive member to *path* or the current working directory. *Member* can refer to an :class:`AceMember` object, a member na

Return a list of the (file)names of all the members in the archive in the order they are in the archive.

Peek at next *bits* bits in the stream without incrementing position. A maximum of 31 bits beyond the end of the input file data are

Read a length symbol from BitStream *bs*.

Skip *bits* bits in the stream. Raise EOFError when skipping beyond the end of the input file data. The pure-python implement

Decrypt a single block consisting of integers *l* and *r*.

Initialize blowfish state using 160-bit key *key* as list or tuple of integers.

Derive the decryption key from password bytes *pwd* using a single application of SHA-1 using non-standard padding. The password is

Get next symbol from BitStream *bs*.

Return an :class:`AceMember` object corresponding to archive member index *idx*. Raise :class:`IndexError` if *idx* is not pr

Return an :class:`AceMember` object corresponding to archive member name *name*. Raise :class:`KeyError` if *name* is not pre

Derive the filename of the next volume after this one. If the filename ends in ``.[cC]XX``, XX is incremented by 1. Otherwise

Parse ACE headers from self.__file. If *search* is > 0, search for the magic bytes in the first *search* bytes of the file.

In-place quicksort of lists *keys* and *values* in descending order of *keys*. Python uses a stable sorting algorithm, while the

Decompress a row of pixels.

Decode and sanitize filename for security and platform independence. Returns either a sanitized relative path, or an empty string.

Arbitrary signed integer division with c behaviour. >>> (c_div(10, 3), c_div(-10, -3), c_div(-10, 3), c_div(10, -3)) (3, 3, -3, -3)

Copy *n* previously produced output bytes to end of dictionary, starting from position *dist* away from the end.

Copy output bytes produced by other decompression methods from *buf* into dictionary. This operation may cause the

Return copy of last *n* appended output bytes for handing them to the caller. This operation may cause the dictionary to shr

Decrypt a buffer of complete blocks, i.e. of length that is a multiple of the block size returned by the blocksize property.

Returns a :class:`FileSegmentIO` object for the file header *fhdr* belonging to this volume.

Get next sample, reading from BitStream *bs* if necessary.

Calculate the error context to use based on the differences between the neighbouring pixels D-A, A-C and C-B:

Return True iff archive is a multi-volume archive as determined by the archive headers. When opening the last volume of a mu

Read an unsigned integer with previously known bit width *bits* from stream. The most significant bit is not encoded in the bit stre

Read a main symbol from BitStream *bs*.

Set expected dictionary size for next decompression run.