eyed3.utils package

Submodules

eyed3.utils.art module

eyed3.utils.art.FRONT_COVER = 'FRONT_COVER'

Album front cover.

eyed3.utils.art.BACK_COVER = 'BACK_COVER'

Album back cover.

eyed3.utils.art.MISC_COVER = 'MISC_COVER'

Other part of the album cover; liner notes, gate-fold, etc.

eyed3.utils.art.LOGO = 'LOGO'

Artist/band logo.

eyed3.utils.art.ARTIST = 'ARTIST'

Artist/band images.

eyed3.utils.art.LIVE = 'LIVE'

Artist/band images.

eyed3.utils.art.FILENAMES = {'ARTIST': ['artist*'], 'BACK_COVER': ['cover-back', 'back', 'cover-back_*'], 'FRONT_COVER': ['cover-front', 'cover-alternate*', 'cover', 'folder', 'front', 'cover-front_*', 'flier'], 'LIVE': ['live*'], 'LOGO': ['logo*'], 'MISC_COVER': ['cover-insert*', 'cover-liner*', 'cover-disc', 'cover-media*']}

A mapping of art types to lists of filename patterns (excluding file extension): type -> [file_pattern, ..].

eyed3.utils.art.TO_ID3_ART_TYPES = {'ARTIST': [7, 8, 10], 'BACK_COVER': [4], 'FRONT_COVER': [3, 0, 1, 5], 'LIVE': [15, 14], 'LOGO': [19], 'MISC_COVER': [6]}

A mapping of art types to ID3 APIC (image) types: type -> [apic_type, ..]

eyed3.utils.art.FROM_ID3_ART_TYPES = {0: 'FRONT_COVER', 1: 'FRONT_COVER', 3: 'FRONT_COVER', 4: 'BACK_COVER', 5: 'FRONT_COVER', 6: 'MISC_COVER', 7: 'ARTIST', 8: 'ARTIST', 10: 'ARTIST', 14: 'LIVE', 15: 'LIVE', 19: 'LOGO'}

A mapping of ID3 art types to eyeD3 art types; the opposite of TO_ID3_ART_TYPES.

eyed3.utils.art.matchArtFile(filename)

Compares filename (case insensitive) with lists of common art file names and returns the type of art that was matched, or None if no types were matched.

eyed3.utils.art.getArtFromTag(tag, type_=None)

Returns a list of eyed3.id3.frames.ImageFrame objects matching type_, all if type_ is None, or empty if tag does not contain art.

eyed3.utils.binfuncs module

eyed3.utils.binfuncs.bytes2bin(bites, sz=8)

Accepts a string of bytes (chars) and returns an array of bits representing the bytes in big endian byte order. An optional max sz for each byte (default 8 bits/byte) which can be used to mask out higher bits.

eyed3.utils.binfuncs.bin2bytes(x)

Convert an array of bits (MSB first) into a string of characters.

eyed3.utils.binfuncs.bin2dec(x)

Convert x, an array of “bits” (MSB first), to it’s decimal value.

eyed3.utils.binfuncs.bytes2dec(bites, sz=8)

eyed3.utils.binfuncs.dec2bin(n, p=1)

Convert a decimal value n to an array of bits (MSB first). Optionally, pad the overall size to p bits.

eyed3.utils.binfuncs.dec2bytes(n, p=1)

eyed3.utils.binfuncs.bin2synchsafe(x)

Convert x, a list of bits (MSB first), to a synch safe list of bits. (section 6.2 of the ID3 2.4 spec).

eyed3.utils.binfuncs.bytes2signedInt16(bites: bytes)

eyed3.utils.binfuncs.signedInt162bytes(n: int)

eyed3.utils.console module

class eyed3.utils.console.AnsiCodes(codes)

Bases: object

classmethod init(allow_colors)

class eyed3.utils.console.AnsiFore

Bases: object

GREY = 30

RED = 31

GREEN = 32

YELLOW = 33

BLUE = 34

MAGENTA = 35

