tocoli package

Subpackages

• tocoli.dsl package
  • Submodules
  • tocoli.dsl.filter module
  • tocoli.dsl.join module
  • tocoli.dsl.map module
  • tocoli.dsl.sort module
  • tocoli.dsl.string module
  • Module contents
• tocoli.py2 package
  • Submodules
  • tocoli.py2.enc module
  • Module contents
• tocoli.py3 package
  • Submodules
  • tocoli.py3.enc module
  • Module contents

Submodules

tocoli.auth module

tocoli.auth.encrypt_api_key(user_id, secret_key)

Encrypts a user id into an api key (token). The generated api key has no expiration time.

tocoli.auth.encrypt_password(password, rounds=100001)

Encrypts a password as salted hash.

tocoli.auth.encrypt_token(user_id, secret_key, expiration=1800)

Encrypts a user id into a timed token. Default expiration time is 30 minutes.

tocoli.auth.generate_salt(length=10, chars='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')

Generates a salt. Defaults to a random salt from [0-9A-Za-z].

tocoli.auth.verify_api_key(api_key, secret_key)

Verifies a given api key (token). Returns the decoded user id or None.

tocoli.auth.verify_password(hash, password)

Verifies a password hash. Returns True on success else False

tocoli.auth.verify_token(token, secret_key)

Verifies a given token. Returns the decoded user id or None.

tocoli.cmp module

tocoli.cmp.comparable(left, right, case_sensitive=False)

Makes values comparable. Returns a tuple of values

tocoli.enc module

tocoli.enc.decode(input, encoding='utf-8', errors='strict', detect='utf-8')

Decode any string. Returns a unicode decoded string otherwise the input.

Use this function to decode an encoded string. Its recommended to use this function as early as possible in your data flow, when you received data from an external resource (e.g. stdin, file, API, …). Once decoded you have access to the encoded information and can operate on it. This func- tion is a universal wrapper for the built-in codecs.decode() function.

Examples

Default encoding utf-8:

>>> decode('café')
u'café'     # utf-8 decoded string

Non default encoding:

>>> decode('café', 'latin-1')
u'café'     # utf-8 decoded string

Advanced codec support:

>>> decode('Y2Fmw6k=\n', 'base64')
u'café'     # utf-8 decoded string

Parameters:

• input (str) – Any string you like to decode. The string can be a byte string or a unicode decoded string. The function makes sure to treat the input type in the correct manner.
• encoding (Optional[str]) – Input encoding. Defaults to utf-8. Defines the encoding of the input.
• errors (Optional[str]) –

  Error handling schemes. Defaults to ‘strict’ These string values are predefined:

  ’strict’ - raise a ValueError error (or a subclass) ‘ignore’ - ignore the character and continue with the next ‘replace’ - replace with a suitable replacement character;

  Python will use the official U+FFFD REPLACEMENT CHARACTER for the builtin Unicode codecs on decoding and ‘?’ on encoding.

  ’xmlcharrefreplace’ - Replace with the appropriate XML

  character reference (only for encoding).

  ’backslashreplace’ - Replace with backslashed escape sequences

  (only for encoding).

• detect (Optional[str]) – Inner encoding. Defaults to utf-8. This parameter defines the recursive decoding type (e.g. contains a base64 encoded string inside another encoded string, which might be a utf-8 or something else). If the given inner decoding type is not correct, then the function tries to detect the encoding auto- matically.

Returns:

unicode (python2) str (python3): Encoded byte string.

tocoli.enc.encode(input, encoding='utf-8', errors='strict', input_encoding='utf-8')

Encode any string. Returns a byte string otherwise the input.

Use this funtion to encode strings you like to write to any kind of output (e.g. stdout, file, API, …). This is useful to exchange information in a standardized way (the encoding). This function is a universal wrapper for the built-in codecs.encode() function.

Examples

Default usage:

>>> encode('café')
b'café'      # utf-8 encoded byte string