CYAN = 36

WHITE = 37

RESET = 39

class eyed3.utils.console.AnsiBack

Bases: object

GREY = 40

RED = 41

GREEN = 42

YELLOW = 43

BLUE = 44

MAGENTA = 45

CYAN = 46

WHITE = 47

RESET = 49

class eyed3.utils.console.AnsiStyle

Bases: object

RESET_ALL = 0

BRIGHT = 1

RESET_BRIGHT = 22

DIM = 2

RESET_DIM = 22

ITALICS = 3

RESET_ITALICS = 23

UNDERLINE = 4

RESET_UNDERLINE = 24

BLINK_SLOW = 5

RESET_BLINK_SLOW = 25

BLINK_FAST = 6

RESET_BLINK_FAST = 26

INVERSE = 7

RESET_INVERSE = 27

STRIKE_THRU = 9

RESET_STRIKE_THRU = 29

eyed3.utils.console.ERROR_COLOR()

eyed3.utils.console.WARNING_COLOR()

eyed3.utils.console.HEADER_COLOR()

class eyed3.utils.console.Spinner(msg, file=None, step=1, chars=None, use_unicode=True, print_done=True)

Bases: object

A class to display a spinner in the terminal.

It is designed to be used with the with statement:

with Spinner("Reticulating splines", "green") as s:
    for item in enumerate(items):
        s.next()

class eyed3.utils.console.ProgressBar(total_or_items: int | Sequence, file=None)

Bases: object

A class to display a progress bar in the terminal.

It is designed to be used either with the with statement:

with ProgressBar(len(items)) as bar:
    for item in enumerate(items):
        bar.update()

or as a generator:

for item in ProgressBar(items):
    item.process()

total_or_itemsint or sequence

If an int, the number of increments in the process being tracked. If a sequence, the items to iterate over.

filewritable file-like object, optional

The file to write the progress bar to. Defaults to sys.stdout. If file is not a tty (as determined by calling its isatty member, if any), the scrollbar will be completely silent.

update(value=None)

Update the progress bar to the given value (out of the total given to the constructor).

classmethod map(function, items, multiprocess=False, file=None)

Does a map operation while displaying a progress bar with percentage complete.

def work(i):
    print(i)

ProgressBar.map(work, range(50))

Parameters:

functionfunction

Function to call for each step

itemssequence

Sequence where each element is a tuple of arguments to pass to function.

multiprocessbool, optional

If True, use the multiprocessing module to distribute each task to a different processor core.

filewriteable file-like object, optional

The file to write the progress bar to. Defaults to sys.stdout. If file is not a tty (as determined by calling its isatty member, if any), the scrollbar will be completely silent.

eyed3.utils.console.printMsg(s)

eyed3.utils.console.printError(s)

eyed3.utils.console.printWarning(s)

eyed3.utils.console.printHeader(s)

eyed3.utils.console.boldText(s, c=None)

eyed3.utils.console.formatText(s, b=False, c=None)

eyed3.utils.console.cformat(msg, fg, bg=None, styles=None)

Format msg with foreground and optional background. Optional styles lists will also be applied. The formatted string is returned.

eyed3.utils.console.getTtySize(fd=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, check_tty=True)

eyed3.utils.console.cprint(msg, fg, bg=None, styles=None, file=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)

Calls cformat and prints the result to output stream file.

eyed3.utils.log module

class eyed3.utils.log.Logger(name)

Bases: Logger

Base class for all loggers

Initialize the logger with a name and an optional level.

verbose(msg, *args, **kwargs)

Log  msg at ‘verbose’ level, debug < verbose < info

eyed3.utils.log.getLogger(name)

eyed3.utils.log.initLogging()

initialize the default logger with console output

eyed3.utils.prompt module

eyed3.utils.prompt.DISABLE_PROMPT = None

Whenever a prompt occurs and this value is not None it can be exit to call sys.exit (see EXIT_STATUS) or raise to throw a RuntimeError, which can be caught if desired.