Transform encoding:

>>> encode('café', 'utf-8', input_encoding='latin-1')
b'café'      # utf-8 encoded byte string

Advanced codec support:

>>> encode('café', 'base64')
b'Y2Fmw6k=\n'       # base64 encoded byte string
                    # inner encoding is always utf-8

Parameters:

• input (str) – Any string you like to encode. The string can be a byte string or a unicode decoded string. The function makes sure to treat the input type in the correct manner.
• encoding (Optional[str]) – Output encoding. Defaults to utf-8. Defines the encoding for the resulting byte string.
• errors (Optional[str]) –

  Error handling schemes. Defaults to ‘strict’ These string values are predefined:

  ’strict’ - raise a ValueError error (or a subclass) ‘ignore’ - ignore the character and continue with the next ‘replace’ - replace with a suitable replacement character;

  Python will use the official U+FFFD REPLACEMENT CHARACTER for the builtin Unicode codecs on decoding and ‘?’ on encoding.

  ’xmlcharrefreplace’ - Replace with the appropriate XML

  character reference (only for encoding).

  ’backslashreplace’ - Replace with backslashed escape sequences

  (only for encoding).

• input_encoding (Optional[str]) – Given encoding. Defaults to utf-8. Set this parameter if your input is not encoded as utf-8.

Returns:

str (python2) bytes (python3): Encoded byte string.

tocoli.filter module

tocoli.filter.clean(str, include='', alpha='a-zA-Z', numeric='0-9')

Filter unwanted characters. Returns the filtered string.

Examples

>>> clean('1.20€')
'120'

>>> clean('1.20€', '.')
'1.20'

>>> clean('1.20€', '.€')
'1.20€'

>>> clean('Hello', alpha='a-z')
'ello'

Parameters:

• str (str) – input string
• include (str) – Regular-expression raw string. Defaults to ‘’. This parameter defines which additional characters to include to the result.
• alpha (str) – Regular-expression raw string. Defaults to ‘a-zA-Z’. This parameter defines which alpha characters should be in the result.
• numeric (str) – Regular-expression raw string. Defaults to ‘0-9’. This parameter defines which numeric characters should be in the result.

Returns:

string which only contains accepted characters.

Return type:

str

tocoli.filter.filter_bytes(s, where, encoding='utf-8')

Returns bytes.

tocoli.filter.filter_dict_by_key(d, keys, all_keys=False)

Returns this ‘dict’ when it contains at least one of the specified keys else None.

tocoli.filter.filter_dict_by_value(d, keywords, keys=None, all_keys=False)

Returns this ‘dict’ when it contains at least one of the keywords as value in the specified keys else None.

tocoli.filter.filter_dicts_by_keys(iterable, keys, all_keys=False)

Returns a ‘list’ of ‘dict’ whose dictionaries contain at least one of the specified keys.

tocoli.filter.filter_dicts_by_values(iterable, keywords, keys=None, all_keys=False)

Returns a ‘list’ of ‘dict’ whose dictionaries contain at least one of the keywords as value in the specified keys.

tocoli.filter.filter_iter(i, where)

Returns a list.

tocoli.filter.filter_list(l, where)

Returns a list.

tocoli.filter.filter_set(s, where)

Returns a set.

tocoli.filter.filter_string(s, where)

Returns a string.

tocoli.filter.filter_strings_by_keywords(iterable, keywords, case_sensitive=False)

Filter strings by exact keywords. Returns a new list.

tocoli.filter.filter_strings_by_similarity(iterable, keywords, ratio=0.8, weights=(1, 4), case_sensitive=False)

Filter strings by similar keywords. Returns a new list of strings.

tocoli.filter.filter_tuple(t, where)

Returns a list.

tocoli.fn module

tocoli.fn.false(*args, **kwargs)

tocoli.fn.first(ordered)

tocoli.fn.first_arg(*args)

tocoli.fn.first_kwarg(**kwargs)

tocoli.fn.identities(*args)

tocoli.fn.identities_args_kwargs(*args, **kwargs)

tocoli.fn.identities_kwargs(**kwargs)

tocoli.fn.identity(x)

tocoli.fn.identity_values(*args, **kwargs)

tocoli.fn.key(iterable, value=None, sort=False, reverse=False, first=False, position=0)

Generic key getter. Returns one or more keys.

tocoli.fn.last(ordered)

tocoli.fn.last_arg(*args)

tocoli.fn.negate(x)

tocoli.fn.no(*args, **kwargs)

tocoli.fn.return_values_as_tuple(**kwargs)

tocoli.fn.second(ordered)

tocoli.fn.second_arg(*args)

tocoli.fn.third(ordered)

tocoli.fn.third_arg(*args)

tocoli.fn.true(*args, **kwargs)

tocoli.fn.value(iterable, key=None, position=1)

Generic value getter. Returns containing value.

tocoli.fn.yes(*args, **kwargs)

tocoli.join module

tocoli.join.join_strings_by_keywords(list, keywords, join=' ')

Join strings by keywords. Returns a new list with joined strings.

tocoli.join.join_values_as_string(*args, **kwargs)

Concatenates all values as one string. Returns a string.

tocoli.map module

tocoli.map.map_to_non_accented_characters(str)

Returns a non accented string.

tocoli.map.recursive_map(item, function=<function first_arg>, flags=6487, parent=None)

Maps any function recursivly to the item.

tocoli.ratio module

class tocoli.ratio.Nominator

MAX = 'max'

MIN = 'min'

tocoli.ratio.count_equal_chars(str1, str2)

tocoli.ratio.equal(str1, str2, nominator='max')

A simple ratio function based on the equality.

tocoli.ratio.median(list)

tocoli.ratio.meta(str1, str2, ratios, weights)

A meta ratio function. Returns a weighted meta ratio.

The Wiesendahl ratio is a meta ratio which combines a weighted ratio of given ratio functions.

Parameters:

• str1 (str) – first string
• str2 (str) – second string
• ratios (list(function(str, str) -> float)) – ratio functions This parameter is a list of ratio functions.
• weights (list(float)) – list of weights Each weight gets applied to its corresponding function.

Returns:

the combined and weighted meta ratio

Return type:

float

tocoli.ratio.similarity(str1, str2, weights=(1, 1), case_sensitive=True)

tocoli.regex module

class tocoli.regex.Anchors

BEGINNING = '^'

END = '$'

NOT_WORD_BOUNDARY = '\\B'

WORD_BOUNDARY = '\\b'

class tocoli.regex.CharClass

ANY = '.'

DIGIT = '\\d'

NOT_DIGIT = '\\D'

NOT_WHITESPACE = '\\S'

NOT_WORD = '\\W'

WHITESPACE = '\\s'

WORD = '\\w'

class tocoli.regex.Escaped

CARRIAGE_RETURN = '\\r'

FORM_FEED = '\\f'

LINE_FEED = '\\n'

NULL = '\\0'

TAB = '\\t'

VERTICAL_TAB = '\\v'

class tocoli.regex.Flags

GLOBAL_SEARCH = 'g'

IGNORE_CASE = 'i'

MULTILINE = 'm'

class tocoli.regex.Generator(options, dictionary)

generate(input)

class tocoli.regex.QuantifiedRe(expr=None)

Bases: tocoli.regex.Re

lazy()

class tocoli.regex.Quantifier

OPTIONAL = '?'

PLUS = '+'

STAR = '*'

class tocoli.regex.Re(expr=None)

Bases: unicode

add(expr, escape=False)

add_backreference(n)

add_escaped_control_char(char)

add_escaped_hexadecimal(pair)

add_escaped_octal(triplet)

add_escaped_unicode(quadruple)

add_negated_set(chars)

add_set(chars)

escape()

group(capturing=True)

lookahead(lookup, positive=True)