exception eyed3.utils.prompt.PromptExit

Bases: RuntimeError

Raised when DISABLE_PROMPT is ‘raise’ and prompt is called.

eyed3.utils.prompt.parseIntList(resp)

eyed3.utils.prompt.prompt(msg, default=None, required=True, type_=<class 'str'>, validate=None, choices=None)

Prompt user for input, the prequest is in msg. If default is not None it will be displayed as the default and returned if not input is entered. The value None is only returned if required is False. The response is passed to type_ for conversion (default is unicode) before being returned. An optional list of valid responses can be provided in choices.

Module contents

eyed3.utils.os_walk_unpack(w)

eyed3.utils.guessMimetype(filename, with_encoding=False)

Deprecated since version 0.9a2: This will be removed in 1.0. Use eyed3.mimetype.guessMimetype() instead.

eyed3.utils.walk(handler, path, excludes=None, fs_encoding='utf-8', recursive=False)

A wrapper around os.walk which handles exclusion patterns and multiple path types (str, pathlib.Path, bytes).

class eyed3.utils.FileHandler

Bases: object

A handler interface for eyed3.utils.walk() callbacks.

handleFile(f)

Called for each file walked. The file f is the full path and the return value is ignored. If the walk should abort the method should raise a StopIteration exception.

handleDirectory(d, files)

Called for each directory d after handleFile has been called for each file in files. StopIteration may be raised to halt iteration.

handleDone()

Called when there are no more files to handle.

eyed3.utils.requireUnicode(*args)

Function decorator to enforce str/unicode argument types. None is a valid argument value, in all cases, regardless of not being unicode. *args Positional arguments may be numeric argument index values (requireUnicode(1, 3) - requires argument 1 and 3 are unicode) or keyword argument names (requireUnicode(“title”)) or a combination thereof.

eyed3.utils.requireBytes(*args)

Function decorator to enforce byte string argument types.

eyed3.utils.formatTime(seconds, total=None, short=False)

Format seconds (number of seconds) as a string representation. When short is False (the default) the format is:

HH:MM:SS.

Otherwise, the format is exacly 6 characters long and of the form:

1w 3d 2d 4h 1h 5m 1m 4s 15s

If total is not None it will also be formatted and appended to the result seperated by ‘ / ‘.

eyed3.utils.formatSize(size, short=False)

Format size (number of bytes) into string format doing KB, MB, or GB conversion where necessary.

When short is False (the default) the format is smallest unit of bytes and largest gigabytes; ‘234 GB’. The short version is 2-4 characters long and of the form

256b 64k 1.1G

eyed3.utils.formatTimeDelta(td)

Format a timedelta object td into a string.

eyed3.utils.chunkCopy(src_fp, dest_fp, chunk_sz=524288)

Copy src_fp to dest_fp in chunk_sz byte increments.

class eyed3.utils.ArgumentParser(*args, **kwargs)

Bases: ArgumentParser

Subclass of argparse.ArgumentParser that adds version and log level options.

parse_args(*args, **kwargs)

class eyed3.utils.LoggingAction(*args, **kwargs)

Bases: _AppendAction

eyed3.utils.datePicker(thing, prefer_recording_date=False)

This function returns a date of some sort, amongst all the possible dates (members called release_date, original_release_date, and recording_date of type eyed3.core.Date).

The order of preference is: 1) date of original release 2) date of this versions release 3) the recording date.

Unless prefer_recording_date is True in which case the order is 3, 1, 2.

None will be returned if no dates are available.

eyed3.utils.makeUniqueFileName(file_path, uniq='')

The file_path is the desired file name, and it is returned if the file does not exist. In the case that it already exists the path is adjusted to be unique. First, the uniq string is added, and then a counter is used to find a unique name.

eyed3.utils.b(x, encoder=None)

Converts x to a bytes string if not already.

Parameters:

• x – The string.

• encoder – Optional codec encoder to perform the conversion. The default is codecs.latin_1_encode.

Returns:

The byte string if conversion was needed.