lookbehind(lookup, positive=True)

negated_set()

optional()

plus()

quantify(min, max=None)

set(chars=None)

star()

class tocoli.regex.Substitution

AFTER_MATCH = "$'"

BEFORE_MATCH = '$`'

DOLLAR = '$$'

MATCH = '$&'

capture_group()

tocoli.regex.alternate(left, right)

tocoli.regex.backreference(n)

tocoli.regex.escape(expr)

tocoli.regex.escape_control_char(char)

tocoli.regex.escape_hexadecimal(pair)

tocoli.regex.escape_octal(triplet)

tocoli.regex.escape_unicode(quadruple)

tocoli.regex.generate(str, start=False, end=False, match=None, quantifier='{0, }', setLike=False, dictionary=None)

Generates a python string for regular-expressions.

tocoli.regex.group(expr, capturing=True)

tocoli.regex.group_capturing(expr)

tocoli.regex.group_non_capturing(expr)

tocoli.regex.lazy(quantified_expr)

tocoli.regex.lookahead(expr, lookup, positive=True)

tocoli.regex.lookahead_negative(expr, lookup)

tocoli.regex.lookahead_positive(expr, lookup)

tocoli.regex.lookbehind(expr, loookup, positive=True)

tocoli.regex.lookbehind_negative(expr, lookup)

tocoli.regex.lookbehind_positive(expr, lookup)

tocoli.regex.negated_set(chars, expr=None)

tocoli.regex.optional(expr)

tocoli.regex.plus(expr)

tocoli.regex.quantify(expr, min, max=None)

tocoli.regex.quantify_lazy(expr, min, max=None)

tocoli.regex.range(start, end)

tocoli.regex.set(chars, expr=None)

tocoli.regex.star(expr)

tocoli.sort module

tocoli.sort.sort_bytes(b, key=None, reverse=False, encoding='utf-8')

Returns bytes.

tocoli.sort.sort_dict_by_key(d, reverse=False)

Returns a ‘list’ of tuple(key, value).

tocoli.sort.sort_dict_by_value(d, reverse=False)

Returns a ‘list’ of tuple(key, value).

tocoli.sort.sort_dicts_by_similarity(iterable, keyword, keys, values=<function first_kwarg>, default=None, sequentially=True, reverse=False, weights=(1, 1), case_sensitive=False)

Returns a sorted ‘list’ of ‘dict’.

tocoli.sort.sort_dicts_by_value(iterable, keys, values=<function first_kwarg>, default=None, sequentially=True, reverse=False)

Sort a list of dictionaries as you like!

Sort a ‘list’ of ‘dict’ by value. For simple sorting define keys as ‘list’ of ‘str’, where the strings are keynames. The functional values parameter behaves like the functional key parameter from the built-in sorted function.

Examples

Simple sort by a key:

>>> dicts = [{'name': 'Eve'},
             {'name': 'Alice', 'email': 'alice@example.com'},
             {'email': 'bob@example.com', 'name': 'Bob'}]

>>> sort_dicts_by_value(dicts, ['name'])
[{'name': 'Alice', 'email': 'alice@example.com'},
 {'email': 'bob@example.com', 'name': 'Bob'},
 {'name': 'Eve'}]

Advanced sort for multiple keys and custom values function:

>>> dicts = [{'price': 100},
             {'price': 50, 'shipping': 40},
             {'shipping': 5, 'price': 55}]

>>> def total(price, shipping):
        return price + shipping

>>> sort_dicts_by_value(dicts,
                        ['price', 'shipping'],
                        values=total,
                        default=0,
                        sequentially=False)
[{'price': 55, 'shipping': 5},
 {'price': 50, 'shipping': 40},
 {'price': 100}]

Sort dictionaries with non string keys:

>>> dicts = [{1: False},
             {'right': True, 1: False},
             {1: True, 'right': True}]

>>> def both(left, right):
        return left and right

>>> sort_dicts_by_value(dicts,
                        [{'key': 1, 'alias': 'left'}, 'right'],
                        values=both,
                        default=False,
                        sequentially=False,
                        reverse=True)
[{1: True, 'right': True},
 {1: False},
 {1: False, 'right': True}]

Parameters:

• iterable (list(dict)) – The input dictonaries.
• keys (list(string or dict)) –

  Sort by defined keys. If you have non string keys then keys should be a ‘dict’ instead of a ‘list’ with plain keys, which defines an alternative keyname for the non string key (e.g. keys={'key': 1: alias: 'one'} instead of keys=[1]). Note: Those dictionaries which do not contain any key of keys will be removed from the result.

  Options:

  • 'key': defines the key
  • 'alias': alternative keyname for non string key names
  • 'sort': sort order (ASCENDING or DESCENDING)

• values (function(**kwargs) -> value) – Returns the value to sort by. Defaults to the first value of given keywords (unordered). The values function receives the defined keys as **kwargs. Thus it is possible to process the values easily by their name (e.g. lambda firstname, lastname: firstname + ' ' + lastname). Note: Take the default and the sequentially parameter into account, when you specify a custom values function. In sequential mode you have to expect different keywords (e.g. lambda **kwargs: …).
• default (value) – Default value. Defaults to None. Defines the default value which is passed to the values function if a specified key from keys is not present or None.
• sequentially (bool) – Run in sequence. Defaults to True. If True each key in keys gets sorted one after the other else runs in batch mode and passes all keys to the values function. Note: The keys get sorted in reverse order. Thus the first key gets sorted as last and vice versa.
• reverse (bool) – Reverse sorting. Defaults to False. Reverses sotring order for each key of keys idependently if the sequentially parameter is True else reverses the sorted ‘list’ as whole.

Returns:

A ‘list’ of ‘dict’.

Note: Those dictionaries which do not contain any key of keys will be removed from the result.

Return type:

list

tocoli.sort.sort_iter(i, key=None, reverse=False)

Returns a list.

tocoli.sort.sort_list(l, key=None, reverse=False)

Returns a list.

tocoli.sort.sort_set(s, key=None, reverse=False)

Returns a list.

tocoli.sort.sort_string(s, key=None, reverse=False)

Returns a string.

tocoli.sort.sort_strings_by_similarity(iterable, keyword, reverse=False, weights=(1, 1), case_sensitive=False)

Returns a sorted ‘list’.

tocoli.sort.sort_tuple(t, key=None, reverse=False)

Returns a list.

tocoli.spell module

class tocoli.spell.Dictionary

latin = {'strict': {u'\xe1': u'a|\xe1|\xe4', u'\xfc': u'u|\xfa|ue|\xfce|\xfc', u'tt': u'tt|t', u'cc': u'cc|ck|c|k', u's': u'ss|s|z|c', u'\xf6': u'o|\xf3|\xf6', u'rr': u'rr|r', u'as': u'as|\xe1s|a|\xe1|s', u'z': u'z|c|s|ss', u'es': u'es|e|s', u'a': u'a|\xe1|\xe4', u'c': u'cc|c|z', u'b': u'b|v', u'e': u'e|\xe9', u'\xe4': u'a|\xe1|\xe4', u'g': u'g|j', u'v': u'v|b', u'\xe9': u'e|\xe9', u'k': u'k|c|q', u'j': u'j|g|y|c|h', u'\xed': u'i|\xed|y', u'l': u'll|l', u'o': u'o|\xf3|\xf6', u'n': u'n|nn|\xf1', u'\xf1': u'n|\xf1', u'i': u'i|\xed|y', u'\xf3': u'o|\xf3|\xf6', u'r': u'rr|r', u'u': u'u|\xfa|ue|\xfce|\xfc', u't': u'tt|t', u'nn': u'nn|n|\xf1', u'y': u'y|ll|i', u'\xfa': u'u|\xfa|ue|\xfce|\xfc', u'os': u'os|o|s|a', u'll': u'll|l|j|y'}, 'wide': {u'sch': u'ssh|sch|sh|ch|sc|h|s', u'cc': u'cc|c|k|s|z|q|x|h', u'll': u'll|l|j|y|ii|i', u'yi': u'yi|hi|i|y|ji|xi', u'\xe1': u'a|\xe1|\xe4|o|\xf3', u'b': u'b|v|w', u'd': u'd|t', u'\xe9': u'e|\xe9|i', u'h': u'h|g|x', u'j': u'j|g|y|c|h', u'\xed': u'i|\xed|y|e|l', u'l': u'll|l|j|i', u'n': u'nn|n|\xf1|m', u'\xf1': u'nn|n|\xf1|m', u'i': u'i|\xed|y|e|l', u'\xf3': u'o|\xf3|\xf6|u|a|\xe1', u'r': u'r|rr', u't': u'tt|d|t', u'v': u'v|b|w', u'x': u'cc|ch|ck|ks|c|j|s|x|z', u'z': u'z|c|s', u'ai': u'ai|i|y', u'is': u'is|\xeds|i|\xed|s|ls', u'ay': u'ay|i|y', u'ie': u'ie|\xede|i\xe9|i|e|le', u'es': u'es|\xe9s|e|s|al', u'rr': u'rr|r', u'nn': u'nn|n|\xf1|m', u'y': u'y|ll|i|j', u'ji': u'ji|j\xed|hi|h\xed|xi|x\xed|y|i|\xed', u'a': u'a|\xe1|\xe4|o|\xf3|e', u'sz': u'sz|s|z', u'c': u'cc|c|k|s|z|q|x|h', u'e': u'e|\xe9|i', u'\xe4': u'a|\xe1|\xe4|o|\xf3', u'g': u'g|j|h|c|q', u'ss': u'ss|s|\xdf', u'k': u'ca|k|c|q', u'm': u'm|n', u'o': u'o|\xf3|\xf6|u|a|\xe1', u'\xfc': u'ue|\xfce|u|\xfa|\xfc|v|w|a', u'q': u'q|k|c', u's': u'ss|c|s|z|\xdf|th', u'sh': u'ssh|sch|sh|ch|sc|h|s|ge', u'u': u'ue|\xfce|u|\xfa|\xfc|v|w|a', u'w': u'w|v|b|u', u'\xf6': u'o|\xf3|\xf6|u|a|\xe1', u'sc': u'ssc|sch|sc|sz|c|s', u'ou': u'ou|\xf3u|o\xfa|o|u', u'\xfa': u'ue|\xfce|u|\xfa|\xfc|v|w|a', u'os': u'os|\xf3s|o|\xf3|s|a', u'tt': u'tt|d|t', u'se': u'sse|ss\xe9|se|s\xe9|e|s'}}

tocoli.spell.lookup(word, dictionary)

tocoli.test module

class tocoli.test.Bencher(rounds=1, collect=False, stopwatch=True, precision='0.8')

bench(function, *args, **kwargs)

class tocoli.test.FnPrinter(seperator='-', width=None)

fnprint(function, *args, **kwargs)

tocoli.test.arguments(args=None, kwargs=None)

tocoli.test.seperator(str='', seperator='-', width=80)

tocoli.type module

tocoli.type.to_bool(input)

Returns ‘bool’.

tocoli.type.to_integer(input)

Returns ‘int’.

tocoli.type.to_string(input, encoding='utf-8')

Module contents

The tocolib is a multipurpose utility library.

class tocoli.Py

class Enc

default = 'utf-8'

preferred = 'utf-8'

class Ver

hex = 34016496

major = 2

micro = 12

minor = 7

releaselevel = 'final'

serial = 0

text = '2.7.12 (default, Nov 19 2016, 06:48:10) \n[GCC 5.4.0 20160609]'

static std(io=<open file '<stdout>', mode 'w'>, encoding='utf-8')