repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
sequence | docstring
stringlengths 3
17.3k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 87
242
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
Erotemic/utool | utool/util_dict.py | dict_stack | def dict_stack(dict_list, key_prefix=''):
r"""
stacks values from two dicts into a new dict where the values are list of
the input values. the keys are the same.
DEPRICATE in favor of dict_stack2
Args:
dict_list (list): list of dicts with similar keys
Returns:
dict dict_stacked
CommandLine:
python -m utool.util_dict --test-dict_stack
python -m utool.util_dict --test-dict_stack:1
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_stacked = dict_stack([dict1_, dict2_])
>>> result = ut.repr2(dict_stacked, sorted_=True)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [4]}
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> # Get equivalent behavior with dict_stack2?
>>> # Almost, as long as None is not part of the list
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_stacked_ = dict_stack2([dict1_, dict2_])
>>> dict_stacked = {key: ut.filter_Nones(val) for key, val in dict_stacked_.items()}
>>> result = ut.repr2(dict_stacked, sorted_=True)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [4]}
"""
dict_stacked_ = defaultdict(list)
for dict_ in dict_list:
for key, val in six.iteritems(dict_):
dict_stacked_[key_prefix + key].append(val)
dict_stacked = dict(dict_stacked_)
return dict_stacked | python | def dict_stack(dict_list, key_prefix=''):
r"""
stacks values from two dicts into a new dict where the values are list of
the input values. the keys are the same.
DEPRICATE in favor of dict_stack2
Args:
dict_list (list): list of dicts with similar keys
Returns:
dict dict_stacked
CommandLine:
python -m utool.util_dict --test-dict_stack
python -m utool.util_dict --test-dict_stack:1
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_stacked = dict_stack([dict1_, dict2_])
>>> result = ut.repr2(dict_stacked, sorted_=True)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [4]}
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> # Get equivalent behavior with dict_stack2?
>>> # Almost, as long as None is not part of the list
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_stacked_ = dict_stack2([dict1_, dict2_])
>>> dict_stacked = {key: ut.filter_Nones(val) for key, val in dict_stacked_.items()}
>>> result = ut.repr2(dict_stacked, sorted_=True)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [4]}
"""
dict_stacked_ = defaultdict(list)
for dict_ in dict_list:
for key, val in six.iteritems(dict_):
dict_stacked_[key_prefix + key].append(val)
dict_stacked = dict(dict_stacked_)
return dict_stacked | [
"def",
"dict_stack",
"(",
"dict_list",
",",
"key_prefix",
"=",
"''",
")",
":",
"dict_stacked_",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"dict_",
"in",
"dict_list",
":",
"for",
"key",
",",
"val",
"in",
"six",
".",
"iteritems",
"(",
"dict_",
")",
":",
"dict_stacked_",
"[",
"key_prefix",
"+",
"key",
"]",
".",
"append",
"(",
"val",
")",
"dict_stacked",
"=",
"dict",
"(",
"dict_stacked_",
")",
"return",
"dict_stacked"
] | r"""
stacks values from two dicts into a new dict where the values are list of
the input values. the keys are the same.
DEPRICATE in favor of dict_stack2
Args:
dict_list (list): list of dicts with similar keys
Returns:
dict dict_stacked
CommandLine:
python -m utool.util_dict --test-dict_stack
python -m utool.util_dict --test-dict_stack:1
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_stacked = dict_stack([dict1_, dict2_])
>>> result = ut.repr2(dict_stacked, sorted_=True)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [4]}
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> # Get equivalent behavior with dict_stack2?
>>> # Almost, as long as None is not part of the list
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_stacked_ = dict_stack2([dict1_, dict2_])
>>> dict_stacked = {key: ut.filter_Nones(val) for key, val in dict_stacked_.items()}
>>> result = ut.repr2(dict_stacked, sorted_=True)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [4]} | [
"r",
"stacks",
"values",
"from",
"two",
"dicts",
"into",
"a",
"new",
"dict",
"where",
"the",
"values",
"are",
"list",
"of",
"the",
"input",
"values",
".",
"the",
"keys",
"are",
"the",
"same",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L332-L379 | train |
Erotemic/utool | utool/util_dict.py | dict_stack2 | def dict_stack2(dict_list, key_suffix=None, default=None):
"""
Stacks vals from a list of dicts into a dict of lists. Inserts Nones in
place of empty items to preserve order.
Args:
dict_list (list): list of dicts
key_suffix (str): (default = None)
Returns:
dict: stacked_dict
Example:
>>> # ENABLE_DOCTEST
>>> # Usual case: multiple dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [None, 4]}
Example1:
>>> # ENABLE_DOCTEST
>>> # Corner case: one dict as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict_list = [dict1_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1], 'b': [2]}
Example2:
>>> # ENABLE_DOCTEST
>>> # Corner case: zero dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = []
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{}
Example3:
>>> # ENABLE_DOCTEST
>>> # Corner case: empty dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = [{}]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{}
Example4:
>>> # ENABLE_DOCTEST
>>> # Corner case: one dict is empty
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
>>> dict2_ = {}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [[1, 2], None], 'b': [[2, 3], None]}
Example5:
>>> # ENABLE_DOCTEST
>>> # Corner case: disjoint dicts
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
>>> dict2_ = {'c': 4}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [[1, 2], None], 'b': [[2, 3], None], 'c': [None, 4]}
Example6:
>>> # ENABLE_DOCTEST
>>> # Corner case: 3 dicts
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = [{'a': 1}, {'b': 1}, {'c': 1}, {'b': 2}]
>>> default = None
>>> dict_stacked = dict_stack2(dict_list, default=default)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1, None, None, None], 'b': [None, 1, None, 2], 'c': [None, None, 1, None]}
"""
if len(dict_list) > 0:
dict_list_ = [map_dict_vals(lambda x: [x], kw) for kw in dict_list]
# Reduce does not handle default quite correctly
default1 = []
default2 = [default]
accum_ = dict_list_[0]
for dict_ in dict_list_[1:]:
default1.append(default)
accum_ = dict_union_combine(accum_, dict_, default=default1,
default2=default2)
stacked_dict = accum_
# stacked_dict = reduce(partial(dict_union_combine, default=[default]), dict_list_)
else:
stacked_dict = {}
# Augment keys if requested
if key_suffix is not None:
stacked_dict = map_dict_keys(lambda x: x + key_suffix, stacked_dict)
return stacked_dict | python | def dict_stack2(dict_list, key_suffix=None, default=None):
"""
Stacks vals from a list of dicts into a dict of lists. Inserts Nones in
place of empty items to preserve order.
Args:
dict_list (list): list of dicts
key_suffix (str): (default = None)
Returns:
dict: stacked_dict
Example:
>>> # ENABLE_DOCTEST
>>> # Usual case: multiple dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [None, 4]}
Example1:
>>> # ENABLE_DOCTEST
>>> # Corner case: one dict as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict_list = [dict1_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1], 'b': [2]}
Example2:
>>> # ENABLE_DOCTEST
>>> # Corner case: zero dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = []
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{}
Example3:
>>> # ENABLE_DOCTEST
>>> # Corner case: empty dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = [{}]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{}
Example4:
>>> # ENABLE_DOCTEST
>>> # Corner case: one dict is empty
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
>>> dict2_ = {}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [[1, 2], None], 'b': [[2, 3], None]}
Example5:
>>> # ENABLE_DOCTEST
>>> # Corner case: disjoint dicts
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
>>> dict2_ = {'c': 4}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [[1, 2], None], 'b': [[2, 3], None], 'c': [None, 4]}
Example6:
>>> # ENABLE_DOCTEST
>>> # Corner case: 3 dicts
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = [{'a': 1}, {'b': 1}, {'c': 1}, {'b': 2}]
>>> default = None
>>> dict_stacked = dict_stack2(dict_list, default=default)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1, None, None, None], 'b': [None, 1, None, 2], 'c': [None, None, 1, None]}
"""
if len(dict_list) > 0:
dict_list_ = [map_dict_vals(lambda x: [x], kw) for kw in dict_list]
# Reduce does not handle default quite correctly
default1 = []
default2 = [default]
accum_ = dict_list_[0]
for dict_ in dict_list_[1:]:
default1.append(default)
accum_ = dict_union_combine(accum_, dict_, default=default1,
default2=default2)
stacked_dict = accum_
# stacked_dict = reduce(partial(dict_union_combine, default=[default]), dict_list_)
else:
stacked_dict = {}
# Augment keys if requested
if key_suffix is not None:
stacked_dict = map_dict_keys(lambda x: x + key_suffix, stacked_dict)
return stacked_dict | [
"def",
"dict_stack2",
"(",
"dict_list",
",",
"key_suffix",
"=",
"None",
",",
"default",
"=",
"None",
")",
":",
"if",
"len",
"(",
"dict_list",
")",
">",
"0",
":",
"dict_list_",
"=",
"[",
"map_dict_vals",
"(",
"lambda",
"x",
":",
"[",
"x",
"]",
",",
"kw",
")",
"for",
"kw",
"in",
"dict_list",
"]",
"# Reduce does not handle default quite correctly",
"default1",
"=",
"[",
"]",
"default2",
"=",
"[",
"default",
"]",
"accum_",
"=",
"dict_list_",
"[",
"0",
"]",
"for",
"dict_",
"in",
"dict_list_",
"[",
"1",
":",
"]",
":",
"default1",
".",
"append",
"(",
"default",
")",
"accum_",
"=",
"dict_union_combine",
"(",
"accum_",
",",
"dict_",
",",
"default",
"=",
"default1",
",",
"default2",
"=",
"default2",
")",
"stacked_dict",
"=",
"accum_",
"# stacked_dict = reduce(partial(dict_union_combine, default=[default]), dict_list_)",
"else",
":",
"stacked_dict",
"=",
"{",
"}",
"# Augment keys if requested",
"if",
"key_suffix",
"is",
"not",
"None",
":",
"stacked_dict",
"=",
"map_dict_keys",
"(",
"lambda",
"x",
":",
"x",
"+",
"key_suffix",
",",
"stacked_dict",
")",
"return",
"stacked_dict"
] | Stacks vals from a list of dicts into a dict of lists. Inserts Nones in
place of empty items to preserve order.
Args:
dict_list (list): list of dicts
key_suffix (str): (default = None)
Returns:
dict: stacked_dict
Example:
>>> # ENABLE_DOCTEST
>>> # Usual case: multiple dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1, 2], 'b': [2, 3], 'c': [None, 4]}
Example1:
>>> # ENABLE_DOCTEST
>>> # Corner case: one dict as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': 1, 'b': 2}
>>> dict_list = [dict1_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1], 'b': [2]}
Example2:
>>> # ENABLE_DOCTEST
>>> # Corner case: zero dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = []
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{}
Example3:
>>> # ENABLE_DOCTEST
>>> # Corner case: empty dicts as input
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = [{}]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{}
Example4:
>>> # ENABLE_DOCTEST
>>> # Corner case: one dict is empty
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
>>> dict2_ = {}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [[1, 2], None], 'b': [[2, 3], None]}
Example5:
>>> # ENABLE_DOCTEST
>>> # Corner case: disjoint dicts
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
>>> dict2_ = {'c': 4}
>>> dict_list = [dict1_, dict2_]
>>> dict_stacked = dict_stack2(dict_list)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [[1, 2], None], 'b': [[2, 3], None], 'c': [None, 4]}
Example6:
>>> # ENABLE_DOCTEST
>>> # Corner case: 3 dicts
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_list = [{'a': 1}, {'b': 1}, {'c': 1}, {'b': 2}]
>>> default = None
>>> dict_stacked = dict_stack2(dict_list, default=default)
>>> result = ut.repr2(dict_stacked)
>>> print(result)
{'a': [1, None, None, None], 'b': [None, 1, None, 2], 'c': [None, None, 1, None]} | [
"Stacks",
"vals",
"from",
"a",
"list",
"of",
"dicts",
"into",
"a",
"dict",
"of",
"lists",
".",
"Inserts",
"Nones",
"in",
"place",
"of",
"empty",
"items",
"to",
"preserve",
"order",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L382-L496 | train |
Erotemic/utool | utool/util_dict.py | invert_dict | def invert_dict(dict_, unique_vals=True):
"""
Reverses the keys and values in a dictionary. Set unique_vals to False if
the values in the dict are not unique.
Args:
dict_ (dict_): dictionary
unique_vals (bool): if False, inverted keys are returned in a list.
Returns:
dict: inverted_dict
CommandLine:
python -m utool.util_dict --test-invert_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 1, 'b': 2}
>>> inverted_dict = invert_dict(dict_)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{1: 'a', 2: 'b'}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = OrderedDict([(2, 'good',), (1, 'ok',), (0, 'junk',), (None, 'UNKNOWN',)])
>>> inverted_dict = invert_dict(dict_)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{'good': 2, 'ok': 1, 'junk': 0, 'UNKNOWN': None}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 1, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 2}
>>> inverted_dict = invert_dict(dict_, unique_vals=False)
>>> inverted_dict = ut.map_dict_vals(sorted, inverted_dict)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{0: ['b', 'c', 'd', 'e'], 1: ['a'], 2: ['f']}
"""
if unique_vals:
inverted_items = [(val, key) for key, val in six.iteritems(dict_)]
inverted_dict = type(dict_)(inverted_items)
else:
inverted_dict = group_items(dict_.keys(), dict_.values())
return inverted_dict | python | def invert_dict(dict_, unique_vals=True):
"""
Reverses the keys and values in a dictionary. Set unique_vals to False if
the values in the dict are not unique.
Args:
dict_ (dict_): dictionary
unique_vals (bool): if False, inverted keys are returned in a list.
Returns:
dict: inverted_dict
CommandLine:
python -m utool.util_dict --test-invert_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 1, 'b': 2}
>>> inverted_dict = invert_dict(dict_)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{1: 'a', 2: 'b'}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = OrderedDict([(2, 'good',), (1, 'ok',), (0, 'junk',), (None, 'UNKNOWN',)])
>>> inverted_dict = invert_dict(dict_)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{'good': 2, 'ok': 1, 'junk': 0, 'UNKNOWN': None}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 1, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 2}
>>> inverted_dict = invert_dict(dict_, unique_vals=False)
>>> inverted_dict = ut.map_dict_vals(sorted, inverted_dict)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{0: ['b', 'c', 'd', 'e'], 1: ['a'], 2: ['f']}
"""
if unique_vals:
inverted_items = [(val, key) for key, val in six.iteritems(dict_)]
inverted_dict = type(dict_)(inverted_items)
else:
inverted_dict = group_items(dict_.keys(), dict_.values())
return inverted_dict | [
"def",
"invert_dict",
"(",
"dict_",
",",
"unique_vals",
"=",
"True",
")",
":",
"if",
"unique_vals",
":",
"inverted_items",
"=",
"[",
"(",
"val",
",",
"key",
")",
"for",
"key",
",",
"val",
"in",
"six",
".",
"iteritems",
"(",
"dict_",
")",
"]",
"inverted_dict",
"=",
"type",
"(",
"dict_",
")",
"(",
"inverted_items",
")",
"else",
":",
"inverted_dict",
"=",
"group_items",
"(",
"dict_",
".",
"keys",
"(",
")",
",",
"dict_",
".",
"values",
"(",
")",
")",
"return",
"inverted_dict"
] | Reverses the keys and values in a dictionary. Set unique_vals to False if
the values in the dict are not unique.
Args:
dict_ (dict_): dictionary
unique_vals (bool): if False, inverted keys are returned in a list.
Returns:
dict: inverted_dict
CommandLine:
python -m utool.util_dict --test-invert_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 1, 'b': 2}
>>> inverted_dict = invert_dict(dict_)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{1: 'a', 2: 'b'}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = OrderedDict([(2, 'good',), (1, 'ok',), (0, 'junk',), (None, 'UNKNOWN',)])
>>> inverted_dict = invert_dict(dict_)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{'good': 2, 'ok': 1, 'junk': 0, 'UNKNOWN': None}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 1, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 2}
>>> inverted_dict = invert_dict(dict_, unique_vals=False)
>>> inverted_dict = ut.map_dict_vals(sorted, inverted_dict)
>>> result = ut.repr4(inverted_dict, nl=False)
>>> print(result)
{0: ['b', 'c', 'd', 'e'], 1: ['a'], 2: ['f']} | [
"Reverses",
"the",
"keys",
"and",
"values",
"in",
"a",
"dictionary",
".",
"Set",
"unique_vals",
"to",
"False",
"if",
"the",
"values",
"in",
"the",
"dict",
"are",
"not",
"unique",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L499-L550 | train |
Erotemic/utool | utool/util_dict.py | iter_all_dict_combinations_ordered | def iter_all_dict_combinations_ordered(varied_dict):
"""
Same as all_dict_combinations but preserves order
"""
tups_list = [[(key, val) for val in val_list]
for (key, val_list) in six.iteritems(varied_dict)]
dict_iter = (OrderedDict(tups) for tups in it.product(*tups_list))
return dict_iter | python | def iter_all_dict_combinations_ordered(varied_dict):
"""
Same as all_dict_combinations but preserves order
"""
tups_list = [[(key, val) for val in val_list]
for (key, val_list) in six.iteritems(varied_dict)]
dict_iter = (OrderedDict(tups) for tups in it.product(*tups_list))
return dict_iter | [
"def",
"iter_all_dict_combinations_ordered",
"(",
"varied_dict",
")",
":",
"tups_list",
"=",
"[",
"[",
"(",
"key",
",",
"val",
")",
"for",
"val",
"in",
"val_list",
"]",
"for",
"(",
"key",
",",
"val_list",
")",
"in",
"six",
".",
"iteritems",
"(",
"varied_dict",
")",
"]",
"dict_iter",
"=",
"(",
"OrderedDict",
"(",
"tups",
")",
"for",
"tups",
"in",
"it",
".",
"product",
"(",
"*",
"tups_list",
")",
")",
"return",
"dict_iter"
] | Same as all_dict_combinations but preserves order | [
"Same",
"as",
"all_dict_combinations",
"but",
"preserves",
"order"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L553-L560 | train |
Erotemic/utool | utool/util_dict.py | all_dict_combinations_lbls | def all_dict_combinations_lbls(varied_dict, remove_singles=True, allow_lone_singles=False):
"""
returns a label for each variation in a varydict.
It tries to not be oververbose and returns only what parameters are varied
in each label.
CommandLine:
python -m utool.util_dict --test-all_dict_combinations_lbls
python -m utool.util_dict --exec-all_dict_combinations_lbls:1
Example:
>>> # ENABLE_DOCTEST
>>> import utool
>>> from utool.util_dict import * # NOQA
>>> varied_dict = {'logdist_weight': [0.0, 1.0], 'pipeline_root': ['vsmany'], 'sv_on': [True, False, None]}
>>> comb_lbls = utool.all_dict_combinations_lbls(varied_dict)
>>> result = (utool.repr4(comb_lbls))
>>> print(result)
[
'logdist_weight=0.0,sv_on=True',
'logdist_weight=0.0,sv_on=False',
'logdist_weight=0.0,sv_on=None',
'logdist_weight=1.0,sv_on=True',
'logdist_weight=1.0,sv_on=False',
'logdist_weight=1.0,sv_on=None',
]
Example:
>>> # ENABLE_DOCTEST
>>> import utool as ut
>>> from utool.util_dict import * # NOQA
>>> varied_dict = {'logdist_weight': [0.0], 'pipeline_root': ['vsmany'], 'sv_on': [True]}
>>> allow_lone_singles = True
>>> comb_lbls = ut.all_dict_combinations_lbls(varied_dict, allow_lone_singles=allow_lone_singles)
>>> result = (ut.repr4(comb_lbls))
>>> print(result)
[
'logdist_weight=0.0,pipeline_root=vsmany,sv_on=True',
]
"""
is_lone_single = all([
isinstance(val_list, (list, tuple)) and len(val_list) == 1
for key, val_list in iteritems_sorted(varied_dict)
])
if not remove_singles or (allow_lone_singles and is_lone_single):
# all entries have one length
multitups_list = [
[(key, val) for val in val_list]
for key, val_list in iteritems_sorted(varied_dict)
]
else:
multitups_list = [
[(key, val) for val in val_list]
for key, val_list in iteritems_sorted(varied_dict)
if isinstance(val_list, (list, tuple)) and len(val_list) > 1]
combtup_list = list(it.product(*multitups_list))
combtup_list2 = [
[(key, val) if isinstance(val, six.string_types) else (key, repr(val))
for (key, val) in combtup]
for combtup in combtup_list]
comb_lbls = [','.join(['%s=%s' % (key, val) for (key, val) in combtup])
for combtup in combtup_list2]
#comb_lbls = list(map(str, comb_pairs))
return comb_lbls | python | def all_dict_combinations_lbls(varied_dict, remove_singles=True, allow_lone_singles=False):
"""
returns a label for each variation in a varydict.
It tries to not be oververbose and returns only what parameters are varied
in each label.
CommandLine:
python -m utool.util_dict --test-all_dict_combinations_lbls
python -m utool.util_dict --exec-all_dict_combinations_lbls:1
Example:
>>> # ENABLE_DOCTEST
>>> import utool
>>> from utool.util_dict import * # NOQA
>>> varied_dict = {'logdist_weight': [0.0, 1.0], 'pipeline_root': ['vsmany'], 'sv_on': [True, False, None]}
>>> comb_lbls = utool.all_dict_combinations_lbls(varied_dict)
>>> result = (utool.repr4(comb_lbls))
>>> print(result)
[
'logdist_weight=0.0,sv_on=True',
'logdist_weight=0.0,sv_on=False',
'logdist_weight=0.0,sv_on=None',
'logdist_weight=1.0,sv_on=True',
'logdist_weight=1.0,sv_on=False',
'logdist_weight=1.0,sv_on=None',
]
Example:
>>> # ENABLE_DOCTEST
>>> import utool as ut
>>> from utool.util_dict import * # NOQA
>>> varied_dict = {'logdist_weight': [0.0], 'pipeline_root': ['vsmany'], 'sv_on': [True]}
>>> allow_lone_singles = True
>>> comb_lbls = ut.all_dict_combinations_lbls(varied_dict, allow_lone_singles=allow_lone_singles)
>>> result = (ut.repr4(comb_lbls))
>>> print(result)
[
'logdist_weight=0.0,pipeline_root=vsmany,sv_on=True',
]
"""
is_lone_single = all([
isinstance(val_list, (list, tuple)) and len(val_list) == 1
for key, val_list in iteritems_sorted(varied_dict)
])
if not remove_singles or (allow_lone_singles and is_lone_single):
# all entries have one length
multitups_list = [
[(key, val) for val in val_list]
for key, val_list in iteritems_sorted(varied_dict)
]
else:
multitups_list = [
[(key, val) for val in val_list]
for key, val_list in iteritems_sorted(varied_dict)
if isinstance(val_list, (list, tuple)) and len(val_list) > 1]
combtup_list = list(it.product(*multitups_list))
combtup_list2 = [
[(key, val) if isinstance(val, six.string_types) else (key, repr(val))
for (key, val) in combtup]
for combtup in combtup_list]
comb_lbls = [','.join(['%s=%s' % (key, val) for (key, val) in combtup])
for combtup in combtup_list2]
#comb_lbls = list(map(str, comb_pairs))
return comb_lbls | [
"def",
"all_dict_combinations_lbls",
"(",
"varied_dict",
",",
"remove_singles",
"=",
"True",
",",
"allow_lone_singles",
"=",
"False",
")",
":",
"is_lone_single",
"=",
"all",
"(",
"[",
"isinstance",
"(",
"val_list",
",",
"(",
"list",
",",
"tuple",
")",
")",
"and",
"len",
"(",
"val_list",
")",
"==",
"1",
"for",
"key",
",",
"val_list",
"in",
"iteritems_sorted",
"(",
"varied_dict",
")",
"]",
")",
"if",
"not",
"remove_singles",
"or",
"(",
"allow_lone_singles",
"and",
"is_lone_single",
")",
":",
"# all entries have one length",
"multitups_list",
"=",
"[",
"[",
"(",
"key",
",",
"val",
")",
"for",
"val",
"in",
"val_list",
"]",
"for",
"key",
",",
"val_list",
"in",
"iteritems_sorted",
"(",
"varied_dict",
")",
"]",
"else",
":",
"multitups_list",
"=",
"[",
"[",
"(",
"key",
",",
"val",
")",
"for",
"val",
"in",
"val_list",
"]",
"for",
"key",
",",
"val_list",
"in",
"iteritems_sorted",
"(",
"varied_dict",
")",
"if",
"isinstance",
"(",
"val_list",
",",
"(",
"list",
",",
"tuple",
")",
")",
"and",
"len",
"(",
"val_list",
")",
">",
"1",
"]",
"combtup_list",
"=",
"list",
"(",
"it",
".",
"product",
"(",
"*",
"multitups_list",
")",
")",
"combtup_list2",
"=",
"[",
"[",
"(",
"key",
",",
"val",
")",
"if",
"isinstance",
"(",
"val",
",",
"six",
".",
"string_types",
")",
"else",
"(",
"key",
",",
"repr",
"(",
"val",
")",
")",
"for",
"(",
"key",
",",
"val",
")",
"in",
"combtup",
"]",
"for",
"combtup",
"in",
"combtup_list",
"]",
"comb_lbls",
"=",
"[",
"','",
".",
"join",
"(",
"[",
"'%s=%s'",
"%",
"(",
"key",
",",
"val",
")",
"for",
"(",
"key",
",",
"val",
")",
"in",
"combtup",
"]",
")",
"for",
"combtup",
"in",
"combtup_list2",
"]",
"#comb_lbls = list(map(str, comb_pairs))",
"return",
"comb_lbls"
] | returns a label for each variation in a varydict.
It tries to not be oververbose and returns only what parameters are varied
in each label.
CommandLine:
python -m utool.util_dict --test-all_dict_combinations_lbls
python -m utool.util_dict --exec-all_dict_combinations_lbls:1
Example:
>>> # ENABLE_DOCTEST
>>> import utool
>>> from utool.util_dict import * # NOQA
>>> varied_dict = {'logdist_weight': [0.0, 1.0], 'pipeline_root': ['vsmany'], 'sv_on': [True, False, None]}
>>> comb_lbls = utool.all_dict_combinations_lbls(varied_dict)
>>> result = (utool.repr4(comb_lbls))
>>> print(result)
[
'logdist_weight=0.0,sv_on=True',
'logdist_weight=0.0,sv_on=False',
'logdist_weight=0.0,sv_on=None',
'logdist_weight=1.0,sv_on=True',
'logdist_weight=1.0,sv_on=False',
'logdist_weight=1.0,sv_on=None',
]
Example:
>>> # ENABLE_DOCTEST
>>> import utool as ut
>>> from utool.util_dict import * # NOQA
>>> varied_dict = {'logdist_weight': [0.0], 'pipeline_root': ['vsmany'], 'sv_on': [True]}
>>> allow_lone_singles = True
>>> comb_lbls = ut.all_dict_combinations_lbls(varied_dict, allow_lone_singles=allow_lone_singles)
>>> result = (ut.repr4(comb_lbls))
>>> print(result)
[
'logdist_weight=0.0,pipeline_root=vsmany,sv_on=True',
] | [
"returns",
"a",
"label",
"for",
"each",
"variation",
"in",
"a",
"varydict",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L617-L681 | train |
Erotemic/utool | utool/util_dict.py | build_conflict_dict | def build_conflict_dict(key_list, val_list):
"""
Builds dict where a list of values is associated with more than one key
Args:
key_list (list):
val_list (list):
Returns:
dict: key_to_vals
CommandLine:
python -m utool.util_dict --test-build_conflict_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> key_list = [ 1, 2, 2, 3, 1]
>>> val_list = ['a', 'b', 'c', 'd', 'e']
>>> key_to_vals = build_conflict_dict(key_list, val_list)
>>> result = ut.repr4(key_to_vals)
>>> print(result)
{
1: ['a', 'e'],
2: ['b', 'c'],
3: ['d'],
}
"""
key_to_vals = defaultdict(list)
for key, val in zip(key_list, val_list):
key_to_vals[key].append(val)
return key_to_vals | python | def build_conflict_dict(key_list, val_list):
"""
Builds dict where a list of values is associated with more than one key
Args:
key_list (list):
val_list (list):
Returns:
dict: key_to_vals
CommandLine:
python -m utool.util_dict --test-build_conflict_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> key_list = [ 1, 2, 2, 3, 1]
>>> val_list = ['a', 'b', 'c', 'd', 'e']
>>> key_to_vals = build_conflict_dict(key_list, val_list)
>>> result = ut.repr4(key_to_vals)
>>> print(result)
{
1: ['a', 'e'],
2: ['b', 'c'],
3: ['d'],
}
"""
key_to_vals = defaultdict(list)
for key, val in zip(key_list, val_list):
key_to_vals[key].append(val)
return key_to_vals | [
"def",
"build_conflict_dict",
"(",
"key_list",
",",
"val_list",
")",
":",
"key_to_vals",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"key",
",",
"val",
"in",
"zip",
"(",
"key_list",
",",
"val_list",
")",
":",
"key_to_vals",
"[",
"key",
"]",
".",
"append",
"(",
"val",
")",
"return",
"key_to_vals"
] | Builds dict where a list of values is associated with more than one key
Args:
key_list (list):
val_list (list):
Returns:
dict: key_to_vals
CommandLine:
python -m utool.util_dict --test-build_conflict_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> key_list = [ 1, 2, 2, 3, 1]
>>> val_list = ['a', 'b', 'c', 'd', 'e']
>>> key_to_vals = build_conflict_dict(key_list, val_list)
>>> result = ut.repr4(key_to_vals)
>>> print(result)
{
1: ['a', 'e'],
2: ['b', 'c'],
3: ['d'],
} | [
"Builds",
"dict",
"where",
"a",
"list",
"of",
"values",
"is",
"associated",
"with",
"more",
"than",
"one",
"key"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L692-L724 | train |
Erotemic/utool | utool/util_dict.py | update_existing | def update_existing(dict1, dict2, copy=False, assert_exists=False,
iswarning=False, alias_dict=None):
r"""
updates vals in dict1 using vals from dict2 only if the
key is already in dict1.
Args:
dict1 (dict):
dict2 (dict):
copy (bool): if true modifies dictionary in place (default = False)
assert_exists (bool): if True throws error if new key specified (default = False)
alias_dict (dict): dictionary of alias keys for dict2 (default = None)
Returns:
dict - updated dictionary
CommandLine:
python -m utool.util_dict --test-update_existing
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> dict1 = {'a': 1, 'b': 2, 'c': 3}
>>> dict2 = {'a': 2, 'd': 3}
>>> dict1_ = update_existing(dict1, dict2)
>>> assert 'd' not in dict1
>>> assert dict1['a'] == 2
>>> assert dict1_ is dict1
"""
if assert_exists:
try:
assert_keys_are_subset(dict1, dict2)
except AssertionError as ex:
from utool import util_dbg
util_dbg.printex(ex, iswarning=iswarning, N=1)
if not iswarning:
raise
if copy:
dict1 = dict(dict1)
if alias_dict is None:
alias_dict = {}
for key, val in six.iteritems(dict2):
key = alias_dict.get(key, key)
if key in dict1:
dict1[key] = val
return dict1 | python | def update_existing(dict1, dict2, copy=False, assert_exists=False,
iswarning=False, alias_dict=None):
r"""
updates vals in dict1 using vals from dict2 only if the
key is already in dict1.
Args:
dict1 (dict):
dict2 (dict):
copy (bool): if true modifies dictionary in place (default = False)
assert_exists (bool): if True throws error if new key specified (default = False)
alias_dict (dict): dictionary of alias keys for dict2 (default = None)
Returns:
dict - updated dictionary
CommandLine:
python -m utool.util_dict --test-update_existing
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> dict1 = {'a': 1, 'b': 2, 'c': 3}
>>> dict2 = {'a': 2, 'd': 3}
>>> dict1_ = update_existing(dict1, dict2)
>>> assert 'd' not in dict1
>>> assert dict1['a'] == 2
>>> assert dict1_ is dict1
"""
if assert_exists:
try:
assert_keys_are_subset(dict1, dict2)
except AssertionError as ex:
from utool import util_dbg
util_dbg.printex(ex, iswarning=iswarning, N=1)
if not iswarning:
raise
if copy:
dict1 = dict(dict1)
if alias_dict is None:
alias_dict = {}
for key, val in six.iteritems(dict2):
key = alias_dict.get(key, key)
if key in dict1:
dict1[key] = val
return dict1 | [
"def",
"update_existing",
"(",
"dict1",
",",
"dict2",
",",
"copy",
"=",
"False",
",",
"assert_exists",
"=",
"False",
",",
"iswarning",
"=",
"False",
",",
"alias_dict",
"=",
"None",
")",
":",
"if",
"assert_exists",
":",
"try",
":",
"assert_keys_are_subset",
"(",
"dict1",
",",
"dict2",
")",
"except",
"AssertionError",
"as",
"ex",
":",
"from",
"utool",
"import",
"util_dbg",
"util_dbg",
".",
"printex",
"(",
"ex",
",",
"iswarning",
"=",
"iswarning",
",",
"N",
"=",
"1",
")",
"if",
"not",
"iswarning",
":",
"raise",
"if",
"copy",
":",
"dict1",
"=",
"dict",
"(",
"dict1",
")",
"if",
"alias_dict",
"is",
"None",
":",
"alias_dict",
"=",
"{",
"}",
"for",
"key",
",",
"val",
"in",
"six",
".",
"iteritems",
"(",
"dict2",
")",
":",
"key",
"=",
"alias_dict",
".",
"get",
"(",
"key",
",",
"key",
")",
"if",
"key",
"in",
"dict1",
":",
"dict1",
"[",
"key",
"]",
"=",
"val",
"return",
"dict1"
] | r"""
updates vals in dict1 using vals from dict2 only if the
key is already in dict1.
Args:
dict1 (dict):
dict2 (dict):
copy (bool): if true modifies dictionary in place (default = False)
assert_exists (bool): if True throws error if new key specified (default = False)
alias_dict (dict): dictionary of alias keys for dict2 (default = None)
Returns:
dict - updated dictionary
CommandLine:
python -m utool.util_dict --test-update_existing
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> dict1 = {'a': 1, 'b': 2, 'c': 3}
>>> dict2 = {'a': 2, 'd': 3}
>>> dict1_ = update_existing(dict1, dict2)
>>> assert 'd' not in dict1
>>> assert dict1['a'] == 2
>>> assert dict1_ is dict1 | [
"r",
"updates",
"vals",
"in",
"dict1",
"using",
"vals",
"from",
"dict2",
"only",
"if",
"the",
"key",
"is",
"already",
"in",
"dict1",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L751-L796 | train |
Erotemic/utool | utool/util_dict.py | dict_update_newkeys | def dict_update_newkeys(dict_, dict2):
""" Like dict.update, but does not overwrite items """
for key, val in six.iteritems(dict2):
if key not in dict_:
dict_[key] = val | python | def dict_update_newkeys(dict_, dict2):
""" Like dict.update, but does not overwrite items """
for key, val in six.iteritems(dict2):
if key not in dict_:
dict_[key] = val | [
"def",
"dict_update_newkeys",
"(",
"dict_",
",",
"dict2",
")",
":",
"for",
"key",
",",
"val",
"in",
"six",
".",
"iteritems",
"(",
"dict2",
")",
":",
"if",
"key",
"not",
"in",
"dict_",
":",
"dict_",
"[",
"key",
"]",
"=",
"val"
] | Like dict.update, but does not overwrite items | [
"Like",
"dict",
".",
"update",
"but",
"does",
"not",
"overwrite",
"items"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L810-L814 | train |
Erotemic/utool | utool/util_dict.py | is_dicteq | def is_dicteq(dict1_, dict2_, almosteq_ok=True, verbose_err=True):
""" Checks to see if dicts are the same. Performs recursion. Handles numpy """
import utool as ut
assert len(dict1_) == len(dict2_), 'dicts are not of same length'
try:
for (key1, val1), (key2, val2) in zip(dict1_.items(), dict2_.items()):
assert key1 == key2, 'key mismatch'
assert type(val1) == type(val2), 'vals are not same type'
if HAVE_NUMPY and np.iterable(val1):
if almosteq_ok and ut.is_float(val1):
assert np.all(ut.almost_eq(val1, val2)), 'float vals are not within thresh'
else:
assert all([np.all(x1 == x2) for (x1, x2) in zip(val1, val2)]), 'np vals are different'
elif isinstance(val1, dict):
is_dicteq(val1, val2, almosteq_ok=almosteq_ok, verbose_err=verbose_err)
else:
assert val1 == val2, 'vals are different'
except AssertionError as ex:
if verbose_err:
ut.printex(ex)
return False
return True | python | def is_dicteq(dict1_, dict2_, almosteq_ok=True, verbose_err=True):
""" Checks to see if dicts are the same. Performs recursion. Handles numpy """
import utool as ut
assert len(dict1_) == len(dict2_), 'dicts are not of same length'
try:
for (key1, val1), (key2, val2) in zip(dict1_.items(), dict2_.items()):
assert key1 == key2, 'key mismatch'
assert type(val1) == type(val2), 'vals are not same type'
if HAVE_NUMPY and np.iterable(val1):
if almosteq_ok and ut.is_float(val1):
assert np.all(ut.almost_eq(val1, val2)), 'float vals are not within thresh'
else:
assert all([np.all(x1 == x2) for (x1, x2) in zip(val1, val2)]), 'np vals are different'
elif isinstance(val1, dict):
is_dicteq(val1, val2, almosteq_ok=almosteq_ok, verbose_err=verbose_err)
else:
assert val1 == val2, 'vals are different'
except AssertionError as ex:
if verbose_err:
ut.printex(ex)
return False
return True | [
"def",
"is_dicteq",
"(",
"dict1_",
",",
"dict2_",
",",
"almosteq_ok",
"=",
"True",
",",
"verbose_err",
"=",
"True",
")",
":",
"import",
"utool",
"as",
"ut",
"assert",
"len",
"(",
"dict1_",
")",
"==",
"len",
"(",
"dict2_",
")",
",",
"'dicts are not of same length'",
"try",
":",
"for",
"(",
"key1",
",",
"val1",
")",
",",
"(",
"key2",
",",
"val2",
")",
"in",
"zip",
"(",
"dict1_",
".",
"items",
"(",
")",
",",
"dict2_",
".",
"items",
"(",
")",
")",
":",
"assert",
"key1",
"==",
"key2",
",",
"'key mismatch'",
"assert",
"type",
"(",
"val1",
")",
"==",
"type",
"(",
"val2",
")",
",",
"'vals are not same type'",
"if",
"HAVE_NUMPY",
"and",
"np",
".",
"iterable",
"(",
"val1",
")",
":",
"if",
"almosteq_ok",
"and",
"ut",
".",
"is_float",
"(",
"val1",
")",
":",
"assert",
"np",
".",
"all",
"(",
"ut",
".",
"almost_eq",
"(",
"val1",
",",
"val2",
")",
")",
",",
"'float vals are not within thresh'",
"else",
":",
"assert",
"all",
"(",
"[",
"np",
".",
"all",
"(",
"x1",
"==",
"x2",
")",
"for",
"(",
"x1",
",",
"x2",
")",
"in",
"zip",
"(",
"val1",
",",
"val2",
")",
"]",
")",
",",
"'np vals are different'",
"elif",
"isinstance",
"(",
"val1",
",",
"dict",
")",
":",
"is_dicteq",
"(",
"val1",
",",
"val2",
",",
"almosteq_ok",
"=",
"almosteq_ok",
",",
"verbose_err",
"=",
"verbose_err",
")",
"else",
":",
"assert",
"val1",
"==",
"val2",
",",
"'vals are different'",
"except",
"AssertionError",
"as",
"ex",
":",
"if",
"verbose_err",
":",
"ut",
".",
"printex",
"(",
"ex",
")",
"return",
"False",
"return",
"True"
] | Checks to see if dicts are the same. Performs recursion. Handles numpy | [
"Checks",
"to",
"see",
"if",
"dicts",
"are",
"the",
"same",
".",
"Performs",
"recursion",
".",
"Handles",
"numpy"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L817-L838 | train |
Erotemic/utool | utool/util_dict.py | dict_setdiff | def dict_setdiff(dict_, negative_keys):
r"""
returns a copy of dict_ without keys in the negative_keys list
Args:
dict_ (dict):
negative_keys (list):
"""
keys = [key for key in six.iterkeys(dict_)
if key not in set(negative_keys)]
subdict_ = dict_subset(dict_, keys)
return subdict_ | python | def dict_setdiff(dict_, negative_keys):
r"""
returns a copy of dict_ without keys in the negative_keys list
Args:
dict_ (dict):
negative_keys (list):
"""
keys = [key for key in six.iterkeys(dict_)
if key not in set(negative_keys)]
subdict_ = dict_subset(dict_, keys)
return subdict_ | [
"def",
"dict_setdiff",
"(",
"dict_",
",",
"negative_keys",
")",
":",
"keys",
"=",
"[",
"key",
"for",
"key",
"in",
"six",
".",
"iterkeys",
"(",
"dict_",
")",
"if",
"key",
"not",
"in",
"set",
"(",
"negative_keys",
")",
"]",
"subdict_",
"=",
"dict_subset",
"(",
"dict_",
",",
"keys",
")",
"return",
"subdict_"
] | r"""
returns a copy of dict_ without keys in the negative_keys list
Args:
dict_ (dict):
negative_keys (list): | [
"r",
"returns",
"a",
"copy",
"of",
"dict_",
"without",
"keys",
"in",
"the",
"negative_keys",
"list"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L877-L888 | train |
Erotemic/utool | utool/util_dict.py | delete_dict_keys | def delete_dict_keys(dict_, key_list):
r"""
Removes items from a dictionary inplace. Keys that do not exist are
ignored.
Args:
dict_ (dict): dict like object with a __del__ attribute
key_list (list): list of keys that specify the items to remove
CommandLine:
python -m utool.util_dict --test-delete_dict_keys
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'bread': 1, 'churches': 1, 'cider': 2, 'very small rocks': 2}
>>> key_list = ['duck', 'bread', 'cider']
>>> delete_dict_keys(dict_, key_list)
>>> result = ut.repr4(dict_, nl=False)
>>> print(result)
{'churches': 1, 'very small rocks': 2}
"""
invalid_keys = set(key_list) - set(dict_.keys())
valid_keys = set(key_list) - invalid_keys
for key in valid_keys:
del dict_[key]
return dict_ | python | def delete_dict_keys(dict_, key_list):
r"""
Removes items from a dictionary inplace. Keys that do not exist are
ignored.
Args:
dict_ (dict): dict like object with a __del__ attribute
key_list (list): list of keys that specify the items to remove
CommandLine:
python -m utool.util_dict --test-delete_dict_keys
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'bread': 1, 'churches': 1, 'cider': 2, 'very small rocks': 2}
>>> key_list = ['duck', 'bread', 'cider']
>>> delete_dict_keys(dict_, key_list)
>>> result = ut.repr4(dict_, nl=False)
>>> print(result)
{'churches': 1, 'very small rocks': 2}
"""
invalid_keys = set(key_list) - set(dict_.keys())
valid_keys = set(key_list) - invalid_keys
for key in valid_keys:
del dict_[key]
return dict_ | [
"def",
"delete_dict_keys",
"(",
"dict_",
",",
"key_list",
")",
":",
"invalid_keys",
"=",
"set",
"(",
"key_list",
")",
"-",
"set",
"(",
"dict_",
".",
"keys",
"(",
")",
")",
"valid_keys",
"=",
"set",
"(",
"key_list",
")",
"-",
"invalid_keys",
"for",
"key",
"in",
"valid_keys",
":",
"del",
"dict_",
"[",
"key",
"]",
"return",
"dict_"
] | r"""
Removes items from a dictionary inplace. Keys that do not exist are
ignored.
Args:
dict_ (dict): dict like object with a __del__ attribute
key_list (list): list of keys that specify the items to remove
CommandLine:
python -m utool.util_dict --test-delete_dict_keys
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'bread': 1, 'churches': 1, 'cider': 2, 'very small rocks': 2}
>>> key_list = ['duck', 'bread', 'cider']
>>> delete_dict_keys(dict_, key_list)
>>> result = ut.repr4(dict_, nl=False)
>>> print(result)
{'churches': 1, 'very small rocks': 2} | [
"r",
"Removes",
"items",
"from",
"a",
"dictionary",
"inplace",
".",
"Keys",
"that",
"do",
"not",
"exist",
"are",
"ignored",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L891-L919 | train |
Erotemic/utool | utool/util_dict.py | dict_take_gen | def dict_take_gen(dict_, keys, *d):
r"""
generate multiple values from a dictionary
Args:
dict_ (dict):
keys (list):
Varargs:
d: if specified is default for key errors
CommandLine:
python -m utool.util_dict --test-dict_take_gen
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> result = list(dict_take_gen(dict_, keys, None))
>>> result = ut.repr4(result, nl=False)
>>> print(result)
['a', 'b', 'c', None, None]
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> try:
>>> print(list(dict_take_gen(dict_, keys)))
>>> result = 'did not get key error'
>>> except KeyError:
>>> result = 'correctly got key error'
>>> print(result)
correctly got key error
"""
if isinstance(keys, six.string_types):
# hack for string keys that makes copy-past easier
keys = keys.split(', ')
if len(d) == 0:
# no default given throws key error
dictget = dict_.__getitem__
elif len(d) == 1:
# default given does not throw key erro
dictget = dict_.get
else:
raise ValueError('len(d) must be 1 or 0')
for key in keys:
if HAVE_NUMPY and isinstance(key, np.ndarray):
# recursive call
yield list(dict_take_gen(dict_, key, *d))
else:
yield dictget(key, *d) | python | def dict_take_gen(dict_, keys, *d):
r"""
generate multiple values from a dictionary
Args:
dict_ (dict):
keys (list):
Varargs:
d: if specified is default for key errors
CommandLine:
python -m utool.util_dict --test-dict_take_gen
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> result = list(dict_take_gen(dict_, keys, None))
>>> result = ut.repr4(result, nl=False)
>>> print(result)
['a', 'b', 'c', None, None]
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> try:
>>> print(list(dict_take_gen(dict_, keys)))
>>> result = 'did not get key error'
>>> except KeyError:
>>> result = 'correctly got key error'
>>> print(result)
correctly got key error
"""
if isinstance(keys, six.string_types):
# hack for string keys that makes copy-past easier
keys = keys.split(', ')
if len(d) == 0:
# no default given throws key error
dictget = dict_.__getitem__
elif len(d) == 1:
# default given does not throw key erro
dictget = dict_.get
else:
raise ValueError('len(d) must be 1 or 0')
for key in keys:
if HAVE_NUMPY and isinstance(key, np.ndarray):
# recursive call
yield list(dict_take_gen(dict_, key, *d))
else:
yield dictget(key, *d) | [
"def",
"dict_take_gen",
"(",
"dict_",
",",
"keys",
",",
"*",
"d",
")",
":",
"if",
"isinstance",
"(",
"keys",
",",
"six",
".",
"string_types",
")",
":",
"# hack for string keys that makes copy-past easier",
"keys",
"=",
"keys",
".",
"split",
"(",
"', '",
")",
"if",
"len",
"(",
"d",
")",
"==",
"0",
":",
"# no default given throws key error",
"dictget",
"=",
"dict_",
".",
"__getitem__",
"elif",
"len",
"(",
"d",
")",
"==",
"1",
":",
"# default given does not throw key erro",
"dictget",
"=",
"dict_",
".",
"get",
"else",
":",
"raise",
"ValueError",
"(",
"'len(d) must be 1 or 0'",
")",
"for",
"key",
"in",
"keys",
":",
"if",
"HAVE_NUMPY",
"and",
"isinstance",
"(",
"key",
",",
"np",
".",
"ndarray",
")",
":",
"# recursive call",
"yield",
"list",
"(",
"dict_take_gen",
"(",
"dict_",
",",
"key",
",",
"*",
"d",
")",
")",
"else",
":",
"yield",
"dictget",
"(",
"key",
",",
"*",
"d",
")"
] | r"""
generate multiple values from a dictionary
Args:
dict_ (dict):
keys (list):
Varargs:
d: if specified is default for key errors
CommandLine:
python -m utool.util_dict --test-dict_take_gen
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> result = list(dict_take_gen(dict_, keys, None))
>>> result = ut.repr4(result, nl=False)
>>> print(result)
['a', 'b', 'c', None, None]
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> try:
>>> print(list(dict_take_gen(dict_, keys)))
>>> result = 'did not get key error'
>>> except KeyError:
>>> result = 'correctly got key error'
>>> print(result)
correctly got key error | [
"r",
"generate",
"multiple",
"values",
"from",
"a",
"dictionary"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L925-L979 | train |
Erotemic/utool | utool/util_dict.py | dict_take | def dict_take(dict_, keys, *d):
""" get multiple values from a dictionary """
try:
return list(dict_take_gen(dict_, keys, *d))
except TypeError:
return list(dict_take_gen(dict_, keys, *d))[0] | python | def dict_take(dict_, keys, *d):
""" get multiple values from a dictionary """
try:
return list(dict_take_gen(dict_, keys, *d))
except TypeError:
return list(dict_take_gen(dict_, keys, *d))[0] | [
"def",
"dict_take",
"(",
"dict_",
",",
"keys",
",",
"*",
"d",
")",
":",
"try",
":",
"return",
"list",
"(",
"dict_take_gen",
"(",
"dict_",
",",
"keys",
",",
"*",
"d",
")",
")",
"except",
"TypeError",
":",
"return",
"list",
"(",
"dict_take_gen",
"(",
"dict_",
",",
"keys",
",",
"*",
"d",
")",
")",
"[",
"0",
"]"
] | get multiple values from a dictionary | [
"get",
"multiple",
"values",
"from",
"a",
"dictionary"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L982-L987 | train |
Erotemic/utool | utool/util_dict.py | dict_take_pop | def dict_take_pop(dict_, keys, *d):
""" like dict_take but pops values off
CommandLine:
python -m utool.util_dict --test-dict_take_pop
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 'other': None, 'another': 'foo', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> print('before: ' + ut.repr4(dict_))
>>> result = list(dict_take_pop(dict_, keys, None))
>>> result = ut.repr4(result, nl=False)
>>> print('after: ' + ut.repr4(dict_))
>>> assert len(dict_) == 2
>>> print(result)
['a', 'b', 'c', None, None]
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> print('before: ' + ut.repr4(dict_))
>>> try:
>>> print(list(dict_take_pop(dict_, keys)))
>>> result = 'did not get key error'
>>> except KeyError:
>>> result = 'correctly got key error'
>>> assert len(dict_) == 0
>>> print('after: ' + ut.repr4(dict_))
>>> print(result)
correctly got key error
"""
if len(d) == 0:
return [dict_.pop(key) for key in keys]
elif len(d) == 1:
default = d[0]
return [dict_.pop(key, default) for key in keys]
else:
raise ValueError('len(d) must be 1 or 0') | python | def dict_take_pop(dict_, keys, *d):
""" like dict_take but pops values off
CommandLine:
python -m utool.util_dict --test-dict_take_pop
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 'other': None, 'another': 'foo', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> print('before: ' + ut.repr4(dict_))
>>> result = list(dict_take_pop(dict_, keys, None))
>>> result = ut.repr4(result, nl=False)
>>> print('after: ' + ut.repr4(dict_))
>>> assert len(dict_) == 2
>>> print(result)
['a', 'b', 'c', None, None]
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> print('before: ' + ut.repr4(dict_))
>>> try:
>>> print(list(dict_take_pop(dict_, keys)))
>>> result = 'did not get key error'
>>> except KeyError:
>>> result = 'correctly got key error'
>>> assert len(dict_) == 0
>>> print('after: ' + ut.repr4(dict_))
>>> print(result)
correctly got key error
"""
if len(d) == 0:
return [dict_.pop(key) for key in keys]
elif len(d) == 1:
default = d[0]
return [dict_.pop(key, default) for key in keys]
else:
raise ValueError('len(d) must be 1 or 0') | [
"def",
"dict_take_pop",
"(",
"dict_",
",",
"keys",
",",
"*",
"d",
")",
":",
"if",
"len",
"(",
"d",
")",
"==",
"0",
":",
"return",
"[",
"dict_",
".",
"pop",
"(",
"key",
")",
"for",
"key",
"in",
"keys",
"]",
"elif",
"len",
"(",
"d",
")",
"==",
"1",
":",
"default",
"=",
"d",
"[",
"0",
"]",
"return",
"[",
"dict_",
".",
"pop",
"(",
"key",
",",
"default",
")",
"for",
"key",
"in",
"keys",
"]",
"else",
":",
"raise",
"ValueError",
"(",
"'len(d) must be 1 or 0'",
")"
] | like dict_take but pops values off
CommandLine:
python -m utool.util_dict --test-dict_take_pop
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 'other': None, 'another': 'foo', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> print('before: ' + ut.repr4(dict_))
>>> result = list(dict_take_pop(dict_, keys, None))
>>> result = ut.repr4(result, nl=False)
>>> print('after: ' + ut.repr4(dict_))
>>> assert len(dict_) == 2
>>> print(result)
['a', 'b', 'c', None, None]
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 'a', 2: 'b', 3: 'c'}
>>> keys = [1, 2, 3, 4, 5]
>>> print('before: ' + ut.repr4(dict_))
>>> try:
>>> print(list(dict_take_pop(dict_, keys)))
>>> result = 'did not get key error'
>>> except KeyError:
>>> result = 'correctly got key error'
>>> assert len(dict_) == 0
>>> print('after: ' + ut.repr4(dict_))
>>> print(result)
correctly got key error | [
"like",
"dict_take",
"but",
"pops",
"values",
"off"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1014-L1057 | train |
Erotemic/utool | utool/util_dict.py | dict_assign | def dict_assign(dict_, keys, vals):
""" simple method for assigning or setting values with a similar interface
to dict_take """
for key, val in zip(keys, vals):
dict_[key] = val | python | def dict_assign(dict_, keys, vals):
""" simple method for assigning or setting values with a similar interface
to dict_take """
for key, val in zip(keys, vals):
dict_[key] = val | [
"def",
"dict_assign",
"(",
"dict_",
",",
"keys",
",",
"vals",
")",
":",
"for",
"key",
",",
"val",
"in",
"zip",
"(",
"keys",
",",
"vals",
")",
":",
"dict_",
"[",
"key",
"]",
"=",
"val"
] | simple method for assigning or setting values with a similar interface
to dict_take | [
"simple",
"method",
"for",
"assigning",
"or",
"setting",
"values",
"with",
"a",
"similar",
"interface",
"to",
"dict_take"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1060-L1064 | train |
Erotemic/utool | utool/util_dict.py | dict_where_len0 | def dict_where_len0(dict_):
"""
Accepts a dict of lists. Returns keys that have vals with no length
"""
keys = np.array(dict_.keys())
flags = np.array(list(map(len, dict_.values()))) == 0
indices = np.where(flags)[0]
return keys[indices] | python | def dict_where_len0(dict_):
"""
Accepts a dict of lists. Returns keys that have vals with no length
"""
keys = np.array(dict_.keys())
flags = np.array(list(map(len, dict_.values()))) == 0
indices = np.where(flags)[0]
return keys[indices] | [
"def",
"dict_where_len0",
"(",
"dict_",
")",
":",
"keys",
"=",
"np",
".",
"array",
"(",
"dict_",
".",
"keys",
"(",
")",
")",
"flags",
"=",
"np",
".",
"array",
"(",
"list",
"(",
"map",
"(",
"len",
",",
"dict_",
".",
"values",
"(",
")",
")",
")",
")",
"==",
"0",
"indices",
"=",
"np",
".",
"where",
"(",
"flags",
")",
"[",
"0",
"]",
"return",
"keys",
"[",
"indices",
"]"
] | Accepts a dict of lists. Returns keys that have vals with no length | [
"Accepts",
"a",
"dict",
"of",
"lists",
".",
"Returns",
"keys",
"that",
"have",
"vals",
"with",
"no",
"length"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1067-L1074 | train |
Erotemic/utool | utool/util_dict.py | dict_hist | def dict_hist(item_list, weight_list=None, ordered=False, labels=None):
r"""
Builds a histogram of items in item_list
Args:
item_list (list): list with hashable items (usually containing duplicates)
Returns:
dict : dictionary where the keys are items in item_list, and the values
are the number of times the item appears in item_list.
CommandLine:
python -m utool.util_dict --test-dict_hist
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 39, 900, 1232, 900, 1232, 2, 2, 2, 900]
>>> hist_ = dict_hist(item_list)
>>> result = ut.repr2(hist_)
>>> print(result)
{1: 1, 2: 4, 39: 1, 900: 3, 1232: 2}
"""
if labels is None:
# hist_ = defaultdict(lambda: 0)
hist_ = defaultdict(int)
else:
hist_ = {k: 0 for k in labels}
if weight_list is None:
# weight_list = it.repeat(1)
for item in item_list:
hist_[item] += 1
else:
for item, weight in zip(item_list, weight_list):
hist_[item] += weight
# hist_ = dict(hist_)
if ordered:
# import utool as ut
# key_order = ut.sortedby(list(hist_.keys()), list(hist_.values()))
getval = op.itemgetter(1)
key_order = [key for (key, value) in sorted(hist_.items(), key=getval)]
hist_ = order_dict_by(hist_, key_order)
return hist_ | python | def dict_hist(item_list, weight_list=None, ordered=False, labels=None):
r"""
Builds a histogram of items in item_list
Args:
item_list (list): list with hashable items (usually containing duplicates)
Returns:
dict : dictionary where the keys are items in item_list, and the values
are the number of times the item appears in item_list.
CommandLine:
python -m utool.util_dict --test-dict_hist
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 39, 900, 1232, 900, 1232, 2, 2, 2, 900]
>>> hist_ = dict_hist(item_list)
>>> result = ut.repr2(hist_)
>>> print(result)
{1: 1, 2: 4, 39: 1, 900: 3, 1232: 2}
"""
if labels is None:
# hist_ = defaultdict(lambda: 0)
hist_ = defaultdict(int)
else:
hist_ = {k: 0 for k in labels}
if weight_list is None:
# weight_list = it.repeat(1)
for item in item_list:
hist_[item] += 1
else:
for item, weight in zip(item_list, weight_list):
hist_[item] += weight
# hist_ = dict(hist_)
if ordered:
# import utool as ut
# key_order = ut.sortedby(list(hist_.keys()), list(hist_.values()))
getval = op.itemgetter(1)
key_order = [key for (key, value) in sorted(hist_.items(), key=getval)]
hist_ = order_dict_by(hist_, key_order)
return hist_ | [
"def",
"dict_hist",
"(",
"item_list",
",",
"weight_list",
"=",
"None",
",",
"ordered",
"=",
"False",
",",
"labels",
"=",
"None",
")",
":",
"if",
"labels",
"is",
"None",
":",
"# hist_ = defaultdict(lambda: 0)",
"hist_",
"=",
"defaultdict",
"(",
"int",
")",
"else",
":",
"hist_",
"=",
"{",
"k",
":",
"0",
"for",
"k",
"in",
"labels",
"}",
"if",
"weight_list",
"is",
"None",
":",
"# weight_list = it.repeat(1)",
"for",
"item",
"in",
"item_list",
":",
"hist_",
"[",
"item",
"]",
"+=",
"1",
"else",
":",
"for",
"item",
",",
"weight",
"in",
"zip",
"(",
"item_list",
",",
"weight_list",
")",
":",
"hist_",
"[",
"item",
"]",
"+=",
"weight",
"# hist_ = dict(hist_)",
"if",
"ordered",
":",
"# import utool as ut",
"# key_order = ut.sortedby(list(hist_.keys()), list(hist_.values()))",
"getval",
"=",
"op",
".",
"itemgetter",
"(",
"1",
")",
"key_order",
"=",
"[",
"key",
"for",
"(",
"key",
",",
"value",
")",
"in",
"sorted",
"(",
"hist_",
".",
"items",
"(",
")",
",",
"key",
"=",
"getval",
")",
"]",
"hist_",
"=",
"order_dict_by",
"(",
"hist_",
",",
"key_order",
")",
"return",
"hist_"
] | r"""
Builds a histogram of items in item_list
Args:
item_list (list): list with hashable items (usually containing duplicates)
Returns:
dict : dictionary where the keys are items in item_list, and the values
are the number of times the item appears in item_list.
CommandLine:
python -m utool.util_dict --test-dict_hist
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 39, 900, 1232, 900, 1232, 2, 2, 2, 900]
>>> hist_ = dict_hist(item_list)
>>> result = ut.repr2(hist_)
>>> print(result)
{1: 1, 2: 4, 39: 1, 900: 3, 1232: 2} | [
"r",
"Builds",
"a",
"histogram",
"of",
"items",
"in",
"item_list"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1236-L1279 | train |
Erotemic/utool | utool/util_dict.py | dict_isect_combine | def dict_isect_combine(dict1, dict2, combine_op=op.add):
""" Intersection of dict keys and combination of dict values """
keys3 = set(dict1.keys()).intersection(set(dict2.keys()))
dict3 = {key: combine_op(dict1[key], dict2[key]) for key in keys3}
return dict3 | python | def dict_isect_combine(dict1, dict2, combine_op=op.add):
""" Intersection of dict keys and combination of dict values """
keys3 = set(dict1.keys()).intersection(set(dict2.keys()))
dict3 = {key: combine_op(dict1[key], dict2[key]) for key in keys3}
return dict3 | [
"def",
"dict_isect_combine",
"(",
"dict1",
",",
"dict2",
",",
"combine_op",
"=",
"op",
".",
"add",
")",
":",
"keys3",
"=",
"set",
"(",
"dict1",
".",
"keys",
"(",
")",
")",
".",
"intersection",
"(",
"set",
"(",
"dict2",
".",
"keys",
"(",
")",
")",
")",
"dict3",
"=",
"{",
"key",
":",
"combine_op",
"(",
"dict1",
"[",
"key",
"]",
",",
"dict2",
"[",
"key",
"]",
")",
"for",
"key",
"in",
"keys3",
"}",
"return",
"dict3"
] | Intersection of dict keys and combination of dict values | [
"Intersection",
"of",
"dict",
"keys",
"and",
"combination",
"of",
"dict",
"values"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1438-L1442 | train |
Erotemic/utool | utool/util_dict.py | dict_union_combine | def dict_union_combine(dict1, dict2, combine_op=op.add,
default=util_const.NoParam,
default2=util_const.NoParam):
"""
Combine of dict keys and uses dfault value when key does not exist
CAREFUL WHEN USING THIS WITH REDUCE. Use dict_stack2 instead
"""
keys3 = set(dict1.keys()).union(set(dict2.keys()))
if default is util_const.NoParam:
dict3 = {key: combine_op(dict1[key], dict2[key]) for key in keys3}
else:
if default2 is util_const.NoParam:
default2 = default
dict3 = {key: combine_op(dict1.get(key, default), dict2.get(key, default2))
for key in keys3}
return dict3 | python | def dict_union_combine(dict1, dict2, combine_op=op.add,
default=util_const.NoParam,
default2=util_const.NoParam):
"""
Combine of dict keys and uses dfault value when key does not exist
CAREFUL WHEN USING THIS WITH REDUCE. Use dict_stack2 instead
"""
keys3 = set(dict1.keys()).union(set(dict2.keys()))
if default is util_const.NoParam:
dict3 = {key: combine_op(dict1[key], dict2[key]) for key in keys3}
else:
if default2 is util_const.NoParam:
default2 = default
dict3 = {key: combine_op(dict1.get(key, default), dict2.get(key, default2))
for key in keys3}
return dict3 | [
"def",
"dict_union_combine",
"(",
"dict1",
",",
"dict2",
",",
"combine_op",
"=",
"op",
".",
"add",
",",
"default",
"=",
"util_const",
".",
"NoParam",
",",
"default2",
"=",
"util_const",
".",
"NoParam",
")",
":",
"keys3",
"=",
"set",
"(",
"dict1",
".",
"keys",
"(",
")",
")",
".",
"union",
"(",
"set",
"(",
"dict2",
".",
"keys",
"(",
")",
")",
")",
"if",
"default",
"is",
"util_const",
".",
"NoParam",
":",
"dict3",
"=",
"{",
"key",
":",
"combine_op",
"(",
"dict1",
"[",
"key",
"]",
",",
"dict2",
"[",
"key",
"]",
")",
"for",
"key",
"in",
"keys3",
"}",
"else",
":",
"if",
"default2",
"is",
"util_const",
".",
"NoParam",
":",
"default2",
"=",
"default",
"dict3",
"=",
"{",
"key",
":",
"combine_op",
"(",
"dict1",
".",
"get",
"(",
"key",
",",
"default",
")",
",",
"dict2",
".",
"get",
"(",
"key",
",",
"default2",
")",
")",
"for",
"key",
"in",
"keys3",
"}",
"return",
"dict3"
] | Combine of dict keys and uses dfault value when key does not exist
CAREFUL WHEN USING THIS WITH REDUCE. Use dict_stack2 instead | [
"Combine",
"of",
"dict",
"keys",
"and",
"uses",
"dfault",
"value",
"when",
"key",
"does",
"not",
"exist"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1445-L1461 | train |
Erotemic/utool | utool/util_dict.py | dict_filter_nones | def dict_filter_nones(dict_):
r"""
Removes None values
Args:
dict_ (dict): a dictionary
Returns:
dict:
CommandLine:
python -m utool.util_dict --exec-dict_filter_nones
Example:
>>> # DISABLE_DOCTEST
>>> # UNSTABLE_DOCTEST
>>> # fails on python 3 because of dict None order
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: None, 2: 'blue', 3: 'four', None: 'fun'}
>>> dict2_ = dict_filter_nones(dict_)
>>> result = ut.repr4(dict2_, nl=False)
>>> print(result)
{None: 'fun', 2: 'blue', 3: 'four'}
"""
dict2_ = {
key: val
for key, val in six.iteritems(dict_)
if val is not None
}
return dict2_ | python | def dict_filter_nones(dict_):
r"""
Removes None values
Args:
dict_ (dict): a dictionary
Returns:
dict:
CommandLine:
python -m utool.util_dict --exec-dict_filter_nones
Example:
>>> # DISABLE_DOCTEST
>>> # UNSTABLE_DOCTEST
>>> # fails on python 3 because of dict None order
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: None, 2: 'blue', 3: 'four', None: 'fun'}
>>> dict2_ = dict_filter_nones(dict_)
>>> result = ut.repr4(dict2_, nl=False)
>>> print(result)
{None: 'fun', 2: 'blue', 3: 'four'}
"""
dict2_ = {
key: val
for key, val in six.iteritems(dict_)
if val is not None
}
return dict2_ | [
"def",
"dict_filter_nones",
"(",
"dict_",
")",
":",
"dict2_",
"=",
"{",
"key",
":",
"val",
"for",
"key",
",",
"val",
"in",
"six",
".",
"iteritems",
"(",
"dict_",
")",
"if",
"val",
"is",
"not",
"None",
"}",
"return",
"dict2_"
] | r"""
Removes None values
Args:
dict_ (dict): a dictionary
Returns:
dict:
CommandLine:
python -m utool.util_dict --exec-dict_filter_nones
Example:
>>> # DISABLE_DOCTEST
>>> # UNSTABLE_DOCTEST
>>> # fails on python 3 because of dict None order
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: None, 2: 'blue', 3: 'four', None: 'fun'}
>>> dict2_ = dict_filter_nones(dict_)
>>> result = ut.repr4(dict2_, nl=False)
>>> print(result)
{None: 'fun', 2: 'blue', 3: 'four'} | [
"r",
"Removes",
"None",
"values"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1474-L1504 | train |
Erotemic/utool | utool/util_dict.py | groupby_tags | def groupby_tags(item_list, tags_list):
r"""
case where an item can belong to multiple groups
Args:
item_list (list):
tags_list (list):
Returns:
dict: groupid_to_items
CommandLine:
python -m utool.util_dict --test-groupby_tags
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> tagged_item_list = {
>>> 'spam': ['meat', 'protein', 'food'],
>>> 'eggs': ['protein', 'food'],
>>> 'cheese': ['dairy', 'protein', 'food'],
>>> 'jam': ['fruit', 'food'],
>>> 'banana': ['weapon', 'fruit', 'food'],
>>> }
>>> item_list = list(tagged_item_list.keys())
>>> tags_list = list(tagged_item_list.values())
>>> groupid_to_items = groupby_tags(item_list, tags_list)
>>> groupid_to_items = ut.map_vals(sorted, groupid_to_items)
>>> result = ('groupid_to_items = %s' % (ut.repr4(groupid_to_items),))
>>> print(result)
groupid_to_items = {
'dairy': ['cheese'],
'food': ['banana', 'cheese', 'eggs', 'jam', 'spam'],
'fruit': ['banana', 'jam'],
'meat': ['spam'],
'protein': ['cheese', 'eggs', 'spam'],
'weapon': ['banana'],
}
"""
groupid_to_items = defaultdict(list)
for tags, item in zip(tags_list, item_list):
for tag in tags:
groupid_to_items[tag].append(item)
return groupid_to_items | python | def groupby_tags(item_list, tags_list):
r"""
case where an item can belong to multiple groups
Args:
item_list (list):
tags_list (list):
Returns:
dict: groupid_to_items
CommandLine:
python -m utool.util_dict --test-groupby_tags
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> tagged_item_list = {
>>> 'spam': ['meat', 'protein', 'food'],
>>> 'eggs': ['protein', 'food'],
>>> 'cheese': ['dairy', 'protein', 'food'],
>>> 'jam': ['fruit', 'food'],
>>> 'banana': ['weapon', 'fruit', 'food'],
>>> }
>>> item_list = list(tagged_item_list.keys())
>>> tags_list = list(tagged_item_list.values())
>>> groupid_to_items = groupby_tags(item_list, tags_list)
>>> groupid_to_items = ut.map_vals(sorted, groupid_to_items)
>>> result = ('groupid_to_items = %s' % (ut.repr4(groupid_to_items),))
>>> print(result)
groupid_to_items = {
'dairy': ['cheese'],
'food': ['banana', 'cheese', 'eggs', 'jam', 'spam'],
'fruit': ['banana', 'jam'],
'meat': ['spam'],
'protein': ['cheese', 'eggs', 'spam'],
'weapon': ['banana'],
}
"""
groupid_to_items = defaultdict(list)
for tags, item in zip(tags_list, item_list):
for tag in tags:
groupid_to_items[tag].append(item)
return groupid_to_items | [
"def",
"groupby_tags",
"(",
"item_list",
",",
"tags_list",
")",
":",
"groupid_to_items",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"tags",
",",
"item",
"in",
"zip",
"(",
"tags_list",
",",
"item_list",
")",
":",
"for",
"tag",
"in",
"tags",
":",
"groupid_to_items",
"[",
"tag",
"]",
".",
"append",
"(",
"item",
")",
"return",
"groupid_to_items"
] | r"""
case where an item can belong to multiple groups
Args:
item_list (list):
tags_list (list):
Returns:
dict: groupid_to_items
CommandLine:
python -m utool.util_dict --test-groupby_tags
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> tagged_item_list = {
>>> 'spam': ['meat', 'protein', 'food'],
>>> 'eggs': ['protein', 'food'],
>>> 'cheese': ['dairy', 'protein', 'food'],
>>> 'jam': ['fruit', 'food'],
>>> 'banana': ['weapon', 'fruit', 'food'],
>>> }
>>> item_list = list(tagged_item_list.keys())
>>> tags_list = list(tagged_item_list.values())
>>> groupid_to_items = groupby_tags(item_list, tags_list)
>>> groupid_to_items = ut.map_vals(sorted, groupid_to_items)
>>> result = ('groupid_to_items = %s' % (ut.repr4(groupid_to_items),))
>>> print(result)
groupid_to_items = {
'dairy': ['cheese'],
'food': ['banana', 'cheese', 'eggs', 'jam', 'spam'],
'fruit': ['banana', 'jam'],
'meat': ['spam'],
'protein': ['cheese', 'eggs', 'spam'],
'weapon': ['banana'],
} | [
"r",
"case",
"where",
"an",
"item",
"can",
"belong",
"to",
"multiple",
"groups"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1507-L1552 | train |
Erotemic/utool | utool/util_dict.py | group_pairs | def group_pairs(pair_list):
"""
Groups a list of items using the first element in each pair as the item and
the second element as the groupid.
Args:
pair_list (list): list of 2-tuples (item, groupid)
Returns:
dict: groupid_to_items: maps a groupid to a list of items
SeeAlso:
group_items
"""
# Initialize dict of lists
groupid_to_items = defaultdict(list)
# Insert each item into the correct group
for item, groupid in pair_list:
groupid_to_items[groupid].append(item)
return groupid_to_items | python | def group_pairs(pair_list):
"""
Groups a list of items using the first element in each pair as the item and
the second element as the groupid.
Args:
pair_list (list): list of 2-tuples (item, groupid)
Returns:
dict: groupid_to_items: maps a groupid to a list of items
SeeAlso:
group_items
"""
# Initialize dict of lists
groupid_to_items = defaultdict(list)
# Insert each item into the correct group
for item, groupid in pair_list:
groupid_to_items[groupid].append(item)
return groupid_to_items | [
"def",
"group_pairs",
"(",
"pair_list",
")",
":",
"# Initialize dict of lists",
"groupid_to_items",
"=",
"defaultdict",
"(",
"list",
")",
"# Insert each item into the correct group",
"for",
"item",
",",
"groupid",
"in",
"pair_list",
":",
"groupid_to_items",
"[",
"groupid",
"]",
".",
"append",
"(",
"item",
")",
"return",
"groupid_to_items"
] | Groups a list of items using the first element in each pair as the item and
the second element as the groupid.
Args:
pair_list (list): list of 2-tuples (item, groupid)
Returns:
dict: groupid_to_items: maps a groupid to a list of items
SeeAlso:
group_items | [
"Groups",
"a",
"list",
"of",
"items",
"using",
"the",
"first",
"element",
"in",
"each",
"pair",
"as",
"the",
"item",
"and",
"the",
"second",
"element",
"as",
"the",
"groupid",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1560-L1579 | train |
Erotemic/utool | utool/util_dict.py | group_items | def group_items(items, by=None, sorted_=True):
"""
Groups a list of items by group id.
Args:
items (list): a list of the values to be grouped.
if `by` is None, then each item is assumed to be a
(groupid, value) pair.
by (list): a corresponding list to group items by.
if specified, these are used as the keys to group values
in `items`
sorted_ (bool): if True preserves the ordering of items within groups
(default = True) FIXME. the opposite is true
Returns:
dict: groupid_to_items: maps a groupid to a list of items
SeeAlso:
group_indices - first part of a a more fine grained grouping algorithm
apply_gropuing - second part of a more fine grained grouping algorithm
CommandLine:
python -m utool.util_dict --test-group_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> items = ['ham', 'jam', 'spam', 'eggs', 'cheese', 'bannana']
>>> by = ['protein', 'fruit', 'protein', 'protein', 'dairy', 'fruit']
>>> groupid_to_items = ut.group_items(items, iter(by))
>>> result = ut.repr2(groupid_to_items)
>>> print(result)
{'dairy': ['cheese'], 'fruit': ['jam', 'bannana'], 'protein': ['ham', 'spam', 'eggs']}
"""
if by is not None:
pairs = list(zip(by, items))
if sorted_:
# Sort by groupid for cache efficiency (does this even do anything?)
# I forgot why this is needed? Determenism?
try:
pairs = sorted(pairs, key=op.itemgetter(0))
except TypeError:
# Python 3 does not allow sorting mixed types
pairs = sorted(pairs, key=lambda tup: str(tup[0]))
else:
pairs = items
# Initialize a dict of lists
groupid_to_items = defaultdict(list)
# Insert each item into the correct group
for groupid, item in pairs:
groupid_to_items[groupid].append(item)
return groupid_to_items | python | def group_items(items, by=None, sorted_=True):
"""
Groups a list of items by group id.
Args:
items (list): a list of the values to be grouped.
if `by` is None, then each item is assumed to be a
(groupid, value) pair.
by (list): a corresponding list to group items by.
if specified, these are used as the keys to group values
in `items`
sorted_ (bool): if True preserves the ordering of items within groups
(default = True) FIXME. the opposite is true
Returns:
dict: groupid_to_items: maps a groupid to a list of items
SeeAlso:
group_indices - first part of a a more fine grained grouping algorithm
apply_gropuing - second part of a more fine grained grouping algorithm
CommandLine:
python -m utool.util_dict --test-group_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> items = ['ham', 'jam', 'spam', 'eggs', 'cheese', 'bannana']
>>> by = ['protein', 'fruit', 'protein', 'protein', 'dairy', 'fruit']
>>> groupid_to_items = ut.group_items(items, iter(by))
>>> result = ut.repr2(groupid_to_items)
>>> print(result)
{'dairy': ['cheese'], 'fruit': ['jam', 'bannana'], 'protein': ['ham', 'spam', 'eggs']}
"""
if by is not None:
pairs = list(zip(by, items))
if sorted_:
# Sort by groupid for cache efficiency (does this even do anything?)
# I forgot why this is needed? Determenism?
try:
pairs = sorted(pairs, key=op.itemgetter(0))
except TypeError:
# Python 3 does not allow sorting mixed types
pairs = sorted(pairs, key=lambda tup: str(tup[0]))
else:
pairs = items
# Initialize a dict of lists
groupid_to_items = defaultdict(list)
# Insert each item into the correct group
for groupid, item in pairs:
groupid_to_items[groupid].append(item)
return groupid_to_items | [
"def",
"group_items",
"(",
"items",
",",
"by",
"=",
"None",
",",
"sorted_",
"=",
"True",
")",
":",
"if",
"by",
"is",
"not",
"None",
":",
"pairs",
"=",
"list",
"(",
"zip",
"(",
"by",
",",
"items",
")",
")",
"if",
"sorted_",
":",
"# Sort by groupid for cache efficiency (does this even do anything?)",
"# I forgot why this is needed? Determenism?",
"try",
":",
"pairs",
"=",
"sorted",
"(",
"pairs",
",",
"key",
"=",
"op",
".",
"itemgetter",
"(",
"0",
")",
")",
"except",
"TypeError",
":",
"# Python 3 does not allow sorting mixed types",
"pairs",
"=",
"sorted",
"(",
"pairs",
",",
"key",
"=",
"lambda",
"tup",
":",
"str",
"(",
"tup",
"[",
"0",
"]",
")",
")",
"else",
":",
"pairs",
"=",
"items",
"# Initialize a dict of lists",
"groupid_to_items",
"=",
"defaultdict",
"(",
"list",
")",
"# Insert each item into the correct group",
"for",
"groupid",
",",
"item",
"in",
"pairs",
":",
"groupid_to_items",
"[",
"groupid",
"]",
".",
"append",
"(",
"item",
")",
"return",
"groupid_to_items"
] | Groups a list of items by group id.
Args:
items (list): a list of the values to be grouped.
if `by` is None, then each item is assumed to be a
(groupid, value) pair.
by (list): a corresponding list to group items by.
if specified, these are used as the keys to group values
in `items`
sorted_ (bool): if True preserves the ordering of items within groups
(default = True) FIXME. the opposite is true
Returns:
dict: groupid_to_items: maps a groupid to a list of items
SeeAlso:
group_indices - first part of a a more fine grained grouping algorithm
apply_gropuing - second part of a more fine grained grouping algorithm
CommandLine:
python -m utool.util_dict --test-group_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> items = ['ham', 'jam', 'spam', 'eggs', 'cheese', 'bannana']
>>> by = ['protein', 'fruit', 'protein', 'protein', 'dairy', 'fruit']
>>> groupid_to_items = ut.group_items(items, iter(by))
>>> result = ut.repr2(groupid_to_items)
>>> print(result)
{'dairy': ['cheese'], 'fruit': ['jam', 'bannana'], 'protein': ['ham', 'spam', 'eggs']} | [
"Groups",
"a",
"list",
"of",
"items",
"by",
"group",
"id",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1582-L1635 | train |
Erotemic/utool | utool/util_dict.py | hierarchical_group_items | def hierarchical_group_items(item_list, groupids_list):
"""
Generalization of group_item. Convert a flast list of ids into a heirarchical dictionary.
TODO: move to util_dict
Reference:
http://stackoverflow.com/questions/10193235/python-translate-a-table-to-a-hierarchical-dictionary
Args:
item_list (list):
groupids_list (list):
CommandLine:
python -m utool.util_dict --exec-hierarchical_group_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4]
>>> groupids_list = [[1, 1, 2, 2]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {1: [1, 2], 2: [3, 4]}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4, 5, 6, 7, 8]
>>> groupids_list = [[1, 2, 1, 2, 1, 2, 1, 2], [3, 2, 2, 2, 3, 1, 1, 1]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {
1: {1: [7], 2: [3], 3: [1, 5]},
2: {1: [6, 8], 2: [2, 4]},
}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4]
>>> groupids_list = [[1, 1, 1, 2], [1, 2, 2, 2], [1, 3, 1, 1]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {
1: {
1: {1: [1]},
2: {1: [3], 3: [2]},
},
2: {
2: {1: [4]},
},
}
"""
# Construct a defaultdict type with the appropriate number of levels
num_groups = len(groupids_list)
leaf_type = partial(defaultdict, list)
if num_groups > 1:
node_type = leaf_type
for _ in range(len(groupids_list) - 2):
node_type = partial(defaultdict, node_type)
root_type = node_type
elif num_groups == 1:
root_type = list
else:
raise ValueError('must suply groupids')
tree = defaultdict(root_type)
#
groupid_tuple_list = list(zip(*groupids_list))
for groupid_tuple, item in zip(groupid_tuple_list, item_list):
node = tree
for groupid in groupid_tuple:
node = node[groupid]
node.append(item)
return tree | python | def hierarchical_group_items(item_list, groupids_list):
"""
Generalization of group_item. Convert a flast list of ids into a heirarchical dictionary.
TODO: move to util_dict
Reference:
http://stackoverflow.com/questions/10193235/python-translate-a-table-to-a-hierarchical-dictionary
Args:
item_list (list):
groupids_list (list):
CommandLine:
python -m utool.util_dict --exec-hierarchical_group_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4]
>>> groupids_list = [[1, 1, 2, 2]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {1: [1, 2], 2: [3, 4]}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4, 5, 6, 7, 8]
>>> groupids_list = [[1, 2, 1, 2, 1, 2, 1, 2], [3, 2, 2, 2, 3, 1, 1, 1]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {
1: {1: [7], 2: [3], 3: [1, 5]},
2: {1: [6, 8], 2: [2, 4]},
}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4]
>>> groupids_list = [[1, 1, 1, 2], [1, 2, 2, 2], [1, 3, 1, 1]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {
1: {
1: {1: [1]},
2: {1: [3], 3: [2]},
},
2: {
2: {1: [4]},
},
}
"""
# Construct a defaultdict type with the appropriate number of levels
num_groups = len(groupids_list)
leaf_type = partial(defaultdict, list)
if num_groups > 1:
node_type = leaf_type
for _ in range(len(groupids_list) - 2):
node_type = partial(defaultdict, node_type)
root_type = node_type
elif num_groups == 1:
root_type = list
else:
raise ValueError('must suply groupids')
tree = defaultdict(root_type)
#
groupid_tuple_list = list(zip(*groupids_list))
for groupid_tuple, item in zip(groupid_tuple_list, item_list):
node = tree
for groupid in groupid_tuple:
node = node[groupid]
node.append(item)
return tree | [
"def",
"hierarchical_group_items",
"(",
"item_list",
",",
"groupids_list",
")",
":",
"# Construct a defaultdict type with the appropriate number of levels",
"num_groups",
"=",
"len",
"(",
"groupids_list",
")",
"leaf_type",
"=",
"partial",
"(",
"defaultdict",
",",
"list",
")",
"if",
"num_groups",
">",
"1",
":",
"node_type",
"=",
"leaf_type",
"for",
"_",
"in",
"range",
"(",
"len",
"(",
"groupids_list",
")",
"-",
"2",
")",
":",
"node_type",
"=",
"partial",
"(",
"defaultdict",
",",
"node_type",
")",
"root_type",
"=",
"node_type",
"elif",
"num_groups",
"==",
"1",
":",
"root_type",
"=",
"list",
"else",
":",
"raise",
"ValueError",
"(",
"'must suply groupids'",
")",
"tree",
"=",
"defaultdict",
"(",
"root_type",
")",
"#",
"groupid_tuple_list",
"=",
"list",
"(",
"zip",
"(",
"*",
"groupids_list",
")",
")",
"for",
"groupid_tuple",
",",
"item",
"in",
"zip",
"(",
"groupid_tuple_list",
",",
"item_list",
")",
":",
"node",
"=",
"tree",
"for",
"groupid",
"in",
"groupid_tuple",
":",
"node",
"=",
"node",
"[",
"groupid",
"]",
"node",
".",
"append",
"(",
"item",
")",
"return",
"tree"
] | Generalization of group_item. Convert a flast list of ids into a heirarchical dictionary.
TODO: move to util_dict
Reference:
http://stackoverflow.com/questions/10193235/python-translate-a-table-to-a-hierarchical-dictionary
Args:
item_list (list):
groupids_list (list):
CommandLine:
python -m utool.util_dict --exec-hierarchical_group_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4]
>>> groupids_list = [[1, 1, 2, 2]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {1: [1, 2], 2: [3, 4]}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4, 5, 6, 7, 8]
>>> groupids_list = [[1, 2, 1, 2, 1, 2, 1, 2], [3, 2, 2, 2, 3, 1, 1, 1]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {
1: {1: [7], 2: [3], 3: [1, 5]},
2: {1: [6, 8], 2: [2, 4]},
}
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4]
>>> groupids_list = [[1, 1, 1, 2], [1, 2, 2, 2], [1, 3, 1, 1]]
>>> tree = hierarchical_group_items(item_list, groupids_list)
>>> result = ('tree = ' + ut.repr4(tree, nl=len(groupids_list) - 1))
>>> print(result)
tree = {
1: {
1: {1: [1]},
2: {1: [3], 3: [2]},
},
2: {
2: {1: [4]},
},
} | [
"Generalization",
"of",
"group_item",
".",
"Convert",
"a",
"flast",
"list",
"of",
"ids",
"into",
"a",
"heirarchical",
"dictionary",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1638-L1719 | train |
Erotemic/utool | utool/util_dict.py | hierarchical_map_vals | def hierarchical_map_vals(func, node, max_depth=None, depth=0):
"""
node is a dict tree like structure with leaves of type list
TODO: move to util_dict
CommandLine:
python -m utool.util_dict --exec-hierarchical_map_vals
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4, 5, 6, 7, 8]
>>> groupids_list = [[1, 2, 1, 2, 1, 2, 1, 2], [3, 2, 2, 2, 3, 1, 1, 1]]
>>> tree = ut.hierarchical_group_items(item_list, groupids_list)
>>> len_tree = ut.hierarchical_map_vals(len, tree)
>>> result = ('len_tree = ' + ut.repr4(len_tree, nl=1))
>>> print(result)
len_tree = {
1: {1: 1, 2: 1, 3: 2},
2: {1: 2, 2: 2},
}
Example1:
>>> # DISABLE_DOCTEST
>>> # UNSTABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> depth = 4
>>> item_list = list(range(2 ** (depth + 1)))
>>> num = len(item_list) // 2
>>> groupids_list = []
>>> total = 0
>>> for level in range(depth):
... num2 = len(item_list) // int((num * 2))
... #nonflat_levelids = [([total + 2 * x + 1] * num + [total + 2 * x + 2] * num) for x in range(num2)]
... nonflat_levelids = [([1] * num + [2] * num) for x in range(num2)]
... levelids = ut.flatten(nonflat_levelids)
... groupids_list.append(levelids)
... total += num2 * 2
... num //= 2
>>> print('groupids_list = %s' % (ut.repr4(groupids_list, nl=1),))
>>> print('depth = %r' % (len(groupids_list),))
>>> tree = ut.hierarchical_group_items(item_list, groupids_list)
>>> print('tree = ' + ut.repr4(tree, nl=None))
>>> flat_tree_values = list(ut.iflatten_dict_values(tree))
>>> assert sorted(flat_tree_values) == sorted(item_list)
>>> print('flat_tree_values = ' + str(flat_tree_values))
>>> #print('flat_tree_keys = ' + str(list(ut.iflatten_dict_keys(tree))))
>>> #print('iflatten_dict_items = ' + str(list(ut.iflatten_dict_items(tree))))
>>> len_tree = ut.hierarchical_map_vals(len, tree, max_depth=4)
>>> result = ('len_tree = ' + ut.repr4(len_tree, nl=None))
>>> print(result)
"""
#if not isinstance(node, dict):
if not hasattr(node, 'items'):
return func(node)
elif max_depth is not None and depth >= max_depth:
#return func(node)
return map_dict_vals(func, node)
#return {key: func(val) for key, val in six.iteritems(node)}
else:
# recursion
#return {key: hierarchical_map_vals(func, val, max_depth, depth + 1) for key, val in six.iteritems(node)}
#keyval_list = [(key, hierarchical_map_vals(func, val, max_depth, depth + 1)) for key, val in six.iteritems(node)]
keyval_list = [(key, hierarchical_map_vals(func, val, max_depth, depth + 1)) for key, val in node.items()]
if isinstance(node, OrderedDict):
return OrderedDict(keyval_list)
else:
return dict(keyval_list) | python | def hierarchical_map_vals(func, node, max_depth=None, depth=0):
"""
node is a dict tree like structure with leaves of type list
TODO: move to util_dict
CommandLine:
python -m utool.util_dict --exec-hierarchical_map_vals
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4, 5, 6, 7, 8]
>>> groupids_list = [[1, 2, 1, 2, 1, 2, 1, 2], [3, 2, 2, 2, 3, 1, 1, 1]]
>>> tree = ut.hierarchical_group_items(item_list, groupids_list)
>>> len_tree = ut.hierarchical_map_vals(len, tree)
>>> result = ('len_tree = ' + ut.repr4(len_tree, nl=1))
>>> print(result)
len_tree = {
1: {1: 1, 2: 1, 3: 2},
2: {1: 2, 2: 2},
}
Example1:
>>> # DISABLE_DOCTEST
>>> # UNSTABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> depth = 4
>>> item_list = list(range(2 ** (depth + 1)))
>>> num = len(item_list) // 2
>>> groupids_list = []
>>> total = 0
>>> for level in range(depth):
... num2 = len(item_list) // int((num * 2))
... #nonflat_levelids = [([total + 2 * x + 1] * num + [total + 2 * x + 2] * num) for x in range(num2)]
... nonflat_levelids = [([1] * num + [2] * num) for x in range(num2)]
... levelids = ut.flatten(nonflat_levelids)
... groupids_list.append(levelids)
... total += num2 * 2
... num //= 2
>>> print('groupids_list = %s' % (ut.repr4(groupids_list, nl=1),))
>>> print('depth = %r' % (len(groupids_list),))
>>> tree = ut.hierarchical_group_items(item_list, groupids_list)
>>> print('tree = ' + ut.repr4(tree, nl=None))
>>> flat_tree_values = list(ut.iflatten_dict_values(tree))
>>> assert sorted(flat_tree_values) == sorted(item_list)
>>> print('flat_tree_values = ' + str(flat_tree_values))
>>> #print('flat_tree_keys = ' + str(list(ut.iflatten_dict_keys(tree))))
>>> #print('iflatten_dict_items = ' + str(list(ut.iflatten_dict_items(tree))))
>>> len_tree = ut.hierarchical_map_vals(len, tree, max_depth=4)
>>> result = ('len_tree = ' + ut.repr4(len_tree, nl=None))
>>> print(result)
"""
#if not isinstance(node, dict):
if not hasattr(node, 'items'):
return func(node)
elif max_depth is not None and depth >= max_depth:
#return func(node)
return map_dict_vals(func, node)
#return {key: func(val) for key, val in six.iteritems(node)}
else:
# recursion
#return {key: hierarchical_map_vals(func, val, max_depth, depth + 1) for key, val in six.iteritems(node)}
#keyval_list = [(key, hierarchical_map_vals(func, val, max_depth, depth + 1)) for key, val in six.iteritems(node)]
keyval_list = [(key, hierarchical_map_vals(func, val, max_depth, depth + 1)) for key, val in node.items()]
if isinstance(node, OrderedDict):
return OrderedDict(keyval_list)
else:
return dict(keyval_list) | [
"def",
"hierarchical_map_vals",
"(",
"func",
",",
"node",
",",
"max_depth",
"=",
"None",
",",
"depth",
"=",
"0",
")",
":",
"#if not isinstance(node, dict):",
"if",
"not",
"hasattr",
"(",
"node",
",",
"'items'",
")",
":",
"return",
"func",
"(",
"node",
")",
"elif",
"max_depth",
"is",
"not",
"None",
"and",
"depth",
">=",
"max_depth",
":",
"#return func(node)",
"return",
"map_dict_vals",
"(",
"func",
",",
"node",
")",
"#return {key: func(val) for key, val in six.iteritems(node)}",
"else",
":",
"# recursion",
"#return {key: hierarchical_map_vals(func, val, max_depth, depth + 1) for key, val in six.iteritems(node)}",
"#keyval_list = [(key, hierarchical_map_vals(func, val, max_depth, depth + 1)) for key, val in six.iteritems(node)]",
"keyval_list",
"=",
"[",
"(",
"key",
",",
"hierarchical_map_vals",
"(",
"func",
",",
"val",
",",
"max_depth",
",",
"depth",
"+",
"1",
")",
")",
"for",
"key",
",",
"val",
"in",
"node",
".",
"items",
"(",
")",
"]",
"if",
"isinstance",
"(",
"node",
",",
"OrderedDict",
")",
":",
"return",
"OrderedDict",
"(",
"keyval_list",
")",
"else",
":",
"return",
"dict",
"(",
"keyval_list",
")"
] | node is a dict tree like structure with leaves of type list
TODO: move to util_dict
CommandLine:
python -m utool.util_dict --exec-hierarchical_map_vals
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> item_list = [1, 2, 3, 4, 5, 6, 7, 8]
>>> groupids_list = [[1, 2, 1, 2, 1, 2, 1, 2], [3, 2, 2, 2, 3, 1, 1, 1]]
>>> tree = ut.hierarchical_group_items(item_list, groupids_list)
>>> len_tree = ut.hierarchical_map_vals(len, tree)
>>> result = ('len_tree = ' + ut.repr4(len_tree, nl=1))
>>> print(result)
len_tree = {
1: {1: 1, 2: 1, 3: 2},
2: {1: 2, 2: 2},
}
Example1:
>>> # DISABLE_DOCTEST
>>> # UNSTABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> depth = 4
>>> item_list = list(range(2 ** (depth + 1)))
>>> num = len(item_list) // 2
>>> groupids_list = []
>>> total = 0
>>> for level in range(depth):
... num2 = len(item_list) // int((num * 2))
... #nonflat_levelids = [([total + 2 * x + 1] * num + [total + 2 * x + 2] * num) for x in range(num2)]
... nonflat_levelids = [([1] * num + [2] * num) for x in range(num2)]
... levelids = ut.flatten(nonflat_levelids)
... groupids_list.append(levelids)
... total += num2 * 2
... num //= 2
>>> print('groupids_list = %s' % (ut.repr4(groupids_list, nl=1),))
>>> print('depth = %r' % (len(groupids_list),))
>>> tree = ut.hierarchical_group_items(item_list, groupids_list)
>>> print('tree = ' + ut.repr4(tree, nl=None))
>>> flat_tree_values = list(ut.iflatten_dict_values(tree))
>>> assert sorted(flat_tree_values) == sorted(item_list)
>>> print('flat_tree_values = ' + str(flat_tree_values))
>>> #print('flat_tree_keys = ' + str(list(ut.iflatten_dict_keys(tree))))
>>> #print('iflatten_dict_items = ' + str(list(ut.iflatten_dict_items(tree))))
>>> len_tree = ut.hierarchical_map_vals(len, tree, max_depth=4)
>>> result = ('len_tree = ' + ut.repr4(len_tree, nl=None))
>>> print(result) | [
"node",
"is",
"a",
"dict",
"tree",
"like",
"structure",
"with",
"leaves",
"of",
"type",
"list"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1750-L1821 | train |
Erotemic/utool | utool/util_dict.py | sort_dict | def sort_dict(dict_, part='keys', key=None, reverse=False):
"""
sorts a dictionary by its values or its keys
Args:
dict_ (dict_): a dictionary
part (str): specifies to sort by keys or values
key (Optional[func]): a function that takes specified part
and returns a sortable value
reverse (bool): (Defaults to False) - True for descinding order. False
for ascending order.
Returns:
OrderedDict: sorted dictionary
CommandLine:
python -m utool.util_dict sort_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 3, 'c': 2, 'b': 1}
>>> results = []
>>> results.append(sort_dict(dict_, 'keys'))
>>> results.append(sort_dict(dict_, 'vals'))
>>> results.append(sort_dict(dict_, 'vals', lambda x: -x))
>>> result = ut.repr4(results)
>>> print(result)
[
{'a': 3, 'b': 1, 'c': 2},
{'b': 1, 'c': 2, 'a': 3},
{'a': 3, 'c': 2, 'b': 1},
]
"""
if part == 'keys':
index = 0
elif part in {'vals', 'values'}:
index = 1
else:
raise ValueError('Unknown method part=%r' % (part,))
if key is None:
_key = op.itemgetter(index)
else:
def _key(item):
return key(item[index])
sorted_items = sorted(six.iteritems(dict_), key=_key, reverse=reverse)
sorted_dict = OrderedDict(sorted_items)
return sorted_dict | python | def sort_dict(dict_, part='keys', key=None, reverse=False):
"""
sorts a dictionary by its values or its keys
Args:
dict_ (dict_): a dictionary
part (str): specifies to sort by keys or values
key (Optional[func]): a function that takes specified part
and returns a sortable value
reverse (bool): (Defaults to False) - True for descinding order. False
for ascending order.
Returns:
OrderedDict: sorted dictionary
CommandLine:
python -m utool.util_dict sort_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 3, 'c': 2, 'b': 1}
>>> results = []
>>> results.append(sort_dict(dict_, 'keys'))
>>> results.append(sort_dict(dict_, 'vals'))
>>> results.append(sort_dict(dict_, 'vals', lambda x: -x))
>>> result = ut.repr4(results)
>>> print(result)
[
{'a': 3, 'b': 1, 'c': 2},
{'b': 1, 'c': 2, 'a': 3},
{'a': 3, 'c': 2, 'b': 1},
]
"""
if part == 'keys':
index = 0
elif part in {'vals', 'values'}:
index = 1
else:
raise ValueError('Unknown method part=%r' % (part,))
if key is None:
_key = op.itemgetter(index)
else:
def _key(item):
return key(item[index])
sorted_items = sorted(six.iteritems(dict_), key=_key, reverse=reverse)
sorted_dict = OrderedDict(sorted_items)
return sorted_dict | [
"def",
"sort_dict",
"(",
"dict_",
",",
"part",
"=",
"'keys'",
",",
"key",
"=",
"None",
",",
"reverse",
"=",
"False",
")",
":",
"if",
"part",
"==",
"'keys'",
":",
"index",
"=",
"0",
"elif",
"part",
"in",
"{",
"'vals'",
",",
"'values'",
"}",
":",
"index",
"=",
"1",
"else",
":",
"raise",
"ValueError",
"(",
"'Unknown method part=%r'",
"%",
"(",
"part",
",",
")",
")",
"if",
"key",
"is",
"None",
":",
"_key",
"=",
"op",
".",
"itemgetter",
"(",
"index",
")",
"else",
":",
"def",
"_key",
"(",
"item",
")",
":",
"return",
"key",
"(",
"item",
"[",
"index",
"]",
")",
"sorted_items",
"=",
"sorted",
"(",
"six",
".",
"iteritems",
"(",
"dict_",
")",
",",
"key",
"=",
"_key",
",",
"reverse",
"=",
"reverse",
")",
"sorted_dict",
"=",
"OrderedDict",
"(",
"sorted_items",
")",
"return",
"sorted_dict"
] | sorts a dictionary by its values or its keys
Args:
dict_ (dict_): a dictionary
part (str): specifies to sort by keys or values
key (Optional[func]): a function that takes specified part
and returns a sortable value
reverse (bool): (Defaults to False) - True for descinding order. False
for ascending order.
Returns:
OrderedDict: sorted dictionary
CommandLine:
python -m utool.util_dict sort_dict
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {'a': 3, 'c': 2, 'b': 1}
>>> results = []
>>> results.append(sort_dict(dict_, 'keys'))
>>> results.append(sort_dict(dict_, 'vals'))
>>> results.append(sort_dict(dict_, 'vals', lambda x: -x))
>>> result = ut.repr4(results)
>>> print(result)
[
{'a': 3, 'b': 1, 'c': 2},
{'b': 1, 'c': 2, 'a': 3},
{'a': 3, 'c': 2, 'b': 1},
] | [
"sorts",
"a",
"dictionary",
"by",
"its",
"values",
"or",
"its",
"keys"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L1955-L2003 | train |
Erotemic/utool | utool/util_dict.py | order_dict_by | def order_dict_by(dict_, key_order):
r"""
Reorders items in a dictionary according to a custom key order
Args:
dict_ (dict_): a dictionary
key_order (list): custom key order
Returns:
OrderedDict: sorted_dict
CommandLine:
python -m utool.util_dict --exec-order_dict_by
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 1, 2: 2, 3: 3, 4: 4}
>>> key_order = [4, 2, 3, 1]
>>> sorted_dict = order_dict_by(dict_, key_order)
>>> result = ('sorted_dict = %s' % (ut.repr4(sorted_dict, nl=False),))
>>> print(result)
>>> assert result == 'sorted_dict = {4: 4, 2: 2, 3: 3, 1: 1}'
"""
dict_keys = set(dict_.keys())
other_keys = dict_keys - set(key_order)
key_order = it.chain(key_order, other_keys)
sorted_dict = OrderedDict(
(key, dict_[key]) for key in key_order if key in dict_keys
)
return sorted_dict | python | def order_dict_by(dict_, key_order):
r"""
Reorders items in a dictionary according to a custom key order
Args:
dict_ (dict_): a dictionary
key_order (list): custom key order
Returns:
OrderedDict: sorted_dict
CommandLine:
python -m utool.util_dict --exec-order_dict_by
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 1, 2: 2, 3: 3, 4: 4}
>>> key_order = [4, 2, 3, 1]
>>> sorted_dict = order_dict_by(dict_, key_order)
>>> result = ('sorted_dict = %s' % (ut.repr4(sorted_dict, nl=False),))
>>> print(result)
>>> assert result == 'sorted_dict = {4: 4, 2: 2, 3: 3, 1: 1}'
"""
dict_keys = set(dict_.keys())
other_keys = dict_keys - set(key_order)
key_order = it.chain(key_order, other_keys)
sorted_dict = OrderedDict(
(key, dict_[key]) for key in key_order if key in dict_keys
)
return sorted_dict | [
"def",
"order_dict_by",
"(",
"dict_",
",",
"key_order",
")",
":",
"dict_keys",
"=",
"set",
"(",
"dict_",
".",
"keys",
"(",
")",
")",
"other_keys",
"=",
"dict_keys",
"-",
"set",
"(",
"key_order",
")",
"key_order",
"=",
"it",
".",
"chain",
"(",
"key_order",
",",
"other_keys",
")",
"sorted_dict",
"=",
"OrderedDict",
"(",
"(",
"key",
",",
"dict_",
"[",
"key",
"]",
")",
"for",
"key",
"in",
"key_order",
"if",
"key",
"in",
"dict_keys",
")",
"return",
"sorted_dict"
] | r"""
Reorders items in a dictionary according to a custom key order
Args:
dict_ (dict_): a dictionary
key_order (list): custom key order
Returns:
OrderedDict: sorted_dict
CommandLine:
python -m utool.util_dict --exec-order_dict_by
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> dict_ = {1: 1, 2: 2, 3: 3, 4: 4}
>>> key_order = [4, 2, 3, 1]
>>> sorted_dict = order_dict_by(dict_, key_order)
>>> result = ('sorted_dict = %s' % (ut.repr4(sorted_dict, nl=False),))
>>> print(result)
>>> assert result == 'sorted_dict = {4: 4, 2: 2, 3: 3, 1: 1}' | [
"r",
"Reorders",
"items",
"in",
"a",
"dictionary",
"according",
"to",
"a",
"custom",
"key",
"order"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L2006-L2038 | train |
Erotemic/utool | utool/util_dict.py | iteritems_sorted | def iteritems_sorted(dict_):
""" change to iteritems ordered """
if isinstance(dict_, OrderedDict):
return six.iteritems(dict_)
else:
return iter(sorted(six.iteritems(dict_))) | python | def iteritems_sorted(dict_):
""" change to iteritems ordered """
if isinstance(dict_, OrderedDict):
return six.iteritems(dict_)
else:
return iter(sorted(six.iteritems(dict_))) | [
"def",
"iteritems_sorted",
"(",
"dict_",
")",
":",
"if",
"isinstance",
"(",
"dict_",
",",
"OrderedDict",
")",
":",
"return",
"six",
".",
"iteritems",
"(",
"dict_",
")",
"else",
":",
"return",
"iter",
"(",
"sorted",
"(",
"six",
".",
"iteritems",
"(",
"dict_",
")",
")",
")"
] | change to iteritems ordered | [
"change",
"to",
"iteritems",
"ordered"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L2041-L2046 | train |
Erotemic/utool | utool/util_dict.py | flatten_dict_vals | def flatten_dict_vals(dict_):
"""
Flattens only values in a heirarchical dictionary, keys are nested.
"""
if isinstance(dict_, dict):
return dict([
((key, augkey), augval)
for key, val in dict_.items()
for augkey, augval in flatten_dict_vals(val).items()
])
else:
return {None: dict_} | python | def flatten_dict_vals(dict_):
"""
Flattens only values in a heirarchical dictionary, keys are nested.
"""
if isinstance(dict_, dict):
return dict([
((key, augkey), augval)
for key, val in dict_.items()
for augkey, augval in flatten_dict_vals(val).items()
])
else:
return {None: dict_} | [
"def",
"flatten_dict_vals",
"(",
"dict_",
")",
":",
"if",
"isinstance",
"(",
"dict_",
",",
"dict",
")",
":",
"return",
"dict",
"(",
"[",
"(",
"(",
"key",
",",
"augkey",
")",
",",
"augval",
")",
"for",
"key",
",",
"val",
"in",
"dict_",
".",
"items",
"(",
")",
"for",
"augkey",
",",
"augval",
"in",
"flatten_dict_vals",
"(",
"val",
")",
".",
"items",
"(",
")",
"]",
")",
"else",
":",
"return",
"{",
"None",
":",
"dict_",
"}"
] | Flattens only values in a heirarchical dictionary, keys are nested. | [
"Flattens",
"only",
"values",
"in",
"a",
"heirarchical",
"dictionary",
"keys",
"are",
"nested",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L2054-L2065 | train |
Erotemic/utool | utool/util_dict.py | depth_atleast | def depth_atleast(list_, depth):
r"""
Returns if depth of list is at least ``depth``
Args:
list_ (list):
depth (int):
Returns:
bool: True
CommandLine:
python -m utool.util_dict --exec-depth_atleast --show
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> list_ = [[[[0]]], [[0]]]
>>> depth = 0
>>> result = [depth_atleast(list_, depth) for depth in range(0, 7)]
>>> print(result)
"""
if depth == 0:
return True
else:
try:
return all([depth_atleast(item, depth - 1) for item in list_])
except TypeError:
return False | python | def depth_atleast(list_, depth):
r"""
Returns if depth of list is at least ``depth``
Args:
list_ (list):
depth (int):
Returns:
bool: True
CommandLine:
python -m utool.util_dict --exec-depth_atleast --show
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> list_ = [[[[0]]], [[0]]]
>>> depth = 0
>>> result = [depth_atleast(list_, depth) for depth in range(0, 7)]
>>> print(result)
"""
if depth == 0:
return True
else:
try:
return all([depth_atleast(item, depth - 1) for item in list_])
except TypeError:
return False | [
"def",
"depth_atleast",
"(",
"list_",
",",
"depth",
")",
":",
"if",
"depth",
"==",
"0",
":",
"return",
"True",
"else",
":",
"try",
":",
"return",
"all",
"(",
"[",
"depth_atleast",
"(",
"item",
",",
"depth",
"-",
"1",
")",
"for",
"item",
"in",
"list_",
"]",
")",
"except",
"TypeError",
":",
"return",
"False"
] | r"""
Returns if depth of list is at least ``depth``
Args:
list_ (list):
depth (int):
Returns:
bool: True
CommandLine:
python -m utool.util_dict --exec-depth_atleast --show
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_dict import * # NOQA
>>> import utool as ut
>>> list_ = [[[[0]]], [[0]]]
>>> depth = 0
>>> result = [depth_atleast(list_, depth) for depth in range(0, 7)]
>>> print(result) | [
"r",
"Returns",
"if",
"depth",
"of",
"list",
"is",
"at",
"least",
"depth"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_dict.py#L2096-L2125 | train |
glormph/msstitch | src/app/actions/mzidtsv/splitmerge.py | get_splitcolnr | def get_splitcolnr(header, bioset, splitcol):
"""Returns column nr on which to split PSM table. Chooses from flags
given via bioset and splitcol"""
if bioset:
return header.index(mzidtsvdata.HEADER_SETNAME)
elif splitcol is not None:
return splitcol - 1
else:
raise RuntimeError('Must specify either --bioset or --splitcol') | python | def get_splitcolnr(header, bioset, splitcol):
"""Returns column nr on which to split PSM table. Chooses from flags
given via bioset and splitcol"""
if bioset:
return header.index(mzidtsvdata.HEADER_SETNAME)
elif splitcol is not None:
return splitcol - 1
else:
raise RuntimeError('Must specify either --bioset or --splitcol') | [
"def",
"get_splitcolnr",
"(",
"header",
",",
"bioset",
",",
"splitcol",
")",
":",
"if",
"bioset",
":",
"return",
"header",
".",
"index",
"(",
"mzidtsvdata",
".",
"HEADER_SETNAME",
")",
"elif",
"splitcol",
"is",
"not",
"None",
":",
"return",
"splitcol",
"-",
"1",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Must specify either --bioset or --splitcol'",
")"
] | Returns column nr on which to split PSM table. Chooses from flags
given via bioset and splitcol | [
"Returns",
"column",
"nr",
"on",
"which",
"to",
"split",
"PSM",
"table",
".",
"Chooses",
"from",
"flags",
"given",
"via",
"bioset",
"and",
"splitcol"
] | ded7e5cbd813d7797dc9d42805778266e59ff042 | https://github.com/glormph/msstitch/blob/ded7e5cbd813d7797dc9d42805778266e59ff042/src/app/actions/mzidtsv/splitmerge.py#L14-L22 | train |
glormph/msstitch | src/app/actions/mzidtsv/splitmerge.py | generate_psms_split | def generate_psms_split(fn, oldheader, bioset, splitcol):
"""Loops PSMs and outputs dictionaries passed to writer. Dictionaries
contain the PSMs and info to which split pool the
respective PSM belongs"""
try:
splitcolnr = get_splitcolnr(oldheader, bioset, splitcol)
except IndexError:
raise RuntimeError('Cannot find bioset header column in '
'input file {}, though --bioset has '
'been passed'.format(fn))
for psm in tsvreader.generate_tsv_psms(fn, oldheader):
yield {'psm': psm,
'split_pool': psm[oldheader[splitcolnr]]
} | python | def generate_psms_split(fn, oldheader, bioset, splitcol):
"""Loops PSMs and outputs dictionaries passed to writer. Dictionaries
contain the PSMs and info to which split pool the
respective PSM belongs"""
try:
splitcolnr = get_splitcolnr(oldheader, bioset, splitcol)
except IndexError:
raise RuntimeError('Cannot find bioset header column in '
'input file {}, though --bioset has '
'been passed'.format(fn))
for psm in tsvreader.generate_tsv_psms(fn, oldheader):
yield {'psm': psm,
'split_pool': psm[oldheader[splitcolnr]]
} | [
"def",
"generate_psms_split",
"(",
"fn",
",",
"oldheader",
",",
"bioset",
",",
"splitcol",
")",
":",
"try",
":",
"splitcolnr",
"=",
"get_splitcolnr",
"(",
"oldheader",
",",
"bioset",
",",
"splitcol",
")",
"except",
"IndexError",
":",
"raise",
"RuntimeError",
"(",
"'Cannot find bioset header column in '",
"'input file {}, though --bioset has '",
"'been passed'",
".",
"format",
"(",
"fn",
")",
")",
"for",
"psm",
"in",
"tsvreader",
".",
"generate_tsv_psms",
"(",
"fn",
",",
"oldheader",
")",
":",
"yield",
"{",
"'psm'",
":",
"psm",
",",
"'split_pool'",
":",
"psm",
"[",
"oldheader",
"[",
"splitcolnr",
"]",
"]",
"}"
] | Loops PSMs and outputs dictionaries passed to writer. Dictionaries
contain the PSMs and info to which split pool the
respective PSM belongs | [
"Loops",
"PSMs",
"and",
"outputs",
"dictionaries",
"passed",
"to",
"writer",
".",
"Dictionaries",
"contain",
"the",
"PSMs",
"and",
"info",
"to",
"which",
"split",
"pool",
"the",
"respective",
"PSM",
"belongs"
] | ded7e5cbd813d7797dc9d42805778266e59ff042 | https://github.com/glormph/msstitch/blob/ded7e5cbd813d7797dc9d42805778266e59ff042/src/app/actions/mzidtsv/splitmerge.py#L25-L38 | train |
Erotemic/utool | utool/_internal/randomwrap.py | rnumlistwithoutreplacement | def rnumlistwithoutreplacement(min, max):
"""Returns a randomly ordered list of the integers between min and max"""
if checkquota() < 1:
raise Exception("Your www.random.org quota has already run out.")
requestparam = build_request_parameterNR(min, max)
request = urllib.request.Request(requestparam)
request.add_header('User-Agent', 'randomwrapy/0.1 very alpha')
opener = urllib.request.build_opener()
numlist = opener.open(request).read()
return numlist.split() | python | def rnumlistwithoutreplacement(min, max):
"""Returns a randomly ordered list of the integers between min and max"""
if checkquota() < 1:
raise Exception("Your www.random.org quota has already run out.")
requestparam = build_request_parameterNR(min, max)
request = urllib.request.Request(requestparam)
request.add_header('User-Agent', 'randomwrapy/0.1 very alpha')
opener = urllib.request.build_opener()
numlist = opener.open(request).read()
return numlist.split() | [
"def",
"rnumlistwithoutreplacement",
"(",
"min",
",",
"max",
")",
":",
"if",
"checkquota",
"(",
")",
"<",
"1",
":",
"raise",
"Exception",
"(",
"\"Your www.random.org quota has already run out.\"",
")",
"requestparam",
"=",
"build_request_parameterNR",
"(",
"min",
",",
"max",
")",
"request",
"=",
"urllib",
".",
"request",
".",
"Request",
"(",
"requestparam",
")",
"request",
".",
"add_header",
"(",
"'User-Agent'",
",",
"'randomwrapy/0.1 very alpha'",
")",
"opener",
"=",
"urllib",
".",
"request",
".",
"build_opener",
"(",
")",
"numlist",
"=",
"opener",
".",
"open",
"(",
"request",
")",
".",
"read",
"(",
")",
"return",
"numlist",
".",
"split",
"(",
")"
] | Returns a randomly ordered list of the integers between min and max | [
"Returns",
"a",
"randomly",
"ordered",
"list",
"of",
"the",
"integers",
"between",
"min",
"and",
"max"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/_internal/randomwrap.py#L54-L63 | train |
Erotemic/utool | utool/_internal/randomwrap.py | rnumlistwithreplacement | def rnumlistwithreplacement(howmany, max, min=0):
"""Returns a list of howmany integers with a maximum value = max.
The minimum value defaults to zero."""
if checkquota() < 1:
raise Exception("Your www.random.org quota has already run out.")
requestparam = build_request_parameterWR(howmany, min, max)
request = urllib.request.Request(requestparam)
request.add_header('User-Agent', 'randomwrapy/0.1 very alpha')
opener = urllib.request.build_opener()
numlist = opener.open(request).read()
return numlist.split() | python | def rnumlistwithreplacement(howmany, max, min=0):
"""Returns a list of howmany integers with a maximum value = max.
The minimum value defaults to zero."""
if checkquota() < 1:
raise Exception("Your www.random.org quota has already run out.")
requestparam = build_request_parameterWR(howmany, min, max)
request = urllib.request.Request(requestparam)
request.add_header('User-Agent', 'randomwrapy/0.1 very alpha')
opener = urllib.request.build_opener()
numlist = opener.open(request).read()
return numlist.split() | [
"def",
"rnumlistwithreplacement",
"(",
"howmany",
",",
"max",
",",
"min",
"=",
"0",
")",
":",
"if",
"checkquota",
"(",
")",
"<",
"1",
":",
"raise",
"Exception",
"(",
"\"Your www.random.org quota has already run out.\"",
")",
"requestparam",
"=",
"build_request_parameterWR",
"(",
"howmany",
",",
"min",
",",
"max",
")",
"request",
"=",
"urllib",
".",
"request",
".",
"Request",
"(",
"requestparam",
")",
"request",
".",
"add_header",
"(",
"'User-Agent'",
",",
"'randomwrapy/0.1 very alpha'",
")",
"opener",
"=",
"urllib",
".",
"request",
".",
"build_opener",
"(",
")",
"numlist",
"=",
"opener",
".",
"open",
"(",
"request",
")",
".",
"read",
"(",
")",
"return",
"numlist",
".",
"split",
"(",
")"
] | Returns a list of howmany integers with a maximum value = max.
The minimum value defaults to zero. | [
"Returns",
"a",
"list",
"of",
"howmany",
"integers",
"with",
"a",
"maximum",
"value",
"=",
"max",
".",
"The",
"minimum",
"value",
"defaults",
"to",
"zero",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/_internal/randomwrap.py#L75-L85 | train |
Erotemic/utool | utool/util_num.py | num_fmt | def num_fmt(num, max_digits=None):
r"""
Weird function. Not very well written. Very special case-y
Args:
num (int or float):
max_digits (int):
Returns:
str:
CommandLine:
python -m utool.util_num --test-num_fmt
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_num import * # NOQA
>>> # build test data
>>> num_list = [0, 0.0, 1.2, 1003232, 41431232., .0000000343, -.443243]
>>> max_digits = None
>>> # execute function
>>> result = [num_fmt(num, max_digits) for num in num_list]
>>> # verify results
>>> print(result)
['0', '0.0', '1.2', '1,003,232', '41431232.0', '0.0', '-0.443']
"""
if num is None:
return 'None'
def num_in_mag(num, mag):
return mag > num and num > (-1 * mag)
if max_digits is None:
# TODO: generalize
if num_in_mag(num, 1):
if num_in_mag(num, .1):
max_digits = 4
else:
max_digits = 3
else:
max_digits = 1
if util_type.is_float(num):
num_str = ('%.' + str(max_digits) + 'f') % num
# Handle trailing and leading zeros
num_str = num_str.rstrip('0').lstrip('0')
if num_str.startswith('.'):
num_str = '0' + num_str
if num_str.endswith('.'):
num_str = num_str + '0'
return num_str
elif util_type.is_int(num):
return int_comma_str(num)
else:
return '%r' | python | def num_fmt(num, max_digits=None):
r"""
Weird function. Not very well written. Very special case-y
Args:
num (int or float):
max_digits (int):
Returns:
str:
CommandLine:
python -m utool.util_num --test-num_fmt
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_num import * # NOQA
>>> # build test data
>>> num_list = [0, 0.0, 1.2, 1003232, 41431232., .0000000343, -.443243]
>>> max_digits = None
>>> # execute function
>>> result = [num_fmt(num, max_digits) for num in num_list]
>>> # verify results
>>> print(result)
['0', '0.0', '1.2', '1,003,232', '41431232.0', '0.0', '-0.443']
"""
if num is None:
return 'None'
def num_in_mag(num, mag):
return mag > num and num > (-1 * mag)
if max_digits is None:
# TODO: generalize
if num_in_mag(num, 1):
if num_in_mag(num, .1):
max_digits = 4
else:
max_digits = 3
else:
max_digits = 1
if util_type.is_float(num):
num_str = ('%.' + str(max_digits) + 'f') % num
# Handle trailing and leading zeros
num_str = num_str.rstrip('0').lstrip('0')
if num_str.startswith('.'):
num_str = '0' + num_str
if num_str.endswith('.'):
num_str = num_str + '0'
return num_str
elif util_type.is_int(num):
return int_comma_str(num)
else:
return '%r' | [
"def",
"num_fmt",
"(",
"num",
",",
"max_digits",
"=",
"None",
")",
":",
"if",
"num",
"is",
"None",
":",
"return",
"'None'",
"def",
"num_in_mag",
"(",
"num",
",",
"mag",
")",
":",
"return",
"mag",
">",
"num",
"and",
"num",
">",
"(",
"-",
"1",
"*",
"mag",
")",
"if",
"max_digits",
"is",
"None",
":",
"# TODO: generalize",
"if",
"num_in_mag",
"(",
"num",
",",
"1",
")",
":",
"if",
"num_in_mag",
"(",
"num",
",",
".1",
")",
":",
"max_digits",
"=",
"4",
"else",
":",
"max_digits",
"=",
"3",
"else",
":",
"max_digits",
"=",
"1",
"if",
"util_type",
".",
"is_float",
"(",
"num",
")",
":",
"num_str",
"=",
"(",
"'%.'",
"+",
"str",
"(",
"max_digits",
")",
"+",
"'f'",
")",
"%",
"num",
"# Handle trailing and leading zeros",
"num_str",
"=",
"num_str",
".",
"rstrip",
"(",
"'0'",
")",
".",
"lstrip",
"(",
"'0'",
")",
"if",
"num_str",
".",
"startswith",
"(",
"'.'",
")",
":",
"num_str",
"=",
"'0'",
"+",
"num_str",
"if",
"num_str",
".",
"endswith",
"(",
"'.'",
")",
":",
"num_str",
"=",
"num_str",
"+",
"'0'",
"return",
"num_str",
"elif",
"util_type",
".",
"is_int",
"(",
"num",
")",
":",
"return",
"int_comma_str",
"(",
"num",
")",
"else",
":",
"return",
"'%r'"
] | r"""
Weird function. Not very well written. Very special case-y
Args:
num (int or float):
max_digits (int):
Returns:
str:
CommandLine:
python -m utool.util_num --test-num_fmt
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_num import * # NOQA
>>> # build test data
>>> num_list = [0, 0.0, 1.2, 1003232, 41431232., .0000000343, -.443243]
>>> max_digits = None
>>> # execute function
>>> result = [num_fmt(num, max_digits) for num in num_list]
>>> # verify results
>>> print(result)
['0', '0.0', '1.2', '1,003,232', '41431232.0', '0.0', '-0.443'] | [
"r",
"Weird",
"function",
".",
"Not",
"very",
"well",
"written",
".",
"Very",
"special",
"case",
"-",
"y"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_num.py#L82-L133 | train |
YuriyGuts/pygoose | pygoose/kg/project.py | Project.load_feature_lists | def load_feature_lists(self, feature_lists):
"""
Load pickled features for train and test sets, assuming they are saved
in the `features` folder along with their column names.
Args:
feature_lists: A list containing the names of the feature lists to load.
Returns:
A tuple containing 3 items: train dataframe, test dataframe,
and a list describing the index ranges for the feature lists.
"""
column_names = []
feature_ranges = []
running_feature_count = 0
for list_id in feature_lists:
feature_list_names = load_lines(self.features_dir + 'X_train_{}.names'.format(list_id))
column_names.extend(feature_list_names)
start_index = running_feature_count
end_index = running_feature_count + len(feature_list_names) - 1
running_feature_count += len(feature_list_names)
feature_ranges.append([list_id, start_index, end_index])
X_train = np.hstack([
load(self.features_dir + 'X_train_{}.pickle'.format(list_id))
for list_id in feature_lists
])
X_test = np.hstack([
load(self.features_dir + 'X_test_{}.pickle'.format(list_id))
for list_id in feature_lists
])
df_train = pd.DataFrame(X_train, columns=column_names)
df_test = pd.DataFrame(X_test, columns=column_names)
return df_train, df_test, feature_ranges | python | def load_feature_lists(self, feature_lists):
"""
Load pickled features for train and test sets, assuming they are saved
in the `features` folder along with their column names.
Args:
feature_lists: A list containing the names of the feature lists to load.
Returns:
A tuple containing 3 items: train dataframe, test dataframe,
and a list describing the index ranges for the feature lists.
"""
column_names = []
feature_ranges = []
running_feature_count = 0
for list_id in feature_lists:
feature_list_names = load_lines(self.features_dir + 'X_train_{}.names'.format(list_id))
column_names.extend(feature_list_names)
start_index = running_feature_count
end_index = running_feature_count + len(feature_list_names) - 1
running_feature_count += len(feature_list_names)
feature_ranges.append([list_id, start_index, end_index])
X_train = np.hstack([
load(self.features_dir + 'X_train_{}.pickle'.format(list_id))
for list_id in feature_lists
])
X_test = np.hstack([
load(self.features_dir + 'X_test_{}.pickle'.format(list_id))
for list_id in feature_lists
])
df_train = pd.DataFrame(X_train, columns=column_names)
df_test = pd.DataFrame(X_test, columns=column_names)
return df_train, df_test, feature_ranges | [
"def",
"load_feature_lists",
"(",
"self",
",",
"feature_lists",
")",
":",
"column_names",
"=",
"[",
"]",
"feature_ranges",
"=",
"[",
"]",
"running_feature_count",
"=",
"0",
"for",
"list_id",
"in",
"feature_lists",
":",
"feature_list_names",
"=",
"load_lines",
"(",
"self",
".",
"features_dir",
"+",
"'X_train_{}.names'",
".",
"format",
"(",
"list_id",
")",
")",
"column_names",
".",
"extend",
"(",
"feature_list_names",
")",
"start_index",
"=",
"running_feature_count",
"end_index",
"=",
"running_feature_count",
"+",
"len",
"(",
"feature_list_names",
")",
"-",
"1",
"running_feature_count",
"+=",
"len",
"(",
"feature_list_names",
")",
"feature_ranges",
".",
"append",
"(",
"[",
"list_id",
",",
"start_index",
",",
"end_index",
"]",
")",
"X_train",
"=",
"np",
".",
"hstack",
"(",
"[",
"load",
"(",
"self",
".",
"features_dir",
"+",
"'X_train_{}.pickle'",
".",
"format",
"(",
"list_id",
")",
")",
"for",
"list_id",
"in",
"feature_lists",
"]",
")",
"X_test",
"=",
"np",
".",
"hstack",
"(",
"[",
"load",
"(",
"self",
".",
"features_dir",
"+",
"'X_test_{}.pickle'",
".",
"format",
"(",
"list_id",
")",
")",
"for",
"list_id",
"in",
"feature_lists",
"]",
")",
"df_train",
"=",
"pd",
".",
"DataFrame",
"(",
"X_train",
",",
"columns",
"=",
"column_names",
")",
"df_test",
"=",
"pd",
".",
"DataFrame",
"(",
"X_test",
",",
"columns",
"=",
"column_names",
")",
"return",
"df_train",
",",
"df_test",
",",
"feature_ranges"
] | Load pickled features for train and test sets, assuming they are saved
in the `features` folder along with their column names.
Args:
feature_lists: A list containing the names of the feature lists to load.
Returns:
A tuple containing 3 items: train dataframe, test dataframe,
and a list describing the index ranges for the feature lists. | [
"Load",
"pickled",
"features",
"for",
"train",
"and",
"test",
"sets",
"assuming",
"they",
"are",
"saved",
"in",
"the",
"features",
"folder",
"along",
"with",
"their",
"column",
"names",
"."
] | 4d9b8827c6d6c4b79949d1cd653393498c0bb3c2 | https://github.com/YuriyGuts/pygoose/blob/4d9b8827c6d6c4b79949d1cd653393498c0bb3c2/pygoose/kg/project.py#L89-L126 | train |
YuriyGuts/pygoose | pygoose/kg/project.py | Project.save_features | def save_features(self, train_features, test_features, feature_names, feature_list_id):
"""
Save features for the training and test sets to disk, along with their metadata.
Args:
train_features: A NumPy array of features for the training set.
test_features: A NumPy array of features for the test set.
feature_names: A list containing the names of the feature columns.
feature_list_id: The name for this feature list.
"""
self.save_feature_names(feature_names, feature_list_id)
self.save_feature_list(train_features, 'train', feature_list_id)
self.save_feature_list(test_features, 'test', feature_list_id) | python | def save_features(self, train_features, test_features, feature_names, feature_list_id):
"""
Save features for the training and test sets to disk, along with their metadata.
Args:
train_features: A NumPy array of features for the training set.
test_features: A NumPy array of features for the test set.
feature_names: A list containing the names of the feature columns.
feature_list_id: The name for this feature list.
"""
self.save_feature_names(feature_names, feature_list_id)
self.save_feature_list(train_features, 'train', feature_list_id)
self.save_feature_list(test_features, 'test', feature_list_id) | [
"def",
"save_features",
"(",
"self",
",",
"train_features",
",",
"test_features",
",",
"feature_names",
",",
"feature_list_id",
")",
":",
"self",
".",
"save_feature_names",
"(",
"feature_names",
",",
"feature_list_id",
")",
"self",
".",
"save_feature_list",
"(",
"train_features",
",",
"'train'",
",",
"feature_list_id",
")",
"self",
".",
"save_feature_list",
"(",
"test_features",
",",
"'test'",
",",
"feature_list_id",
")"
] | Save features for the training and test sets to disk, along with their metadata.
Args:
train_features: A NumPy array of features for the training set.
test_features: A NumPy array of features for the test set.
feature_names: A list containing the names of the feature columns.
feature_list_id: The name for this feature list. | [
"Save",
"features",
"for",
"the",
"training",
"and",
"test",
"sets",
"to",
"disk",
"along",
"with",
"their",
"metadata",
"."
] | 4d9b8827c6d6c4b79949d1cd653393498c0bb3c2 | https://github.com/YuriyGuts/pygoose/blob/4d9b8827c6d6c4b79949d1cd653393498c0bb3c2/pygoose/kg/project.py#L128-L141 | train |
YuriyGuts/pygoose | pygoose/kg/project.py | Project.discover | def discover():
"""
Automatically discover the paths to various data folders in this project
and compose a Project instance.
Returns:
A constructed Project object.
Raises:
ValueError: if the paths could not be figured out automatically.
In this case, you have to create a Project manually using the initializer.
"""
# Try ../data: we're most likely running a Jupyter notebook from the 'notebooks' directory
candidate_path = os.path.abspath(os.path.join(os.curdir, os.pardir, 'data'))
if os.path.exists(candidate_path):
return Project(os.path.abspath(os.path.join(candidate_path, os.pardir)))
# Try ./data
candidate_path = os.path.abspath(os.path.join(os.curdir, 'data'))
if os.path.exists(candidate_path):
return Project(os.path.abspath(os.curdir))
# Try ../../data
candidate_path = os.path.abspath(os.path.join(os.curdir, os.pardir, 'data'))
if os.path.exists(candidate_path):
return Project(os.path.abspath(os.path.join(candidate_path, os.pardir, os.pardir)))
# Out of ideas at this point.
raise ValueError('Cannot discover the structure of the project. Make sure that the data directory exists') | python | def discover():
"""
Automatically discover the paths to various data folders in this project
and compose a Project instance.
Returns:
A constructed Project object.
Raises:
ValueError: if the paths could not be figured out automatically.
In this case, you have to create a Project manually using the initializer.
"""
# Try ../data: we're most likely running a Jupyter notebook from the 'notebooks' directory
candidate_path = os.path.abspath(os.path.join(os.curdir, os.pardir, 'data'))
if os.path.exists(candidate_path):
return Project(os.path.abspath(os.path.join(candidate_path, os.pardir)))
# Try ./data
candidate_path = os.path.abspath(os.path.join(os.curdir, 'data'))
if os.path.exists(candidate_path):
return Project(os.path.abspath(os.curdir))
# Try ../../data
candidate_path = os.path.abspath(os.path.join(os.curdir, os.pardir, 'data'))
if os.path.exists(candidate_path):
return Project(os.path.abspath(os.path.join(candidate_path, os.pardir, os.pardir)))
# Out of ideas at this point.
raise ValueError('Cannot discover the structure of the project. Make sure that the data directory exists') | [
"def",
"discover",
"(",
")",
":",
"# Try ../data: we're most likely running a Jupyter notebook from the 'notebooks' directory",
"candidate_path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"curdir",
",",
"os",
".",
"pardir",
",",
"'data'",
")",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"candidate_path",
")",
":",
"return",
"Project",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"join",
"(",
"candidate_path",
",",
"os",
".",
"pardir",
")",
")",
")",
"# Try ./data",
"candidate_path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"curdir",
",",
"'data'",
")",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"candidate_path",
")",
":",
"return",
"Project",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"curdir",
")",
")",
"# Try ../../data",
"candidate_path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"curdir",
",",
"os",
".",
"pardir",
",",
"'data'",
")",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"candidate_path",
")",
":",
"return",
"Project",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"join",
"(",
"candidate_path",
",",
"os",
".",
"pardir",
",",
"os",
".",
"pardir",
")",
")",
")",
"# Out of ideas at this point.",
"raise",
"ValueError",
"(",
"'Cannot discover the structure of the project. Make sure that the data directory exists'",
")"
] | Automatically discover the paths to various data folders in this project
and compose a Project instance.
Returns:
A constructed Project object.
Raises:
ValueError: if the paths could not be figured out automatically.
In this case, you have to create a Project manually using the initializer. | [
"Automatically",
"discover",
"the",
"paths",
"to",
"various",
"data",
"folders",
"in",
"this",
"project",
"and",
"compose",
"a",
"Project",
"instance",
"."
] | 4d9b8827c6d6c4b79949d1cd653393498c0bb3c2 | https://github.com/YuriyGuts/pygoose/blob/4d9b8827c6d6c4b79949d1cd653393498c0bb3c2/pygoose/kg/project.py#L170-L199 | train |
YuriyGuts/pygoose | pygoose/kg/project.py | Project.init | def init():
"""
Creates the project infrastructure assuming the current directory is the project root.
Typically used as a command-line entry point called by `pygoose init`.
"""
project = Project(os.path.abspath(os.getcwd()))
paths_to_create = [
project.data_dir,
project.notebooks_dir,
project.aux_dir,
project.features_dir,
project.preprocessed_data_dir,
project.submissions_dir,
project.trained_model_dir,
project.temp_dir,
]
for path in paths_to_create:
os.makedirs(path, exist_ok=True) | python | def init():
"""
Creates the project infrastructure assuming the current directory is the project root.
Typically used as a command-line entry point called by `pygoose init`.
"""
project = Project(os.path.abspath(os.getcwd()))
paths_to_create = [
project.data_dir,
project.notebooks_dir,
project.aux_dir,
project.features_dir,
project.preprocessed_data_dir,
project.submissions_dir,
project.trained_model_dir,
project.temp_dir,
]
for path in paths_to_create:
os.makedirs(path, exist_ok=True) | [
"def",
"init",
"(",
")",
":",
"project",
"=",
"Project",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"getcwd",
"(",
")",
")",
")",
"paths_to_create",
"=",
"[",
"project",
".",
"data_dir",
",",
"project",
".",
"notebooks_dir",
",",
"project",
".",
"aux_dir",
",",
"project",
".",
"features_dir",
",",
"project",
".",
"preprocessed_data_dir",
",",
"project",
".",
"submissions_dir",
",",
"project",
".",
"trained_model_dir",
",",
"project",
".",
"temp_dir",
",",
"]",
"for",
"path",
"in",
"paths_to_create",
":",
"os",
".",
"makedirs",
"(",
"path",
",",
"exist_ok",
"=",
"True",
")"
] | Creates the project infrastructure assuming the current directory is the project root.
Typically used as a command-line entry point called by `pygoose init`. | [
"Creates",
"the",
"project",
"infrastructure",
"assuming",
"the",
"current",
"directory",
"is",
"the",
"project",
"root",
".",
"Typically",
"used",
"as",
"a",
"command",
"-",
"line",
"entry",
"point",
"called",
"by",
"pygoose",
"init",
"."
] | 4d9b8827c6d6c4b79949d1cd653393498c0bb3c2 | https://github.com/YuriyGuts/pygoose/blob/4d9b8827c6d6c4b79949d1cd653393498c0bb3c2/pygoose/kg/project.py#L202-L221 | train |
tmr232/awesomelib | awesome/iterator.py | unique_justseen | def unique_justseen(iterable, key=None):
"List unique elements, preserving order. Remember only the element just seen."
# unique_justseen('AAAABBBCCDAABBB') --> A B C D A B
# unique_justseen('ABBCcAD', str.lower) --> A B C A D
return imap(next, imap(operator.itemgetter(1), groupby(iterable, key))) | python | def unique_justseen(iterable, key=None):
"List unique elements, preserving order. Remember only the element just seen."
# unique_justseen('AAAABBBCCDAABBB') --> A B C D A B
# unique_justseen('ABBCcAD', str.lower) --> A B C A D
return imap(next, imap(operator.itemgetter(1), groupby(iterable, key))) | [
"def",
"unique_justseen",
"(",
"iterable",
",",
"key",
"=",
"None",
")",
":",
"# unique_justseen('AAAABBBCCDAABBB') --> A B C D A B",
"# unique_justseen('ABBCcAD', str.lower) --> A B C A D",
"return",
"imap",
"(",
"next",
",",
"imap",
"(",
"operator",
".",
"itemgetter",
"(",
"1",
")",
",",
"groupby",
"(",
"iterable",
",",
"key",
")",
")",
")"
] | List unique elements, preserving order. Remember only the element just seen. | [
"List",
"unique",
"elements",
"preserving",
"order",
".",
"Remember",
"only",
"the",
"element",
"just",
"seen",
"."
] | 69a63466a63679f9e2abac8a719853a5e527219c | https://github.com/tmr232/awesomelib/blob/69a63466a63679f9e2abac8a719853a5e527219c/awesome/iterator.py#L122-L126 | train |
Erotemic/utool | utool/util_inject.py | _get_module | def _get_module(module_name=None, module=None, register=True):
""" finds module in sys.modules based on module name unless the module has
already been found and is passed in """
if module is None and module_name is not None:
try:
module = sys.modules[module_name]
except KeyError as ex:
print(ex)
raise KeyError(('module_name=%r must be loaded before ' +
'receiving injections') % module_name)
elif module is not None and module_name is None:
pass
else:
raise ValueError('module_name or module must be exclusively specified')
if register is True:
_add_injected_module(module)
return module | python | def _get_module(module_name=None, module=None, register=True):
""" finds module in sys.modules based on module name unless the module has
already been found and is passed in """
if module is None and module_name is not None:
try:
module = sys.modules[module_name]
except KeyError as ex:
print(ex)
raise KeyError(('module_name=%r must be loaded before ' +
'receiving injections') % module_name)
elif module is not None and module_name is None:
pass
else:
raise ValueError('module_name or module must be exclusively specified')
if register is True:
_add_injected_module(module)
return module | [
"def",
"_get_module",
"(",
"module_name",
"=",
"None",
",",
"module",
"=",
"None",
",",
"register",
"=",
"True",
")",
":",
"if",
"module",
"is",
"None",
"and",
"module_name",
"is",
"not",
"None",
":",
"try",
":",
"module",
"=",
"sys",
".",
"modules",
"[",
"module_name",
"]",
"except",
"KeyError",
"as",
"ex",
":",
"print",
"(",
"ex",
")",
"raise",
"KeyError",
"(",
"(",
"'module_name=%r must be loaded before '",
"+",
"'receiving injections'",
")",
"%",
"module_name",
")",
"elif",
"module",
"is",
"not",
"None",
"and",
"module_name",
"is",
"None",
":",
"pass",
"else",
":",
"raise",
"ValueError",
"(",
"'module_name or module must be exclusively specified'",
")",
"if",
"register",
"is",
"True",
":",
"_add_injected_module",
"(",
"module",
")",
"return",
"module"
] | finds module in sys.modules based on module name unless the module has
already been found and is passed in | [
"finds",
"module",
"in",
"sys",
".",
"modules",
"based",
"on",
"module",
"name",
"unless",
"the",
"module",
"has",
"already",
"been",
"found",
"and",
"is",
"passed",
"in"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L86-L102 | train |
Erotemic/utool | utool/util_inject.py | inject_colored_exceptions | def inject_colored_exceptions():
"""
Causes exceptions to be colored if not already
Hooks into sys.excepthook
CommandLine:
python -m utool.util_inject --test-inject_colored_exceptions
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_inject import * # NOQA
>>> print('sys.excepthook = %r ' % (sys.excepthook,))
>>> #assert sys.excepthook is colored_pygments_excepthook, 'bad excepthook'
>>> raise Exception('should be in color')
"""
#COLORED_INJECTS = '--nocolorex' not in sys.argv
#COLORED_INJECTS = '--colorex' in sys.argv
# Ignore colored exceptions on win32
if VERBOSE:
print('[inject] injecting colored exceptions')
if not sys.platform.startswith('win32'):
if VERYVERBOSE:
print('[inject] injecting colored exceptions')
if '--noinject-color' in sys.argv:
print('Not injecting color')
else:
sys.excepthook = colored_pygments_excepthook
else:
if VERYVERBOSE:
print('[inject] cannot inject colored exceptions') | python | def inject_colored_exceptions():
"""
Causes exceptions to be colored if not already
Hooks into sys.excepthook
CommandLine:
python -m utool.util_inject --test-inject_colored_exceptions
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_inject import * # NOQA
>>> print('sys.excepthook = %r ' % (sys.excepthook,))
>>> #assert sys.excepthook is colored_pygments_excepthook, 'bad excepthook'
>>> raise Exception('should be in color')
"""
#COLORED_INJECTS = '--nocolorex' not in sys.argv
#COLORED_INJECTS = '--colorex' in sys.argv
# Ignore colored exceptions on win32
if VERBOSE:
print('[inject] injecting colored exceptions')
if not sys.platform.startswith('win32'):
if VERYVERBOSE:
print('[inject] injecting colored exceptions')
if '--noinject-color' in sys.argv:
print('Not injecting color')
else:
sys.excepthook = colored_pygments_excepthook
else:
if VERYVERBOSE:
print('[inject] cannot inject colored exceptions') | [
"def",
"inject_colored_exceptions",
"(",
")",
":",
"#COLORED_INJECTS = '--nocolorex' not in sys.argv",
"#COLORED_INJECTS = '--colorex' in sys.argv",
"# Ignore colored exceptions on win32",
"if",
"VERBOSE",
":",
"print",
"(",
"'[inject] injecting colored exceptions'",
")",
"if",
"not",
"sys",
".",
"platform",
".",
"startswith",
"(",
"'win32'",
")",
":",
"if",
"VERYVERBOSE",
":",
"print",
"(",
"'[inject] injecting colored exceptions'",
")",
"if",
"'--noinject-color'",
"in",
"sys",
".",
"argv",
":",
"print",
"(",
"'Not injecting color'",
")",
"else",
":",
"sys",
".",
"excepthook",
"=",
"colored_pygments_excepthook",
"else",
":",
"if",
"VERYVERBOSE",
":",
"print",
"(",
"'[inject] cannot inject colored exceptions'",
")"
] | Causes exceptions to be colored if not already
Hooks into sys.excepthook
CommandLine:
python -m utool.util_inject --test-inject_colored_exceptions
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_inject import * # NOQA
>>> print('sys.excepthook = %r ' % (sys.excepthook,))
>>> #assert sys.excepthook is colored_pygments_excepthook, 'bad excepthook'
>>> raise Exception('should be in color') | [
"Causes",
"exceptions",
"to",
"be",
"colored",
"if",
"not",
"already"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L135-L166 | train |
Erotemic/utool | utool/util_inject.py | inject_print_functions | def inject_print_functions(module_name=None, module_prefix='[???]',
DEBUG=False, module=None):
"""
makes print functions to be injected into the module
"""
module = _get_module(module_name, module)
if SILENT:
def print(*args):
""" silent builtins.print """
pass
def printDBG(*args):
""" silent debug print """
pass
def print_(*args):
""" silent stdout.write """
pass
else:
if DEBUG_PRINT:
# Turns on printing where a message came from
def print(*args):
""" debugging logging builtins.print """
from utool._internal.meta_util_dbg import get_caller_name
calltag = ''.join(('[caller:', get_caller_name(N=DEBUG_PRINT_N), ']' ))
util_logging._utool_print()(calltag, *args)
else:
def print(*args):
""" logging builtins.print """
util_logging._utool_print()(*args)
if __AGGROFLUSH__:
def print_(*args):
""" aggressive logging stdout.write """
util_logging._utool_write()(*args)
util_logging._utool_flush()()
else:
def print_(*args):
""" logging stdout.write """
util_logging._utool_write()(*args)
# turn on module debugging with command line flags
dotpos = module.__name__.rfind('.')
if dotpos == -1:
module_name = module.__name__
else:
module_name = module.__name__[dotpos + 1:]
def _replchars(str_):
return str_.replace('_', '-').replace(']', '').replace('[', '')
flag1 = '--debug-%s' % _replchars(module_name)
flag2 = '--debug-%s' % _replchars(module_prefix)
DEBUG_FLAG = any([flag in sys.argv for flag in [flag1, flag2]])
for curflag in ARGV_DEBUG_FLAGS:
if curflag in module_prefix:
DEBUG_FLAG = True
if __DEBUG_ALL__ or DEBUG or DEBUG_FLAG:
print('INJECT_PRINT: %r == %r' % (module_name, module_prefix))
def printDBG(*args):
""" debug logging print """
msg = ', '.join(map(str, args))
util_logging.__UTOOL_PRINTDBG__(module_prefix + ' DEBUG ' + msg)
else:
def printDBG(*args):
""" silent debug logging print """
pass
#_inject_funcs(module, print, print_, printDBG)
print_funcs = (print, print_, printDBG)
return print_funcs | python | def inject_print_functions(module_name=None, module_prefix='[???]',
DEBUG=False, module=None):
"""
makes print functions to be injected into the module
"""
module = _get_module(module_name, module)
if SILENT:
def print(*args):
""" silent builtins.print """
pass
def printDBG(*args):
""" silent debug print """
pass
def print_(*args):
""" silent stdout.write """
pass
else:
if DEBUG_PRINT:
# Turns on printing where a message came from
def print(*args):
""" debugging logging builtins.print """
from utool._internal.meta_util_dbg import get_caller_name
calltag = ''.join(('[caller:', get_caller_name(N=DEBUG_PRINT_N), ']' ))
util_logging._utool_print()(calltag, *args)
else:
def print(*args):
""" logging builtins.print """
util_logging._utool_print()(*args)
if __AGGROFLUSH__:
def print_(*args):
""" aggressive logging stdout.write """
util_logging._utool_write()(*args)
util_logging._utool_flush()()
else:
def print_(*args):
""" logging stdout.write """
util_logging._utool_write()(*args)
# turn on module debugging with command line flags
dotpos = module.__name__.rfind('.')
if dotpos == -1:
module_name = module.__name__
else:
module_name = module.__name__[dotpos + 1:]
def _replchars(str_):
return str_.replace('_', '-').replace(']', '').replace('[', '')
flag1 = '--debug-%s' % _replchars(module_name)
flag2 = '--debug-%s' % _replchars(module_prefix)
DEBUG_FLAG = any([flag in sys.argv for flag in [flag1, flag2]])
for curflag in ARGV_DEBUG_FLAGS:
if curflag in module_prefix:
DEBUG_FLAG = True
if __DEBUG_ALL__ or DEBUG or DEBUG_FLAG:
print('INJECT_PRINT: %r == %r' % (module_name, module_prefix))
def printDBG(*args):
""" debug logging print """
msg = ', '.join(map(str, args))
util_logging.__UTOOL_PRINTDBG__(module_prefix + ' DEBUG ' + msg)
else:
def printDBG(*args):
""" silent debug logging print """
pass
#_inject_funcs(module, print, print_, printDBG)
print_funcs = (print, print_, printDBG)
return print_funcs | [
"def",
"inject_print_functions",
"(",
"module_name",
"=",
"None",
",",
"module_prefix",
"=",
"'[???]'",
",",
"DEBUG",
"=",
"False",
",",
"module",
"=",
"None",
")",
":",
"module",
"=",
"_get_module",
"(",
"module_name",
",",
"module",
")",
"if",
"SILENT",
":",
"def",
"print",
"(",
"*",
"args",
")",
":",
"\"\"\" silent builtins.print \"\"\"",
"pass",
"def",
"printDBG",
"(",
"*",
"args",
")",
":",
"\"\"\" silent debug print \"\"\"",
"pass",
"def",
"print_",
"(",
"*",
"args",
")",
":",
"\"\"\" silent stdout.write \"\"\"",
"pass",
"else",
":",
"if",
"DEBUG_PRINT",
":",
"# Turns on printing where a message came from",
"def",
"print",
"(",
"*",
"args",
")",
":",
"\"\"\" debugging logging builtins.print \"\"\"",
"from",
"utool",
".",
"_internal",
".",
"meta_util_dbg",
"import",
"get_caller_name",
"calltag",
"=",
"''",
".",
"join",
"(",
"(",
"'[caller:'",
",",
"get_caller_name",
"(",
"N",
"=",
"DEBUG_PRINT_N",
")",
",",
"']'",
")",
")",
"util_logging",
".",
"_utool_print",
"(",
")",
"(",
"calltag",
",",
"*",
"args",
")",
"else",
":",
"def",
"print",
"(",
"*",
"args",
")",
":",
"\"\"\" logging builtins.print \"\"\"",
"util_logging",
".",
"_utool_print",
"(",
")",
"(",
"*",
"args",
")",
"if",
"__AGGROFLUSH__",
":",
"def",
"print_",
"(",
"*",
"args",
")",
":",
"\"\"\" aggressive logging stdout.write \"\"\"",
"util_logging",
".",
"_utool_write",
"(",
")",
"(",
"*",
"args",
")",
"util_logging",
".",
"_utool_flush",
"(",
")",
"(",
")",
"else",
":",
"def",
"print_",
"(",
"*",
"args",
")",
":",
"\"\"\" logging stdout.write \"\"\"",
"util_logging",
".",
"_utool_write",
"(",
")",
"(",
"*",
"args",
")",
"# turn on module debugging with command line flags",
"dotpos",
"=",
"module",
".",
"__name__",
".",
"rfind",
"(",
"'.'",
")",
"if",
"dotpos",
"==",
"-",
"1",
":",
"module_name",
"=",
"module",
".",
"__name__",
"else",
":",
"module_name",
"=",
"module",
".",
"__name__",
"[",
"dotpos",
"+",
"1",
":",
"]",
"def",
"_replchars",
"(",
"str_",
")",
":",
"return",
"str_",
".",
"replace",
"(",
"'_'",
",",
"'-'",
")",
".",
"replace",
"(",
"']'",
",",
"''",
")",
".",
"replace",
"(",
"'['",
",",
"''",
")",
"flag1",
"=",
"'--debug-%s'",
"%",
"_replchars",
"(",
"module_name",
")",
"flag2",
"=",
"'--debug-%s'",
"%",
"_replchars",
"(",
"module_prefix",
")",
"DEBUG_FLAG",
"=",
"any",
"(",
"[",
"flag",
"in",
"sys",
".",
"argv",
"for",
"flag",
"in",
"[",
"flag1",
",",
"flag2",
"]",
"]",
")",
"for",
"curflag",
"in",
"ARGV_DEBUG_FLAGS",
":",
"if",
"curflag",
"in",
"module_prefix",
":",
"DEBUG_FLAG",
"=",
"True",
"if",
"__DEBUG_ALL__",
"or",
"DEBUG",
"or",
"DEBUG_FLAG",
":",
"print",
"(",
"'INJECT_PRINT: %r == %r'",
"%",
"(",
"module_name",
",",
"module_prefix",
")",
")",
"def",
"printDBG",
"(",
"*",
"args",
")",
":",
"\"\"\" debug logging print \"\"\"",
"msg",
"=",
"', '",
".",
"join",
"(",
"map",
"(",
"str",
",",
"args",
")",
")",
"util_logging",
".",
"__UTOOL_PRINTDBG__",
"(",
"module_prefix",
"+",
"' DEBUG '",
"+",
"msg",
")",
"else",
":",
"def",
"printDBG",
"(",
"*",
"args",
")",
":",
"\"\"\" silent debug logging print \"\"\"",
"pass",
"#_inject_funcs(module, print, print_, printDBG)",
"print_funcs",
"=",
"(",
"print",
",",
"print_",
",",
"printDBG",
")",
"return",
"print_funcs"
] | makes print functions to be injected into the module | [
"makes",
"print",
"functions",
"to",
"be",
"injected",
"into",
"the",
"module"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L207-L272 | train |
Erotemic/utool | utool/util_inject.py | make_module_reload_func | def make_module_reload_func(module_name=None, module_prefix='[???]', module=None):
""" Injects dynamic module reloading """
module = _get_module(module_name, module, register=False)
if module_name is None:
module_name = str(module.__name__)
def rrr(verbose=True):
""" Dynamic module reloading """
if not __RELOAD_OK__:
raise Exception('Reloading has been forced off')
try:
import imp
if verbose and not QUIET:
builtins.print('RELOAD: ' + str(module_prefix) + ' __name__=' + module_name)
imp.reload(module)
except Exception as ex:
print(ex)
print('%s Failed to reload' % module_prefix)
raise
# this doesn't seem to set anything on import *
#_inject_funcs(module, rrr)
return rrr | python | def make_module_reload_func(module_name=None, module_prefix='[???]', module=None):
""" Injects dynamic module reloading """
module = _get_module(module_name, module, register=False)
if module_name is None:
module_name = str(module.__name__)
def rrr(verbose=True):
""" Dynamic module reloading """
if not __RELOAD_OK__:
raise Exception('Reloading has been forced off')
try:
import imp
if verbose and not QUIET:
builtins.print('RELOAD: ' + str(module_prefix) + ' __name__=' + module_name)
imp.reload(module)
except Exception as ex:
print(ex)
print('%s Failed to reload' % module_prefix)
raise
# this doesn't seem to set anything on import *
#_inject_funcs(module, rrr)
return rrr | [
"def",
"make_module_reload_func",
"(",
"module_name",
"=",
"None",
",",
"module_prefix",
"=",
"'[???]'",
",",
"module",
"=",
"None",
")",
":",
"module",
"=",
"_get_module",
"(",
"module_name",
",",
"module",
",",
"register",
"=",
"False",
")",
"if",
"module_name",
"is",
"None",
":",
"module_name",
"=",
"str",
"(",
"module",
".",
"__name__",
")",
"def",
"rrr",
"(",
"verbose",
"=",
"True",
")",
":",
"\"\"\" Dynamic module reloading \"\"\"",
"if",
"not",
"__RELOAD_OK__",
":",
"raise",
"Exception",
"(",
"'Reloading has been forced off'",
")",
"try",
":",
"import",
"imp",
"if",
"verbose",
"and",
"not",
"QUIET",
":",
"builtins",
".",
"print",
"(",
"'RELOAD: '",
"+",
"str",
"(",
"module_prefix",
")",
"+",
"' __name__='",
"+",
"module_name",
")",
"imp",
".",
"reload",
"(",
"module",
")",
"except",
"Exception",
"as",
"ex",
":",
"print",
"(",
"ex",
")",
"print",
"(",
"'%s Failed to reload'",
"%",
"module_prefix",
")",
"raise",
"# this doesn't seem to set anything on import *",
"#_inject_funcs(module, rrr)",
"return",
"rrr"
] | Injects dynamic module reloading | [
"Injects",
"dynamic",
"module",
"reloading"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L298-L318 | train |
Erotemic/utool | utool/util_inject.py | noinject | def noinject(module_name=None, module_prefix='[???]', DEBUG=False, module=None, N=0, via=None):
"""
Use in modules that do not have inject in them
Does not inject anything into the module. Just lets utool know that a module
is being imported so the import order can be debuged
"""
if PRINT_INJECT_ORDER:
from utool._internal import meta_util_dbg
callername = meta_util_dbg.get_caller_name(N=N + 1, strict=False)
lineno = meta_util_dbg.get_caller_lineno(N=N + 1, strict=False)
suff = ' via %s' % (via,) if via else ''
fmtdict = dict(N=N, lineno=lineno, callername=callername,
modname=module_name, suff=suff)
msg = '[util_inject] N={N} {modname} is imported by {callername} at lineno={lineno}{suff}'.format(**fmtdict)
if DEBUG_SLOW_IMPORT:
global PREV_MODNAME
seconds = tt.toc()
import_times[(PREV_MODNAME, module_name)] = seconds
PREV_MODNAME = module_name
builtins.print(msg)
if DEBUG_SLOW_IMPORT:
tt.tic()
# builtins.print(elapsed)
if EXIT_ON_INJECT_MODNAME == module_name:
builtins.print('...exiting')
assert False, 'exit in inject requested' | python | def noinject(module_name=None, module_prefix='[???]', DEBUG=False, module=None, N=0, via=None):
"""
Use in modules that do not have inject in them
Does not inject anything into the module. Just lets utool know that a module
is being imported so the import order can be debuged
"""
if PRINT_INJECT_ORDER:
from utool._internal import meta_util_dbg
callername = meta_util_dbg.get_caller_name(N=N + 1, strict=False)
lineno = meta_util_dbg.get_caller_lineno(N=N + 1, strict=False)
suff = ' via %s' % (via,) if via else ''
fmtdict = dict(N=N, lineno=lineno, callername=callername,
modname=module_name, suff=suff)
msg = '[util_inject] N={N} {modname} is imported by {callername} at lineno={lineno}{suff}'.format(**fmtdict)
if DEBUG_SLOW_IMPORT:
global PREV_MODNAME
seconds = tt.toc()
import_times[(PREV_MODNAME, module_name)] = seconds
PREV_MODNAME = module_name
builtins.print(msg)
if DEBUG_SLOW_IMPORT:
tt.tic()
# builtins.print(elapsed)
if EXIT_ON_INJECT_MODNAME == module_name:
builtins.print('...exiting')
assert False, 'exit in inject requested' | [
"def",
"noinject",
"(",
"module_name",
"=",
"None",
",",
"module_prefix",
"=",
"'[???]'",
",",
"DEBUG",
"=",
"False",
",",
"module",
"=",
"None",
",",
"N",
"=",
"0",
",",
"via",
"=",
"None",
")",
":",
"if",
"PRINT_INJECT_ORDER",
":",
"from",
"utool",
".",
"_internal",
"import",
"meta_util_dbg",
"callername",
"=",
"meta_util_dbg",
".",
"get_caller_name",
"(",
"N",
"=",
"N",
"+",
"1",
",",
"strict",
"=",
"False",
")",
"lineno",
"=",
"meta_util_dbg",
".",
"get_caller_lineno",
"(",
"N",
"=",
"N",
"+",
"1",
",",
"strict",
"=",
"False",
")",
"suff",
"=",
"' via %s'",
"%",
"(",
"via",
",",
")",
"if",
"via",
"else",
"''",
"fmtdict",
"=",
"dict",
"(",
"N",
"=",
"N",
",",
"lineno",
"=",
"lineno",
",",
"callername",
"=",
"callername",
",",
"modname",
"=",
"module_name",
",",
"suff",
"=",
"suff",
")",
"msg",
"=",
"'[util_inject] N={N} {modname} is imported by {callername} at lineno={lineno}{suff}'",
".",
"format",
"(",
"*",
"*",
"fmtdict",
")",
"if",
"DEBUG_SLOW_IMPORT",
":",
"global",
"PREV_MODNAME",
"seconds",
"=",
"tt",
".",
"toc",
"(",
")",
"import_times",
"[",
"(",
"PREV_MODNAME",
",",
"module_name",
")",
"]",
"=",
"seconds",
"PREV_MODNAME",
"=",
"module_name",
"builtins",
".",
"print",
"(",
"msg",
")",
"if",
"DEBUG_SLOW_IMPORT",
":",
"tt",
".",
"tic",
"(",
")",
"# builtins.print(elapsed)",
"if",
"EXIT_ON_INJECT_MODNAME",
"==",
"module_name",
":",
"builtins",
".",
"print",
"(",
"'...exiting'",
")",
"assert",
"False",
",",
"'exit in inject requested'"
] | Use in modules that do not have inject in them
Does not inject anything into the module. Just lets utool know that a module
is being imported so the import order can be debuged | [
"Use",
"in",
"modules",
"that",
"do",
"not",
"have",
"inject",
"in",
"them"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L441-L470 | train |
Erotemic/utool | utool/util_inject.py | inject | def inject(module_name=None, module_prefix='[???]', DEBUG=False, module=None, N=1):
"""
Injects your module with utool magic
Utool magic is not actually magic. It just turns your ``print`` statments into
logging statments, allows for your module to be used with the utool.Indent
context manager and the and utool.indent_func decorator. ``printDBG`` will soon
be deprecated as will ``print_``. The function rrr is a developer convinience for
reloading the module dynamically durring runtime. The profile decorator is
a no-op if not using kernprof.py, otherwise it is kernprof.py's profile
decorator.
Args:
module_name (str): the __name__ varaible in your module
module_prefix (str): a user defined module prefix
DEBUG (bool):
module (None): the actual module (optional)
Returns:
tuple : (print, print_, printDBG, rrr, profile_)
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_inject import * # NOQA
>>> from __future__ import absolute_import, division, print_function, unicode_literals
>>> from util.util_inject import inject
>>> print, rrr, profile = inject2(__name__, '[mod]')
"""
#noinject(module_name, module_prefix, DEBUG, module, N=1)
noinject(module_name, module_prefix, DEBUG, module, N=N)
module = _get_module(module_name, module)
rrr = make_module_reload_func(None, module_prefix, module)
profile_ = make_module_profile_func(None, module_prefix, module)
print_funcs = inject_print_functions(None, module_prefix, DEBUG, module)
(print, print_, printDBG) = print_funcs
return (print, print_, printDBG, rrr, profile_) | python | def inject(module_name=None, module_prefix='[???]', DEBUG=False, module=None, N=1):
"""
Injects your module with utool magic
Utool magic is not actually magic. It just turns your ``print`` statments into
logging statments, allows for your module to be used with the utool.Indent
context manager and the and utool.indent_func decorator. ``printDBG`` will soon
be deprecated as will ``print_``. The function rrr is a developer convinience for
reloading the module dynamically durring runtime. The profile decorator is
a no-op if not using kernprof.py, otherwise it is kernprof.py's profile
decorator.
Args:
module_name (str): the __name__ varaible in your module
module_prefix (str): a user defined module prefix
DEBUG (bool):
module (None): the actual module (optional)
Returns:
tuple : (print, print_, printDBG, rrr, profile_)
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_inject import * # NOQA
>>> from __future__ import absolute_import, division, print_function, unicode_literals
>>> from util.util_inject import inject
>>> print, rrr, profile = inject2(__name__, '[mod]')
"""
#noinject(module_name, module_prefix, DEBUG, module, N=1)
noinject(module_name, module_prefix, DEBUG, module, N=N)
module = _get_module(module_name, module)
rrr = make_module_reload_func(None, module_prefix, module)
profile_ = make_module_profile_func(None, module_prefix, module)
print_funcs = inject_print_functions(None, module_prefix, DEBUG, module)
(print, print_, printDBG) = print_funcs
return (print, print_, printDBG, rrr, profile_) | [
"def",
"inject",
"(",
"module_name",
"=",
"None",
",",
"module_prefix",
"=",
"'[???]'",
",",
"DEBUG",
"=",
"False",
",",
"module",
"=",
"None",
",",
"N",
"=",
"1",
")",
":",
"#noinject(module_name, module_prefix, DEBUG, module, N=1)",
"noinject",
"(",
"module_name",
",",
"module_prefix",
",",
"DEBUG",
",",
"module",
",",
"N",
"=",
"N",
")",
"module",
"=",
"_get_module",
"(",
"module_name",
",",
"module",
")",
"rrr",
"=",
"make_module_reload_func",
"(",
"None",
",",
"module_prefix",
",",
"module",
")",
"profile_",
"=",
"make_module_profile_func",
"(",
"None",
",",
"module_prefix",
",",
"module",
")",
"print_funcs",
"=",
"inject_print_functions",
"(",
"None",
",",
"module_prefix",
",",
"DEBUG",
",",
"module",
")",
"(",
"print",
",",
"print_",
",",
"printDBG",
")",
"=",
"print_funcs",
"return",
"(",
"print",
",",
"print_",
",",
"printDBG",
",",
"rrr",
",",
"profile_",
")"
] | Injects your module with utool magic
Utool magic is not actually magic. It just turns your ``print`` statments into
logging statments, allows for your module to be used with the utool.Indent
context manager and the and utool.indent_func decorator. ``printDBG`` will soon
be deprecated as will ``print_``. The function rrr is a developer convinience for
reloading the module dynamically durring runtime. The profile decorator is
a no-op if not using kernprof.py, otherwise it is kernprof.py's profile
decorator.
Args:
module_name (str): the __name__ varaible in your module
module_prefix (str): a user defined module prefix
DEBUG (bool):
module (None): the actual module (optional)
Returns:
tuple : (print, print_, printDBG, rrr, profile_)
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_inject import * # NOQA
>>> from __future__ import absolute_import, division, print_function, unicode_literals
>>> from util.util_inject import inject
>>> print, rrr, profile = inject2(__name__, '[mod]') | [
"Injects",
"your",
"module",
"with",
"utool",
"magic"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L473-L508 | train |
Erotemic/utool | utool/util_inject.py | inject2 | def inject2(module_name=None, module_prefix=None, DEBUG=False, module=None, N=1):
""" wrapper that depricates print_ and printDBG """
if module_prefix is None:
module_prefix = '[%s]' % (module_name,)
noinject(module_name, module_prefix, DEBUG, module, N=N)
module = _get_module(module_name, module)
rrr = make_module_reload_func(None, module_prefix, module)
profile_ = make_module_profile_func(None, module_prefix, module)
print = make_module_print_func(module)
return print, rrr, profile_ | python | def inject2(module_name=None, module_prefix=None, DEBUG=False, module=None, N=1):
""" wrapper that depricates print_ and printDBG """
if module_prefix is None:
module_prefix = '[%s]' % (module_name,)
noinject(module_name, module_prefix, DEBUG, module, N=N)
module = _get_module(module_name, module)
rrr = make_module_reload_func(None, module_prefix, module)
profile_ = make_module_profile_func(None, module_prefix, module)
print = make_module_print_func(module)
return print, rrr, profile_ | [
"def",
"inject2",
"(",
"module_name",
"=",
"None",
",",
"module_prefix",
"=",
"None",
",",
"DEBUG",
"=",
"False",
",",
"module",
"=",
"None",
",",
"N",
"=",
"1",
")",
":",
"if",
"module_prefix",
"is",
"None",
":",
"module_prefix",
"=",
"'[%s]'",
"%",
"(",
"module_name",
",",
")",
"noinject",
"(",
"module_name",
",",
"module_prefix",
",",
"DEBUG",
",",
"module",
",",
"N",
"=",
"N",
")",
"module",
"=",
"_get_module",
"(",
"module_name",
",",
"module",
")",
"rrr",
"=",
"make_module_reload_func",
"(",
"None",
",",
"module_prefix",
",",
"module",
")",
"profile_",
"=",
"make_module_profile_func",
"(",
"None",
",",
"module_prefix",
",",
"module",
")",
"print",
"=",
"make_module_print_func",
"(",
"module",
")",
"return",
"print",
",",
"rrr",
",",
"profile_"
] | wrapper that depricates print_ and printDBG | [
"wrapper",
"that",
"depricates",
"print_",
"and",
"printDBG"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L511-L520 | train |
Erotemic/utool | utool/util_inject.py | inject_python_code2 | def inject_python_code2(fpath, patch_code, tag):
""" Does autogeneration stuff """
import utool as ut
text = ut.readfrom(fpath)
start_tag = '# <%s>' % tag
end_tag = '# </%s>' % tag
new_text = ut.replace_between_tags(text, patch_code, start_tag, end_tag)
ut.writeto(fpath, new_text) | python | def inject_python_code2(fpath, patch_code, tag):
""" Does autogeneration stuff """
import utool as ut
text = ut.readfrom(fpath)
start_tag = '# <%s>' % tag
end_tag = '# </%s>' % tag
new_text = ut.replace_between_tags(text, patch_code, start_tag, end_tag)
ut.writeto(fpath, new_text) | [
"def",
"inject_python_code2",
"(",
"fpath",
",",
"patch_code",
",",
"tag",
")",
":",
"import",
"utool",
"as",
"ut",
"text",
"=",
"ut",
".",
"readfrom",
"(",
"fpath",
")",
"start_tag",
"=",
"'# <%s>'",
"%",
"tag",
"end_tag",
"=",
"'# </%s>'",
"%",
"tag",
"new_text",
"=",
"ut",
".",
"replace_between_tags",
"(",
"text",
",",
"patch_code",
",",
"start_tag",
",",
"end_tag",
")",
"ut",
".",
"writeto",
"(",
"fpath",
",",
"new_text",
")"
] | Does autogeneration stuff | [
"Does",
"autogeneration",
"stuff"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L561-L568 | train |
Erotemic/utool | utool/util_inject.py | inject_python_code | def inject_python_code(fpath, patch_code, tag=None,
inject_location='after_imports'):
"""
DEPRICATE
puts code into files on disk
"""
import utool as ut
assert tag is not None, 'TAG MUST BE SPECIFIED IN INJECTED CODETEXT'
text = ut.read_from(fpath)
comment_start_tag = '# <util_inject:%s>' % tag
comment_end_tag = '# </util_inject:%s>' % tag
tagstart_txtpos = text.find(comment_start_tag)
tagend_txtpos = text.find(comment_end_tag)
text_lines = ut.split_python_text_into_lines(text)
# split the file into two parts and inject code between them
if tagstart_txtpos != -1 or tagend_txtpos != -1:
assert tagstart_txtpos != -1, 'both tags must not be found'
assert tagend_txtpos != -1, 'both tags must not be found'
for pos, line in enumerate(text_lines):
if line.startswith(comment_start_tag):
tagstart_pos = pos
if line.startswith(comment_end_tag):
tagend_pos = pos
part1 = text_lines[0:tagstart_pos]
part2 = text_lines[tagend_pos + 1:]
else:
if inject_location == 'after_imports':
first_nonimport_pos = 0
for line in text_lines:
list_ = ['import ', 'from ', '#', ' ']
isvalid = (len(line) == 0 or
any(line.startswith(str_) for str_ in list_))
if not isvalid:
break
first_nonimport_pos += 1
part1 = text_lines[0:first_nonimport_pos]
part2 = text_lines[first_nonimport_pos:]
else:
raise AssertionError('Unknown inject location')
newtext = (
'\n'.join(part1 + [comment_start_tag]) +
'\n' + patch_code + '\n' +
'\n'.join( [comment_end_tag] + part2)
)
text_backup_fname = fpath + '.' + ut.get_timestamp() + '.bak'
ut.write_to(text_backup_fname, text)
ut.write_to(fpath, newtext) | python | def inject_python_code(fpath, patch_code, tag=None,
inject_location='after_imports'):
"""
DEPRICATE
puts code into files on disk
"""
import utool as ut
assert tag is not None, 'TAG MUST BE SPECIFIED IN INJECTED CODETEXT'
text = ut.read_from(fpath)
comment_start_tag = '# <util_inject:%s>' % tag
comment_end_tag = '# </util_inject:%s>' % tag
tagstart_txtpos = text.find(comment_start_tag)
tagend_txtpos = text.find(comment_end_tag)
text_lines = ut.split_python_text_into_lines(text)
# split the file into two parts and inject code between them
if tagstart_txtpos != -1 or tagend_txtpos != -1:
assert tagstart_txtpos != -1, 'both tags must not be found'
assert tagend_txtpos != -1, 'both tags must not be found'
for pos, line in enumerate(text_lines):
if line.startswith(comment_start_tag):
tagstart_pos = pos
if line.startswith(comment_end_tag):
tagend_pos = pos
part1 = text_lines[0:tagstart_pos]
part2 = text_lines[tagend_pos + 1:]
else:
if inject_location == 'after_imports':
first_nonimport_pos = 0
for line in text_lines:
list_ = ['import ', 'from ', '#', ' ']
isvalid = (len(line) == 0 or
any(line.startswith(str_) for str_ in list_))
if not isvalid:
break
first_nonimport_pos += 1
part1 = text_lines[0:first_nonimport_pos]
part2 = text_lines[first_nonimport_pos:]
else:
raise AssertionError('Unknown inject location')
newtext = (
'\n'.join(part1 + [comment_start_tag]) +
'\n' + patch_code + '\n' +
'\n'.join( [comment_end_tag] + part2)
)
text_backup_fname = fpath + '.' + ut.get_timestamp() + '.bak'
ut.write_to(text_backup_fname, text)
ut.write_to(fpath, newtext) | [
"def",
"inject_python_code",
"(",
"fpath",
",",
"patch_code",
",",
"tag",
"=",
"None",
",",
"inject_location",
"=",
"'after_imports'",
")",
":",
"import",
"utool",
"as",
"ut",
"assert",
"tag",
"is",
"not",
"None",
",",
"'TAG MUST BE SPECIFIED IN INJECTED CODETEXT'",
"text",
"=",
"ut",
".",
"read_from",
"(",
"fpath",
")",
"comment_start_tag",
"=",
"'# <util_inject:%s>'",
"%",
"tag",
"comment_end_tag",
"=",
"'# </util_inject:%s>'",
"%",
"tag",
"tagstart_txtpos",
"=",
"text",
".",
"find",
"(",
"comment_start_tag",
")",
"tagend_txtpos",
"=",
"text",
".",
"find",
"(",
"comment_end_tag",
")",
"text_lines",
"=",
"ut",
".",
"split_python_text_into_lines",
"(",
"text",
")",
"# split the file into two parts and inject code between them",
"if",
"tagstart_txtpos",
"!=",
"-",
"1",
"or",
"tagend_txtpos",
"!=",
"-",
"1",
":",
"assert",
"tagstart_txtpos",
"!=",
"-",
"1",
",",
"'both tags must not be found'",
"assert",
"tagend_txtpos",
"!=",
"-",
"1",
",",
"'both tags must not be found'",
"for",
"pos",
",",
"line",
"in",
"enumerate",
"(",
"text_lines",
")",
":",
"if",
"line",
".",
"startswith",
"(",
"comment_start_tag",
")",
":",
"tagstart_pos",
"=",
"pos",
"if",
"line",
".",
"startswith",
"(",
"comment_end_tag",
")",
":",
"tagend_pos",
"=",
"pos",
"part1",
"=",
"text_lines",
"[",
"0",
":",
"tagstart_pos",
"]",
"part2",
"=",
"text_lines",
"[",
"tagend_pos",
"+",
"1",
":",
"]",
"else",
":",
"if",
"inject_location",
"==",
"'after_imports'",
":",
"first_nonimport_pos",
"=",
"0",
"for",
"line",
"in",
"text_lines",
":",
"list_",
"=",
"[",
"'import '",
",",
"'from '",
",",
"'#'",
",",
"' '",
"]",
"isvalid",
"=",
"(",
"len",
"(",
"line",
")",
"==",
"0",
"or",
"any",
"(",
"line",
".",
"startswith",
"(",
"str_",
")",
"for",
"str_",
"in",
"list_",
")",
")",
"if",
"not",
"isvalid",
":",
"break",
"first_nonimport_pos",
"+=",
"1",
"part1",
"=",
"text_lines",
"[",
"0",
":",
"first_nonimport_pos",
"]",
"part2",
"=",
"text_lines",
"[",
"first_nonimport_pos",
":",
"]",
"else",
":",
"raise",
"AssertionError",
"(",
"'Unknown inject location'",
")",
"newtext",
"=",
"(",
"'\\n'",
".",
"join",
"(",
"part1",
"+",
"[",
"comment_start_tag",
"]",
")",
"+",
"'\\n'",
"+",
"patch_code",
"+",
"'\\n'",
"+",
"'\\n'",
".",
"join",
"(",
"[",
"comment_end_tag",
"]",
"+",
"part2",
")",
")",
"text_backup_fname",
"=",
"fpath",
"+",
"'.'",
"+",
"ut",
".",
"get_timestamp",
"(",
")",
"+",
"'.bak'",
"ut",
".",
"write_to",
"(",
"text_backup_fname",
",",
"text",
")",
"ut",
".",
"write_to",
"(",
"fpath",
",",
"newtext",
")"
] | DEPRICATE
puts code into files on disk | [
"DEPRICATE",
"puts",
"code",
"into",
"files",
"on",
"disk"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_inject.py#L571-L622 | train |
Erotemic/utool | utool/Printable.py | printableType | def printableType(val, name=None, parent=None):
"""
Tries to make a nice type string for a value.
Can also pass in a Printable parent object
"""
import numpy as np
if parent is not None and hasattr(parent, 'customPrintableType'):
# Hack for non - trivial preference types
_typestr = parent.customPrintableType(name)
if _typestr is not None:
return _typestr
if isinstance(val, np.ndarray):
info = npArrInfo(val)
_typestr = info.dtypestr
elif isinstance(val, object):
_typestr = val.__class__.__name__
else:
_typestr = str(type(val))
_typestr = _typestr.replace('type', '')
_typestr = re.sub('[\'><]', '', _typestr)
_typestr = re.sub(' *', ' ', _typestr)
_typestr = _typestr.strip()
return _typestr | python | def printableType(val, name=None, parent=None):
"""
Tries to make a nice type string for a value.
Can also pass in a Printable parent object
"""
import numpy as np
if parent is not None and hasattr(parent, 'customPrintableType'):
# Hack for non - trivial preference types
_typestr = parent.customPrintableType(name)
if _typestr is not None:
return _typestr
if isinstance(val, np.ndarray):
info = npArrInfo(val)
_typestr = info.dtypestr
elif isinstance(val, object):
_typestr = val.__class__.__name__
else:
_typestr = str(type(val))
_typestr = _typestr.replace('type', '')
_typestr = re.sub('[\'><]', '', _typestr)
_typestr = re.sub(' *', ' ', _typestr)
_typestr = _typestr.strip()
return _typestr | [
"def",
"printableType",
"(",
"val",
",",
"name",
"=",
"None",
",",
"parent",
"=",
"None",
")",
":",
"import",
"numpy",
"as",
"np",
"if",
"parent",
"is",
"not",
"None",
"and",
"hasattr",
"(",
"parent",
",",
"'customPrintableType'",
")",
":",
"# Hack for non - trivial preference types",
"_typestr",
"=",
"parent",
".",
"customPrintableType",
"(",
"name",
")",
"if",
"_typestr",
"is",
"not",
"None",
":",
"return",
"_typestr",
"if",
"isinstance",
"(",
"val",
",",
"np",
".",
"ndarray",
")",
":",
"info",
"=",
"npArrInfo",
"(",
"val",
")",
"_typestr",
"=",
"info",
".",
"dtypestr",
"elif",
"isinstance",
"(",
"val",
",",
"object",
")",
":",
"_typestr",
"=",
"val",
".",
"__class__",
".",
"__name__",
"else",
":",
"_typestr",
"=",
"str",
"(",
"type",
"(",
"val",
")",
")",
"_typestr",
"=",
"_typestr",
".",
"replace",
"(",
"'type'",
",",
"''",
")",
"_typestr",
"=",
"re",
".",
"sub",
"(",
"'[\\'><]'",
",",
"''",
",",
"_typestr",
")",
"_typestr",
"=",
"re",
".",
"sub",
"(",
"' *'",
",",
"' '",
",",
"_typestr",
")",
"_typestr",
"=",
"_typestr",
".",
"strip",
"(",
")",
"return",
"_typestr"
] | Tries to make a nice type string for a value.
Can also pass in a Printable parent object | [
"Tries",
"to",
"make",
"a",
"nice",
"type",
"string",
"for",
"a",
"value",
".",
"Can",
"also",
"pass",
"in",
"a",
"Printable",
"parent",
"object"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/Printable.py#L96-L118 | train |
Erotemic/utool | utool/Printable.py | printableVal | def printableVal(val, type_bit=True, justlength=False):
"""
Very old way of doing pretty printing. Need to update and refactor.
DEPRICATE
"""
from utool import util_dev
# Move to util_dev
# NUMPY ARRAY
import numpy as np
if type(val) is np.ndarray:
info = npArrInfo(val)
if info.dtypestr.startswith('bool'):
_valstr = '{ shape:' + info.shapestr + ' bittotal: ' + info.bittotal + '}'
# + '\n |_____'
elif info.dtypestr.startswith('float'):
_valstr = util_dev.get_stats_str(val)
else:
_valstr = '{ shape:' + info.shapestr + ' mM:' + info.minmaxstr + ' }' # + '\n |_____'
# String
elif isinstance(val, (str, unicode)): # NOQA
_valstr = '\'%s\'' % val
# List
elif isinstance(val, list):
if justlength or len(val) > 30:
_valstr = 'len=' + str(len(val))
else:
_valstr = '[ ' + (', \n '.join([str(v) for v in val])) + ' ]'
# ??? isinstance(val, AbstractPrintable):
elif hasattr(val, 'get_printable') and type(val) != type:
_valstr = val.get_printable(type_bit=type_bit)
elif isinstance(val, dict):
_valstr = '{\n'
for val_key in val.keys():
val_val = val[val_key]
_valstr += ' ' + str(val_key) + ' : ' + str(val_val) + '\n'
_valstr += '}'
else:
_valstr = str(val)
if _valstr.find('\n') > 0: # Indent if necessary
_valstr = _valstr.replace('\n', '\n ')
_valstr = '\n ' + _valstr
_valstr = re.sub('\n *$', '', _valstr) # Replace empty lines
return _valstr | python | def printableVal(val, type_bit=True, justlength=False):
"""
Very old way of doing pretty printing. Need to update and refactor.
DEPRICATE
"""
from utool import util_dev
# Move to util_dev
# NUMPY ARRAY
import numpy as np
if type(val) is np.ndarray:
info = npArrInfo(val)
if info.dtypestr.startswith('bool'):
_valstr = '{ shape:' + info.shapestr + ' bittotal: ' + info.bittotal + '}'
# + '\n |_____'
elif info.dtypestr.startswith('float'):
_valstr = util_dev.get_stats_str(val)
else:
_valstr = '{ shape:' + info.shapestr + ' mM:' + info.minmaxstr + ' }' # + '\n |_____'
# String
elif isinstance(val, (str, unicode)): # NOQA
_valstr = '\'%s\'' % val
# List
elif isinstance(val, list):
if justlength or len(val) > 30:
_valstr = 'len=' + str(len(val))
else:
_valstr = '[ ' + (', \n '.join([str(v) for v in val])) + ' ]'
# ??? isinstance(val, AbstractPrintable):
elif hasattr(val, 'get_printable') and type(val) != type:
_valstr = val.get_printable(type_bit=type_bit)
elif isinstance(val, dict):
_valstr = '{\n'
for val_key in val.keys():
val_val = val[val_key]
_valstr += ' ' + str(val_key) + ' : ' + str(val_val) + '\n'
_valstr += '}'
else:
_valstr = str(val)
if _valstr.find('\n') > 0: # Indent if necessary
_valstr = _valstr.replace('\n', '\n ')
_valstr = '\n ' + _valstr
_valstr = re.sub('\n *$', '', _valstr) # Replace empty lines
return _valstr | [
"def",
"printableVal",
"(",
"val",
",",
"type_bit",
"=",
"True",
",",
"justlength",
"=",
"False",
")",
":",
"from",
"utool",
"import",
"util_dev",
"# Move to util_dev",
"# NUMPY ARRAY",
"import",
"numpy",
"as",
"np",
"if",
"type",
"(",
"val",
")",
"is",
"np",
".",
"ndarray",
":",
"info",
"=",
"npArrInfo",
"(",
"val",
")",
"if",
"info",
".",
"dtypestr",
".",
"startswith",
"(",
"'bool'",
")",
":",
"_valstr",
"=",
"'{ shape:'",
"+",
"info",
".",
"shapestr",
"+",
"' bittotal: '",
"+",
"info",
".",
"bittotal",
"+",
"'}'",
"# + '\\n |_____'",
"elif",
"info",
".",
"dtypestr",
".",
"startswith",
"(",
"'float'",
")",
":",
"_valstr",
"=",
"util_dev",
".",
"get_stats_str",
"(",
"val",
")",
"else",
":",
"_valstr",
"=",
"'{ shape:'",
"+",
"info",
".",
"shapestr",
"+",
"' mM:'",
"+",
"info",
".",
"minmaxstr",
"+",
"' }'",
"# + '\\n |_____'",
"# String",
"elif",
"isinstance",
"(",
"val",
",",
"(",
"str",
",",
"unicode",
")",
")",
":",
"# NOQA",
"_valstr",
"=",
"'\\'%s\\''",
"%",
"val",
"# List",
"elif",
"isinstance",
"(",
"val",
",",
"list",
")",
":",
"if",
"justlength",
"or",
"len",
"(",
"val",
")",
">",
"30",
":",
"_valstr",
"=",
"'len='",
"+",
"str",
"(",
"len",
"(",
"val",
")",
")",
"else",
":",
"_valstr",
"=",
"'[ '",
"+",
"(",
"', \\n '",
".",
"join",
"(",
"[",
"str",
"(",
"v",
")",
"for",
"v",
"in",
"val",
"]",
")",
")",
"+",
"' ]'",
"# ??? isinstance(val, AbstractPrintable):",
"elif",
"hasattr",
"(",
"val",
",",
"'get_printable'",
")",
"and",
"type",
"(",
"val",
")",
"!=",
"type",
":",
"_valstr",
"=",
"val",
".",
"get_printable",
"(",
"type_bit",
"=",
"type_bit",
")",
"elif",
"isinstance",
"(",
"val",
",",
"dict",
")",
":",
"_valstr",
"=",
"'{\\n'",
"for",
"val_key",
"in",
"val",
".",
"keys",
"(",
")",
":",
"val_val",
"=",
"val",
"[",
"val_key",
"]",
"_valstr",
"+=",
"' '",
"+",
"str",
"(",
"val_key",
")",
"+",
"' : '",
"+",
"str",
"(",
"val_val",
")",
"+",
"'\\n'",
"_valstr",
"+=",
"'}'",
"else",
":",
"_valstr",
"=",
"str",
"(",
"val",
")",
"if",
"_valstr",
".",
"find",
"(",
"'\\n'",
")",
">",
"0",
":",
"# Indent if necessary",
"_valstr",
"=",
"_valstr",
".",
"replace",
"(",
"'\\n'",
",",
"'\\n '",
")",
"_valstr",
"=",
"'\\n '",
"+",
"_valstr",
"_valstr",
"=",
"re",
".",
"sub",
"(",
"'\\n *$'",
",",
"''",
",",
"_valstr",
")",
"# Replace empty lines",
"return",
"_valstr"
] | Very old way of doing pretty printing. Need to update and refactor.
DEPRICATE | [
"Very",
"old",
"way",
"of",
"doing",
"pretty",
"printing",
".",
"Need",
"to",
"update",
"and",
"refactor",
".",
"DEPRICATE"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/Printable.py#L121-L163 | train |
Erotemic/utool | utool/Printable.py | npArrInfo | def npArrInfo(arr):
"""
OLD update and refactor
"""
from utool.DynamicStruct import DynStruct
info = DynStruct()
info.shapestr = '[' + ' x '.join([str(x) for x in arr.shape]) + ']'
info.dtypestr = str(arr.dtype)
if info.dtypestr == 'bool':
info.bittotal = 'T=%d, F=%d' % (sum(arr), sum(1 - arr))
elif info.dtypestr == 'object':
info.minmaxstr = 'NA'
elif info.dtypestr[0] == '|':
info.minmaxstr = 'NA'
else:
if arr.size > 0:
info.minmaxstr = '(%r, %r)' % (arr.min(), arr.max())
else:
info.minmaxstr = '(None)'
return info | python | def npArrInfo(arr):
"""
OLD update and refactor
"""
from utool.DynamicStruct import DynStruct
info = DynStruct()
info.shapestr = '[' + ' x '.join([str(x) for x in arr.shape]) + ']'
info.dtypestr = str(arr.dtype)
if info.dtypestr == 'bool':
info.bittotal = 'T=%d, F=%d' % (sum(arr), sum(1 - arr))
elif info.dtypestr == 'object':
info.minmaxstr = 'NA'
elif info.dtypestr[0] == '|':
info.minmaxstr = 'NA'
else:
if arr.size > 0:
info.minmaxstr = '(%r, %r)' % (arr.min(), arr.max())
else:
info.minmaxstr = '(None)'
return info | [
"def",
"npArrInfo",
"(",
"arr",
")",
":",
"from",
"utool",
".",
"DynamicStruct",
"import",
"DynStruct",
"info",
"=",
"DynStruct",
"(",
")",
"info",
".",
"shapestr",
"=",
"'['",
"+",
"' x '",
".",
"join",
"(",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"arr",
".",
"shape",
"]",
")",
"+",
"']'",
"info",
".",
"dtypestr",
"=",
"str",
"(",
"arr",
".",
"dtype",
")",
"if",
"info",
".",
"dtypestr",
"==",
"'bool'",
":",
"info",
".",
"bittotal",
"=",
"'T=%d, F=%d'",
"%",
"(",
"sum",
"(",
"arr",
")",
",",
"sum",
"(",
"1",
"-",
"arr",
")",
")",
"elif",
"info",
".",
"dtypestr",
"==",
"'object'",
":",
"info",
".",
"minmaxstr",
"=",
"'NA'",
"elif",
"info",
".",
"dtypestr",
"[",
"0",
"]",
"==",
"'|'",
":",
"info",
".",
"minmaxstr",
"=",
"'NA'",
"else",
":",
"if",
"arr",
".",
"size",
">",
"0",
":",
"info",
".",
"minmaxstr",
"=",
"'(%r, %r)'",
"%",
"(",
"arr",
".",
"min",
"(",
")",
",",
"arr",
".",
"max",
"(",
")",
")",
"else",
":",
"info",
".",
"minmaxstr",
"=",
"'(None)'",
"return",
"info"
] | OLD update and refactor | [
"OLD",
"update",
"and",
"refactor"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/Printable.py#L166-L185 | train |
glormph/msstitch | src/app/actions/mzidtsv/isonormalize.py | get_isobaric_ratios | def get_isobaric_ratios(psmfn, psmheader, channels, denom_channels, min_int,
targetfn, accessioncol, normalize, normratiofn):
"""Main function to calculate ratios for PSMs, peptides, proteins, genes.
Can do simple ratios, median-of-ratios and median-centering
normalization."""
psm_or_feat_ratios = get_psmratios(psmfn, psmheader, channels,
denom_channels, min_int, accessioncol)
if normalize and normratiofn:
normheader = reader.get_tsv_header(normratiofn)
normratios = get_ratios_from_fn(normratiofn, normheader, channels)
ch_medians = get_medians(channels, normratios, report=True)
outratios = calculate_normalized_ratios(psm_or_feat_ratios, ch_medians,
channels)
elif normalize:
flatratios = [[feat[ch] for ch in channels]
for feat in psm_or_feat_ratios]
ch_medians = get_medians(channels, flatratios, report=True)
outratios = calculate_normalized_ratios(psm_or_feat_ratios, ch_medians,
channels)
else:
outratios = psm_or_feat_ratios
# at this point, outratios look like:
# [{ch1: 123, ch2: 456, ISOQUANTRATIO_FEAT_ACC: ENSG1244}, ]
if accessioncol and targetfn:
outratios = {x[ISOQUANTRATIO_FEAT_ACC]: x for x in outratios}
return output_to_target_accession_table(targetfn, outratios, channels)
elif not accessioncol and not targetfn:
return paste_to_psmtable(psmfn, psmheader, outratios)
elif accessioncol and not targetfn:
# generate new table with accessions
return ({(k if not k == ISOQUANTRATIO_FEAT_ACC
else prottabledata.HEADER_ACCESSION): v
for k, v in ratio.items()} for ratio in outratios) | python | def get_isobaric_ratios(psmfn, psmheader, channels, denom_channels, min_int,
targetfn, accessioncol, normalize, normratiofn):
"""Main function to calculate ratios for PSMs, peptides, proteins, genes.
Can do simple ratios, median-of-ratios and median-centering
normalization."""
psm_or_feat_ratios = get_psmratios(psmfn, psmheader, channels,
denom_channels, min_int, accessioncol)
if normalize and normratiofn:
normheader = reader.get_tsv_header(normratiofn)
normratios = get_ratios_from_fn(normratiofn, normheader, channels)
ch_medians = get_medians(channels, normratios, report=True)
outratios = calculate_normalized_ratios(psm_or_feat_ratios, ch_medians,
channels)
elif normalize:
flatratios = [[feat[ch] for ch in channels]
for feat in psm_or_feat_ratios]
ch_medians = get_medians(channels, flatratios, report=True)
outratios = calculate_normalized_ratios(psm_or_feat_ratios, ch_medians,
channels)
else:
outratios = psm_or_feat_ratios
# at this point, outratios look like:
# [{ch1: 123, ch2: 456, ISOQUANTRATIO_FEAT_ACC: ENSG1244}, ]
if accessioncol and targetfn:
outratios = {x[ISOQUANTRATIO_FEAT_ACC]: x for x in outratios}
return output_to_target_accession_table(targetfn, outratios, channels)
elif not accessioncol and not targetfn:
return paste_to_psmtable(psmfn, psmheader, outratios)
elif accessioncol and not targetfn:
# generate new table with accessions
return ({(k if not k == ISOQUANTRATIO_FEAT_ACC
else prottabledata.HEADER_ACCESSION): v
for k, v in ratio.items()} for ratio in outratios) | [
"def",
"get_isobaric_ratios",
"(",
"psmfn",
",",
"psmheader",
",",
"channels",
",",
"denom_channels",
",",
"min_int",
",",
"targetfn",
",",
"accessioncol",
",",
"normalize",
",",
"normratiofn",
")",
":",
"psm_or_feat_ratios",
"=",
"get_psmratios",
"(",
"psmfn",
",",
"psmheader",
",",
"channels",
",",
"denom_channels",
",",
"min_int",
",",
"accessioncol",
")",
"if",
"normalize",
"and",
"normratiofn",
":",
"normheader",
"=",
"reader",
".",
"get_tsv_header",
"(",
"normratiofn",
")",
"normratios",
"=",
"get_ratios_from_fn",
"(",
"normratiofn",
",",
"normheader",
",",
"channels",
")",
"ch_medians",
"=",
"get_medians",
"(",
"channels",
",",
"normratios",
",",
"report",
"=",
"True",
")",
"outratios",
"=",
"calculate_normalized_ratios",
"(",
"psm_or_feat_ratios",
",",
"ch_medians",
",",
"channels",
")",
"elif",
"normalize",
":",
"flatratios",
"=",
"[",
"[",
"feat",
"[",
"ch",
"]",
"for",
"ch",
"in",
"channels",
"]",
"for",
"feat",
"in",
"psm_or_feat_ratios",
"]",
"ch_medians",
"=",
"get_medians",
"(",
"channels",
",",
"flatratios",
",",
"report",
"=",
"True",
")",
"outratios",
"=",
"calculate_normalized_ratios",
"(",
"psm_or_feat_ratios",
",",
"ch_medians",
",",
"channels",
")",
"else",
":",
"outratios",
"=",
"psm_or_feat_ratios",
"# at this point, outratios look like:",
"# [{ch1: 123, ch2: 456, ISOQUANTRATIO_FEAT_ACC: ENSG1244}, ]",
"if",
"accessioncol",
"and",
"targetfn",
":",
"outratios",
"=",
"{",
"x",
"[",
"ISOQUANTRATIO_FEAT_ACC",
"]",
":",
"x",
"for",
"x",
"in",
"outratios",
"}",
"return",
"output_to_target_accession_table",
"(",
"targetfn",
",",
"outratios",
",",
"channels",
")",
"elif",
"not",
"accessioncol",
"and",
"not",
"targetfn",
":",
"return",
"paste_to_psmtable",
"(",
"psmfn",
",",
"psmheader",
",",
"outratios",
")",
"elif",
"accessioncol",
"and",
"not",
"targetfn",
":",
"# generate new table with accessions",
"return",
"(",
"{",
"(",
"k",
"if",
"not",
"k",
"==",
"ISOQUANTRATIO_FEAT_ACC",
"else",
"prottabledata",
".",
"HEADER_ACCESSION",
")",
":",
"v",
"for",
"k",
",",
"v",
"in",
"ratio",
".",
"items",
"(",
")",
"}",
"for",
"ratio",
"in",
"outratios",
")"
] | Main function to calculate ratios for PSMs, peptides, proteins, genes.
Can do simple ratios, median-of-ratios and median-centering
normalization. | [
"Main",
"function",
"to",
"calculate",
"ratios",
"for",
"PSMs",
"peptides",
"proteins",
"genes",
".",
"Can",
"do",
"simple",
"ratios",
"median",
"-",
"of",
"-",
"ratios",
"and",
"median",
"-",
"centering",
"normalization",
"."
] | ded7e5cbd813d7797dc9d42805778266e59ff042 | https://github.com/glormph/msstitch/blob/ded7e5cbd813d7797dc9d42805778266e59ff042/src/app/actions/mzidtsv/isonormalize.py#L13-L45 | train |
timedata-org/loady | loady/files.py | sanitize | def sanitize(value):
"""Strips all undesirable characters out of potential file paths."""
value = unicodedata.normalize('NFKD', value)
value = value.strip()
value = re.sub('[^./\w\s-]', '', value)
value = re.sub('[-\s]+', '-', value)
return value | python | def sanitize(value):
"""Strips all undesirable characters out of potential file paths."""
value = unicodedata.normalize('NFKD', value)
value = value.strip()
value = re.sub('[^./\w\s-]', '', value)
value = re.sub('[-\s]+', '-', value)
return value | [
"def",
"sanitize",
"(",
"value",
")",
":",
"value",
"=",
"unicodedata",
".",
"normalize",
"(",
"'NFKD'",
",",
"value",
")",
"value",
"=",
"value",
".",
"strip",
"(",
")",
"value",
"=",
"re",
".",
"sub",
"(",
"'[^./\\w\\s-]'",
",",
"''",
",",
"value",
")",
"value",
"=",
"re",
".",
"sub",
"(",
"'[-\\s]+'",
",",
"'-'",
",",
"value",
")",
"return",
"value"
] | Strips all undesirable characters out of potential file paths. | [
"Strips",
"all",
"undesirable",
"characters",
"out",
"of",
"potential",
"file",
"paths",
"."
] | 94ffcdb92f15a28f3c85f77bd293a9cb59de4cad | https://github.com/timedata-org/loady/blob/94ffcdb92f15a28f3c85f77bd293a9cb59de4cad/loady/files.py#L10-L18 | train |
timedata-org/loady | loady/files.py | remove_on_exception | def remove_on_exception(dirname, remove=True):
"""Creates a directory, yields to the caller, and removes that directory
if an exception is thrown."""
os.makedirs(dirname)
try:
yield
except:
if remove:
shutil.rmtree(dirname, ignore_errors=True)
raise | python | def remove_on_exception(dirname, remove=True):
"""Creates a directory, yields to the caller, and removes that directory
if an exception is thrown."""
os.makedirs(dirname)
try:
yield
except:
if remove:
shutil.rmtree(dirname, ignore_errors=True)
raise | [
"def",
"remove_on_exception",
"(",
"dirname",
",",
"remove",
"=",
"True",
")",
":",
"os",
".",
"makedirs",
"(",
"dirname",
")",
"try",
":",
"yield",
"except",
":",
"if",
"remove",
":",
"shutil",
".",
"rmtree",
"(",
"dirname",
",",
"ignore_errors",
"=",
"True",
")",
"raise"
] | Creates a directory, yields to the caller, and removes that directory
if an exception is thrown. | [
"Creates",
"a",
"directory",
"yields",
"to",
"the",
"caller",
"and",
"removes",
"that",
"directory",
"if",
"an",
"exception",
"is",
"thrown",
"."
] | 94ffcdb92f15a28f3c85f77bd293a9cb59de4cad | https://github.com/timedata-org/loady/blob/94ffcdb92f15a28f3c85f77bd293a9cb59de4cad/loady/files.py#L22-L31 | train |
glormph/msstitch | src/app/actions/mzidtsv/percolator.py | add_percolator_to_mzidtsv | def add_percolator_to_mzidtsv(mzidfn, tsvfn, multipsm, oldheader):
"""Takes a MSGF+ tsv and corresponding mzId, adds percolatordata
to tsv lines. Generator yields the lines. Multiple PSMs per scan
can be delivered, in which case rank is also reported.
"""
namespace = readers.get_mzid_namespace(mzidfn)
try:
xmlns = '{%s}' % namespace['xmlns']
except TypeError:
xmlns = ''
specfnids = readers.get_mzid_specfile_ids(mzidfn, namespace)
mzidpepmap = {}
for peptide in readers.generate_mzid_peptides(mzidfn, namespace):
pep_id, seq = readers.get_mzid_peptidedata(peptide, xmlns)
mzidpepmap[pep_id] = seq
mzidpercomap = {}
for specid_data in readers.generate_mzid_spec_id_items(mzidfn, namespace,
xmlns, specfnids):
scan, fn, pepid, spec_id = specid_data
percodata = readers.get_specidentitem_percolator_data(spec_id, xmlns)
try:
mzidpercomap[fn][scan][mzidpepmap[pepid]] = percodata
except KeyError:
try:
mzidpercomap[fn][scan] = {mzidpepmap[pepid]: percodata}
except KeyError:
mzidpercomap[fn] = {scan: {mzidpepmap[pepid]: percodata}}
for line in tsvreader.generate_tsv_psms(tsvfn, oldheader):
outline = {k: v for k, v in line.items()}
fn = line[mzidtsvdata.HEADER_SPECFILE]
scan = line[mzidtsvdata.HEADER_SCANNR]
seq = line[mzidtsvdata.HEADER_PEPTIDE]
outline.update(mzidpercomap[fn][scan][seq])
yield outline | python | def add_percolator_to_mzidtsv(mzidfn, tsvfn, multipsm, oldheader):
"""Takes a MSGF+ tsv and corresponding mzId, adds percolatordata
to tsv lines. Generator yields the lines. Multiple PSMs per scan
can be delivered, in which case rank is also reported.
"""
namespace = readers.get_mzid_namespace(mzidfn)
try:
xmlns = '{%s}' % namespace['xmlns']
except TypeError:
xmlns = ''
specfnids = readers.get_mzid_specfile_ids(mzidfn, namespace)
mzidpepmap = {}
for peptide in readers.generate_mzid_peptides(mzidfn, namespace):
pep_id, seq = readers.get_mzid_peptidedata(peptide, xmlns)
mzidpepmap[pep_id] = seq
mzidpercomap = {}
for specid_data in readers.generate_mzid_spec_id_items(mzidfn, namespace,
xmlns, specfnids):
scan, fn, pepid, spec_id = specid_data
percodata = readers.get_specidentitem_percolator_data(spec_id, xmlns)
try:
mzidpercomap[fn][scan][mzidpepmap[pepid]] = percodata
except KeyError:
try:
mzidpercomap[fn][scan] = {mzidpepmap[pepid]: percodata}
except KeyError:
mzidpercomap[fn] = {scan: {mzidpepmap[pepid]: percodata}}
for line in tsvreader.generate_tsv_psms(tsvfn, oldheader):
outline = {k: v for k, v in line.items()}
fn = line[mzidtsvdata.HEADER_SPECFILE]
scan = line[mzidtsvdata.HEADER_SCANNR]
seq = line[mzidtsvdata.HEADER_PEPTIDE]
outline.update(mzidpercomap[fn][scan][seq])
yield outline | [
"def",
"add_percolator_to_mzidtsv",
"(",
"mzidfn",
",",
"tsvfn",
",",
"multipsm",
",",
"oldheader",
")",
":",
"namespace",
"=",
"readers",
".",
"get_mzid_namespace",
"(",
"mzidfn",
")",
"try",
":",
"xmlns",
"=",
"'{%s}'",
"%",
"namespace",
"[",
"'xmlns'",
"]",
"except",
"TypeError",
":",
"xmlns",
"=",
"''",
"specfnids",
"=",
"readers",
".",
"get_mzid_specfile_ids",
"(",
"mzidfn",
",",
"namespace",
")",
"mzidpepmap",
"=",
"{",
"}",
"for",
"peptide",
"in",
"readers",
".",
"generate_mzid_peptides",
"(",
"mzidfn",
",",
"namespace",
")",
":",
"pep_id",
",",
"seq",
"=",
"readers",
".",
"get_mzid_peptidedata",
"(",
"peptide",
",",
"xmlns",
")",
"mzidpepmap",
"[",
"pep_id",
"]",
"=",
"seq",
"mzidpercomap",
"=",
"{",
"}",
"for",
"specid_data",
"in",
"readers",
".",
"generate_mzid_spec_id_items",
"(",
"mzidfn",
",",
"namespace",
",",
"xmlns",
",",
"specfnids",
")",
":",
"scan",
",",
"fn",
",",
"pepid",
",",
"spec_id",
"=",
"specid_data",
"percodata",
"=",
"readers",
".",
"get_specidentitem_percolator_data",
"(",
"spec_id",
",",
"xmlns",
")",
"try",
":",
"mzidpercomap",
"[",
"fn",
"]",
"[",
"scan",
"]",
"[",
"mzidpepmap",
"[",
"pepid",
"]",
"]",
"=",
"percodata",
"except",
"KeyError",
":",
"try",
":",
"mzidpercomap",
"[",
"fn",
"]",
"[",
"scan",
"]",
"=",
"{",
"mzidpepmap",
"[",
"pepid",
"]",
":",
"percodata",
"}",
"except",
"KeyError",
":",
"mzidpercomap",
"[",
"fn",
"]",
"=",
"{",
"scan",
":",
"{",
"mzidpepmap",
"[",
"pepid",
"]",
":",
"percodata",
"}",
"}",
"for",
"line",
"in",
"tsvreader",
".",
"generate_tsv_psms",
"(",
"tsvfn",
",",
"oldheader",
")",
":",
"outline",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"line",
".",
"items",
"(",
")",
"}",
"fn",
"=",
"line",
"[",
"mzidtsvdata",
".",
"HEADER_SPECFILE",
"]",
"scan",
"=",
"line",
"[",
"mzidtsvdata",
".",
"HEADER_SCANNR",
"]",
"seq",
"=",
"line",
"[",
"mzidtsvdata",
".",
"HEADER_PEPTIDE",
"]",
"outline",
".",
"update",
"(",
"mzidpercomap",
"[",
"fn",
"]",
"[",
"scan",
"]",
"[",
"seq",
"]",
")",
"yield",
"outline"
] | Takes a MSGF+ tsv and corresponding mzId, adds percolatordata
to tsv lines. Generator yields the lines. Multiple PSMs per scan
can be delivered, in which case rank is also reported. | [
"Takes",
"a",
"MSGF",
"+",
"tsv",
"and",
"corresponding",
"mzId",
"adds",
"percolatordata",
"to",
"tsv",
"lines",
".",
"Generator",
"yields",
"the",
"lines",
".",
"Multiple",
"PSMs",
"per",
"scan",
"can",
"be",
"delivered",
"in",
"which",
"case",
"rank",
"is",
"also",
"reported",
"."
] | ded7e5cbd813d7797dc9d42805778266e59ff042 | https://github.com/glormph/msstitch/blob/ded7e5cbd813d7797dc9d42805778266e59ff042/src/app/actions/mzidtsv/percolator.py#L6-L39 | train |
Erotemic/utool | utool/util_profile.py | parse_rawprofile_blocks | def parse_rawprofile_blocks(text):
"""
Split the file into blocks along delimters and and put delimeters back in
the list
"""
# The total time reported in the raw output is from pystone not kernprof
# The pystone total time is actually the average time spent in the function
delim = 'Total time: '
delim2 = 'Pystone time: '
#delim = 'File: '
profile_block_list = ut.regex_split('^' + delim, text)
for ix in range(1, len(profile_block_list)):
profile_block_list[ix] = delim2 + profile_block_list[ix]
return profile_block_list | python | def parse_rawprofile_blocks(text):
"""
Split the file into blocks along delimters and and put delimeters back in
the list
"""
# The total time reported in the raw output is from pystone not kernprof
# The pystone total time is actually the average time spent in the function
delim = 'Total time: '
delim2 = 'Pystone time: '
#delim = 'File: '
profile_block_list = ut.regex_split('^' + delim, text)
for ix in range(1, len(profile_block_list)):
profile_block_list[ix] = delim2 + profile_block_list[ix]
return profile_block_list | [
"def",
"parse_rawprofile_blocks",
"(",
"text",
")",
":",
"# The total time reported in the raw output is from pystone not kernprof",
"# The pystone total time is actually the average time spent in the function",
"delim",
"=",
"'Total time: '",
"delim2",
"=",
"'Pystone time: '",
"#delim = 'File: '",
"profile_block_list",
"=",
"ut",
".",
"regex_split",
"(",
"'^'",
"+",
"delim",
",",
"text",
")",
"for",
"ix",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"profile_block_list",
")",
")",
":",
"profile_block_list",
"[",
"ix",
"]",
"=",
"delim2",
"+",
"profile_block_list",
"[",
"ix",
"]",
"return",
"profile_block_list"
] | Split the file into blocks along delimters and and put delimeters back in
the list | [
"Split",
"the",
"file",
"into",
"blocks",
"along",
"delimters",
"and",
"and",
"put",
"delimeters",
"back",
"in",
"the",
"list"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_profile.py#L78-L91 | train |
Erotemic/utool | utool/util_profile.py | parse_timemap_from_blocks | def parse_timemap_from_blocks(profile_block_list):
"""
Build a map from times to line_profile blocks
"""
prefix_list = []
timemap = ut.ddict(list)
for ix in range(len(profile_block_list)):
block = profile_block_list[ix]
total_time = get_block_totaltime(block)
# Blocks without time go at the front of sorted output
if total_time is None:
prefix_list.append(block)
# Blocks that are not run are not appended to output
elif total_time != 0:
timemap[total_time].append(block)
return prefix_list, timemap | python | def parse_timemap_from_blocks(profile_block_list):
"""
Build a map from times to line_profile blocks
"""
prefix_list = []
timemap = ut.ddict(list)
for ix in range(len(profile_block_list)):
block = profile_block_list[ix]
total_time = get_block_totaltime(block)
# Blocks without time go at the front of sorted output
if total_time is None:
prefix_list.append(block)
# Blocks that are not run are not appended to output
elif total_time != 0:
timemap[total_time].append(block)
return prefix_list, timemap | [
"def",
"parse_timemap_from_blocks",
"(",
"profile_block_list",
")",
":",
"prefix_list",
"=",
"[",
"]",
"timemap",
"=",
"ut",
".",
"ddict",
"(",
"list",
")",
"for",
"ix",
"in",
"range",
"(",
"len",
"(",
"profile_block_list",
")",
")",
":",
"block",
"=",
"profile_block_list",
"[",
"ix",
"]",
"total_time",
"=",
"get_block_totaltime",
"(",
"block",
")",
"# Blocks without time go at the front of sorted output",
"if",
"total_time",
"is",
"None",
":",
"prefix_list",
".",
"append",
"(",
"block",
")",
"# Blocks that are not run are not appended to output",
"elif",
"total_time",
"!=",
"0",
":",
"timemap",
"[",
"total_time",
"]",
".",
"append",
"(",
"block",
")",
"return",
"prefix_list",
",",
"timemap"
] | Build a map from times to line_profile blocks | [
"Build",
"a",
"map",
"from",
"times",
"to",
"line_profile",
"blocks"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_profile.py#L123-L138 | train |
Erotemic/utool | utool/util_profile.py | clean_line_profile_text | def clean_line_profile_text(text):
"""
Sorts the output from line profile by execution time
Removes entries which were not run
"""
#
profile_block_list = parse_rawprofile_blocks(text)
#profile_block_list = fix_rawprofile_blocks(profile_block_list)
#---
# FIXME can be written much nicer
prefix_list, timemap = parse_timemap_from_blocks(profile_block_list)
# Sort the blocks by time
sorted_lists = sorted(six.iteritems(timemap), key=operator.itemgetter(0))
newlist = prefix_list[:]
for key, val in sorted_lists:
newlist.extend(val)
# Rejoin output text
output_text = '\n'.join(newlist)
#---
# Hack in a profile summary
summary_text = get_summary(profile_block_list)
output_text = output_text
return output_text, summary_text | python | def clean_line_profile_text(text):
"""
Sorts the output from line profile by execution time
Removes entries which were not run
"""
#
profile_block_list = parse_rawprofile_blocks(text)
#profile_block_list = fix_rawprofile_blocks(profile_block_list)
#---
# FIXME can be written much nicer
prefix_list, timemap = parse_timemap_from_blocks(profile_block_list)
# Sort the blocks by time
sorted_lists = sorted(six.iteritems(timemap), key=operator.itemgetter(0))
newlist = prefix_list[:]
for key, val in sorted_lists:
newlist.extend(val)
# Rejoin output text
output_text = '\n'.join(newlist)
#---
# Hack in a profile summary
summary_text = get_summary(profile_block_list)
output_text = output_text
return output_text, summary_text | [
"def",
"clean_line_profile_text",
"(",
"text",
")",
":",
"#",
"profile_block_list",
"=",
"parse_rawprofile_blocks",
"(",
"text",
")",
"#profile_block_list = fix_rawprofile_blocks(profile_block_list)",
"#---",
"# FIXME can be written much nicer",
"prefix_list",
",",
"timemap",
"=",
"parse_timemap_from_blocks",
"(",
"profile_block_list",
")",
"# Sort the blocks by time",
"sorted_lists",
"=",
"sorted",
"(",
"six",
".",
"iteritems",
"(",
"timemap",
")",
",",
"key",
"=",
"operator",
".",
"itemgetter",
"(",
"0",
")",
")",
"newlist",
"=",
"prefix_list",
"[",
":",
"]",
"for",
"key",
",",
"val",
"in",
"sorted_lists",
":",
"newlist",
".",
"extend",
"(",
"val",
")",
"# Rejoin output text",
"output_text",
"=",
"'\\n'",
".",
"join",
"(",
"newlist",
")",
"#---",
"# Hack in a profile summary",
"summary_text",
"=",
"get_summary",
"(",
"profile_block_list",
")",
"output_text",
"=",
"output_text",
"return",
"output_text",
",",
"summary_text"
] | Sorts the output from line profile by execution time
Removes entries which were not run | [
"Sorts",
"the",
"output",
"from",
"line",
"profile",
"by",
"execution",
"time",
"Removes",
"entries",
"which",
"were",
"not",
"run"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_profile.py#L191-L213 | train |
Erotemic/utool | utool/util_profile.py | clean_lprof_file | def clean_lprof_file(input_fname, output_fname=None):
""" Reads a .lprof file and cleans it """
# Read the raw .lprof text dump
text = ut.read_from(input_fname)
# Sort and clean the text
output_text = clean_line_profile_text(text)
return output_text | python | def clean_lprof_file(input_fname, output_fname=None):
""" Reads a .lprof file and cleans it """
# Read the raw .lprof text dump
text = ut.read_from(input_fname)
# Sort and clean the text
output_text = clean_line_profile_text(text)
return output_text | [
"def",
"clean_lprof_file",
"(",
"input_fname",
",",
"output_fname",
"=",
"None",
")",
":",
"# Read the raw .lprof text dump",
"text",
"=",
"ut",
".",
"read_from",
"(",
"input_fname",
")",
"# Sort and clean the text",
"output_text",
"=",
"clean_line_profile_text",
"(",
"text",
")",
"return",
"output_text"
] | Reads a .lprof file and cleans it | [
"Reads",
"a",
".",
"lprof",
"file",
"and",
"cleans",
"it"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_profile.py#L216-L222 | train |
YuriyGuts/pygoose | pygoose/kg/keras.py | get_class_weights | def get_class_weights(y, smooth_factor=0):
"""
Returns the weights for each class based on the frequencies of the samples.
Args:
y: A list of true labels (the labels must be hashable).
smooth_factor: A factor that smooths extremely uneven weights.
Returns:
A dictionary with the weight for each class.
"""
from collections import Counter
counter = Counter(y)
if smooth_factor > 0:
p = max(counter.values()) * smooth_factor
for k in counter.keys():
counter[k] += p
majority = max(counter.values())
return {cls: float(majority / count) for cls, count in counter.items()} | python | def get_class_weights(y, smooth_factor=0):
"""
Returns the weights for each class based on the frequencies of the samples.
Args:
y: A list of true labels (the labels must be hashable).
smooth_factor: A factor that smooths extremely uneven weights.
Returns:
A dictionary with the weight for each class.
"""
from collections import Counter
counter = Counter(y)
if smooth_factor > 0:
p = max(counter.values()) * smooth_factor
for k in counter.keys():
counter[k] += p
majority = max(counter.values())
return {cls: float(majority / count) for cls, count in counter.items()} | [
"def",
"get_class_weights",
"(",
"y",
",",
"smooth_factor",
"=",
"0",
")",
":",
"from",
"collections",
"import",
"Counter",
"counter",
"=",
"Counter",
"(",
"y",
")",
"if",
"smooth_factor",
">",
"0",
":",
"p",
"=",
"max",
"(",
"counter",
".",
"values",
"(",
")",
")",
"*",
"smooth_factor",
"for",
"k",
"in",
"counter",
".",
"keys",
"(",
")",
":",
"counter",
"[",
"k",
"]",
"+=",
"p",
"majority",
"=",
"max",
"(",
"counter",
".",
"values",
"(",
")",
")",
"return",
"{",
"cls",
":",
"float",
"(",
"majority",
"/",
"count",
")",
"for",
"cls",
",",
"count",
"in",
"counter",
".",
"items",
"(",
")",
"}"
] | Returns the weights for each class based on the frequencies of the samples.
Args:
y: A list of true labels (the labels must be hashable).
smooth_factor: A factor that smooths extremely uneven weights.
Returns:
A dictionary with the weight for each class. | [
"Returns",
"the",
"weights",
"for",
"each",
"class",
"based",
"on",
"the",
"frequencies",
"of",
"the",
"samples",
"."
] | 4d9b8827c6d6c4b79949d1cd653393498c0bb3c2 | https://github.com/YuriyGuts/pygoose/blob/4d9b8827c6d6c4b79949d1cd653393498c0bb3c2/pygoose/kg/keras.py#L4-L26 | train |
YuriyGuts/pygoose | pygoose/kg/keras.py | plot_loss_history | def plot_loss_history(history, figsize=(15, 8)):
"""
Plots the learning history for a Keras model,
assuming the validation data was provided to the 'fit' function.
Args:
history: The return value from the 'fit' function.
figsize: The size of the plot.
"""
plt.figure(figsize=figsize)
plt.plot(history.history["loss"])
plt.plot(history.history["val_loss"])
plt.xlabel("# Epochs")
plt.ylabel("Loss")
plt.legend(["Training", "Validation"])
plt.title("Loss over time")
plt.show() | python | def plot_loss_history(history, figsize=(15, 8)):
"""
Plots the learning history for a Keras model,
assuming the validation data was provided to the 'fit' function.
Args:
history: The return value from the 'fit' function.
figsize: The size of the plot.
"""
plt.figure(figsize=figsize)
plt.plot(history.history["loss"])
plt.plot(history.history["val_loss"])
plt.xlabel("# Epochs")
plt.ylabel("Loss")
plt.legend(["Training", "Validation"])
plt.title("Loss over time")
plt.show() | [
"def",
"plot_loss_history",
"(",
"history",
",",
"figsize",
"=",
"(",
"15",
",",
"8",
")",
")",
":",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"figsize",
")",
"plt",
".",
"plot",
"(",
"history",
".",
"history",
"[",
"\"loss\"",
"]",
")",
"plt",
".",
"plot",
"(",
"history",
".",
"history",
"[",
"\"val_loss\"",
"]",
")",
"plt",
".",
"xlabel",
"(",
"\"# Epochs\"",
")",
"plt",
".",
"ylabel",
"(",
"\"Loss\"",
")",
"plt",
".",
"legend",
"(",
"[",
"\"Training\"",
",",
"\"Validation\"",
"]",
")",
"plt",
".",
"title",
"(",
"\"Loss over time\"",
")",
"plt",
".",
"show",
"(",
")"
] | Plots the learning history for a Keras model,
assuming the validation data was provided to the 'fit' function.
Args:
history: The return value from the 'fit' function.
figsize: The size of the plot. | [
"Plots",
"the",
"learning",
"history",
"for",
"a",
"Keras",
"model",
"assuming",
"the",
"validation",
"data",
"was",
"provided",
"to",
"the",
"fit",
"function",
"."
] | 4d9b8827c6d6c4b79949d1cd653393498c0bb3c2 | https://github.com/YuriyGuts/pygoose/blob/4d9b8827c6d6c4b79949d1cd653393498c0bb3c2/pygoose/kg/keras.py#L29-L49 | train |
Erotemic/utool | utool/util_iter.py | iter_window | def iter_window(iterable, size=2, step=1, wrap=False):
r"""
iterates through iterable with a window size
generalizeation of itertwo
Args:
iterable (iter): an iterable sequence
size (int): window size (default = 2)
wrap (bool): wraparound (default = False)
Returns:
iter: returns windows in a sequence
CommandLine:
python -m utool.util_iter --exec-iter_window
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6]
>>> size, step, wrap = 3, 1, True
>>> window_iter = iter_window(iterable, size, step, wrap)
>>> window_list = list(window_iter)
>>> result = ('window_list = %r' % (window_list,))
>>> print(result)
window_list = [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 1), (6, 1, 2)]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6]
>>> size, step, wrap = 3, 2, True
>>> window_iter = iter_window(iterable, size, step, wrap)
>>> window_list = list(window_iter)
>>> result = ('window_list = %r' % (window_list,))
>>> print(result)
window_list = [(1, 2, 3), (3, 4, 5), (5, 6, 1)]
"""
# it.tee may be slow, but works on all iterables
iter_list = it.tee(iterable, size)
if wrap:
# Secondary iterables need to be cycled for wraparound
iter_list = [iter_list[0]] + list(map(it.cycle, iter_list[1:]))
# Step each iterator the approprate number of times
try:
for count, iter_ in enumerate(iter_list[1:], start=1):
for _ in range(count):
six.next(iter_)
except StopIteration:
return iter(())
else:
_window_iter = zip(*iter_list)
# Account for the step size
window_iter = it.islice(_window_iter, 0, None, step)
return window_iter | python | def iter_window(iterable, size=2, step=1, wrap=False):
r"""
iterates through iterable with a window size
generalizeation of itertwo
Args:
iterable (iter): an iterable sequence
size (int): window size (default = 2)
wrap (bool): wraparound (default = False)
Returns:
iter: returns windows in a sequence
CommandLine:
python -m utool.util_iter --exec-iter_window
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6]
>>> size, step, wrap = 3, 1, True
>>> window_iter = iter_window(iterable, size, step, wrap)
>>> window_list = list(window_iter)
>>> result = ('window_list = %r' % (window_list,))
>>> print(result)
window_list = [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 1), (6, 1, 2)]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6]
>>> size, step, wrap = 3, 2, True
>>> window_iter = iter_window(iterable, size, step, wrap)
>>> window_list = list(window_iter)
>>> result = ('window_list = %r' % (window_list,))
>>> print(result)
window_list = [(1, 2, 3), (3, 4, 5), (5, 6, 1)]
"""
# it.tee may be slow, but works on all iterables
iter_list = it.tee(iterable, size)
if wrap:
# Secondary iterables need to be cycled for wraparound
iter_list = [iter_list[0]] + list(map(it.cycle, iter_list[1:]))
# Step each iterator the approprate number of times
try:
for count, iter_ in enumerate(iter_list[1:], start=1):
for _ in range(count):
six.next(iter_)
except StopIteration:
return iter(())
else:
_window_iter = zip(*iter_list)
# Account for the step size
window_iter = it.islice(_window_iter, 0, None, step)
return window_iter | [
"def",
"iter_window",
"(",
"iterable",
",",
"size",
"=",
"2",
",",
"step",
"=",
"1",
",",
"wrap",
"=",
"False",
")",
":",
"# it.tee may be slow, but works on all iterables",
"iter_list",
"=",
"it",
".",
"tee",
"(",
"iterable",
",",
"size",
")",
"if",
"wrap",
":",
"# Secondary iterables need to be cycled for wraparound",
"iter_list",
"=",
"[",
"iter_list",
"[",
"0",
"]",
"]",
"+",
"list",
"(",
"map",
"(",
"it",
".",
"cycle",
",",
"iter_list",
"[",
"1",
":",
"]",
")",
")",
"# Step each iterator the approprate number of times",
"try",
":",
"for",
"count",
",",
"iter_",
"in",
"enumerate",
"(",
"iter_list",
"[",
"1",
":",
"]",
",",
"start",
"=",
"1",
")",
":",
"for",
"_",
"in",
"range",
"(",
"count",
")",
":",
"six",
".",
"next",
"(",
"iter_",
")",
"except",
"StopIteration",
":",
"return",
"iter",
"(",
"(",
")",
")",
"else",
":",
"_window_iter",
"=",
"zip",
"(",
"*",
"iter_list",
")",
"# Account for the step size",
"window_iter",
"=",
"it",
".",
"islice",
"(",
"_window_iter",
",",
"0",
",",
"None",
",",
"step",
")",
"return",
"window_iter"
] | r"""
iterates through iterable with a window size
generalizeation of itertwo
Args:
iterable (iter): an iterable sequence
size (int): window size (default = 2)
wrap (bool): wraparound (default = False)
Returns:
iter: returns windows in a sequence
CommandLine:
python -m utool.util_iter --exec-iter_window
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6]
>>> size, step, wrap = 3, 1, True
>>> window_iter = iter_window(iterable, size, step, wrap)
>>> window_list = list(window_iter)
>>> result = ('window_list = %r' % (window_list,))
>>> print(result)
window_list = [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 1), (6, 1, 2)]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6]
>>> size, step, wrap = 3, 2, True
>>> window_iter = iter_window(iterable, size, step, wrap)
>>> window_list = list(window_iter)
>>> result = ('window_list = %r' % (window_list,))
>>> print(result)
window_list = [(1, 2, 3), (3, 4, 5), (5, 6, 1)] | [
"r",
"iterates",
"through",
"iterable",
"with",
"a",
"window",
"size",
"generalizeation",
"of",
"itertwo"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L89-L143 | train |
Erotemic/utool | utool/util_iter.py | iter_compress | def iter_compress(item_iter, flag_iter):
"""
iter_compress - like numpy compress
Args:
item_iter (list):
flag_iter (list): of bools
Returns:
list: true_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> item_iter = [1, 2, 3, 4, 5]
>>> flag_iter = [False, True, True, False, True]
>>> true_items = iter_compress(item_iter, flag_iter)
>>> result = list(true_items)
>>> print(result)
[2, 3, 5]
"""
# TODO: Just use it.compress
true_items = (item for (item, flag) in zip(item_iter, flag_iter) if flag)
return true_items | python | def iter_compress(item_iter, flag_iter):
"""
iter_compress - like numpy compress
Args:
item_iter (list):
flag_iter (list): of bools
Returns:
list: true_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> item_iter = [1, 2, 3, 4, 5]
>>> flag_iter = [False, True, True, False, True]
>>> true_items = iter_compress(item_iter, flag_iter)
>>> result = list(true_items)
>>> print(result)
[2, 3, 5]
"""
# TODO: Just use it.compress
true_items = (item for (item, flag) in zip(item_iter, flag_iter) if flag)
return true_items | [
"def",
"iter_compress",
"(",
"item_iter",
",",
"flag_iter",
")",
":",
"# TODO: Just use it.compress",
"true_items",
"=",
"(",
"item",
"for",
"(",
"item",
",",
"flag",
")",
"in",
"zip",
"(",
"item_iter",
",",
"flag_iter",
")",
"if",
"flag",
")",
"return",
"true_items"
] | iter_compress - like numpy compress
Args:
item_iter (list):
flag_iter (list): of bools
Returns:
list: true_items
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> item_iter = [1, 2, 3, 4, 5]
>>> flag_iter = [False, True, True, False, True]
>>> true_items = iter_compress(item_iter, flag_iter)
>>> result = list(true_items)
>>> print(result)
[2, 3, 5] | [
"iter_compress",
"-",
"like",
"numpy",
"compress"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L232-L255 | train |
Erotemic/utool | utool/util_iter.py | ichunks | def ichunks(iterable, chunksize, bordermode=None):
r"""
generates successive n-sized chunks from ``iterable``.
Args:
iterable (list): input to iterate over
chunksize (int): size of sublist to return
bordermode (str): None, 'cycle', or 'replicate'
References:
http://stackoverflow.com/questions/434287/iterate-over-a-list-in-chunks
SeeAlso:
util_progress.get_num_chunks
CommandLine:
python -m utool.util_iter --exec-ichunks --show
Timeit:
>>> import utool as ut
>>> setup = ut.codeblock('''
from utool.util_iter import * # NOQA
iterable = list(range(100))
chunksize = 8
''')
>>> stmt_list = [
... 'list(ichunks(iterable, chunksize))',
... 'list(ichunks_noborder(iterable, chunksize))',
... 'list(ichunks_list(iterable, chunksize))',
... ]
>>> (passed, times, results) = ut.timeit_compare(stmt_list, setup)
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6, 7]
>>> chunksize = 3
>>> genresult = ichunks(iterable, chunksize)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7]]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = (1, 2, 3, 4, 5, 6, 7)
>>> chunksize = 3
>>> bordermode = 'cycle'
>>> genresult = ichunks(iterable, chunksize, bordermode)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7, 1, 2]]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = (1, 2, 3, 4, 5, 6, 7)
>>> chunksize = 3
>>> bordermode = 'replicate'
>>> genresult = ichunks(iterable, chunksize, bordermode)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7, 7, 7]]
"""
if bordermode is None:
return ichunks_noborder(iterable, chunksize)
elif bordermode == 'cycle':
return ichunks_cycle(iterable, chunksize)
elif bordermode == 'replicate':
return ichunks_replicate(iterable, chunksize)
else:
raise ValueError('unknown bordermode=%r' % (bordermode,)) | python | def ichunks(iterable, chunksize, bordermode=None):
r"""
generates successive n-sized chunks from ``iterable``.
Args:
iterable (list): input to iterate over
chunksize (int): size of sublist to return
bordermode (str): None, 'cycle', or 'replicate'
References:
http://stackoverflow.com/questions/434287/iterate-over-a-list-in-chunks
SeeAlso:
util_progress.get_num_chunks
CommandLine:
python -m utool.util_iter --exec-ichunks --show
Timeit:
>>> import utool as ut
>>> setup = ut.codeblock('''
from utool.util_iter import * # NOQA
iterable = list(range(100))
chunksize = 8
''')
>>> stmt_list = [
... 'list(ichunks(iterable, chunksize))',
... 'list(ichunks_noborder(iterable, chunksize))',
... 'list(ichunks_list(iterable, chunksize))',
... ]
>>> (passed, times, results) = ut.timeit_compare(stmt_list, setup)
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6, 7]
>>> chunksize = 3
>>> genresult = ichunks(iterable, chunksize)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7]]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = (1, 2, 3, 4, 5, 6, 7)
>>> chunksize = 3
>>> bordermode = 'cycle'
>>> genresult = ichunks(iterable, chunksize, bordermode)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7, 1, 2]]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = (1, 2, 3, 4, 5, 6, 7)
>>> chunksize = 3
>>> bordermode = 'replicate'
>>> genresult = ichunks(iterable, chunksize, bordermode)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7, 7, 7]]
"""
if bordermode is None:
return ichunks_noborder(iterable, chunksize)
elif bordermode == 'cycle':
return ichunks_cycle(iterable, chunksize)
elif bordermode == 'replicate':
return ichunks_replicate(iterable, chunksize)
else:
raise ValueError('unknown bordermode=%r' % (bordermode,)) | [
"def",
"ichunks",
"(",
"iterable",
",",
"chunksize",
",",
"bordermode",
"=",
"None",
")",
":",
"if",
"bordermode",
"is",
"None",
":",
"return",
"ichunks_noborder",
"(",
"iterable",
",",
"chunksize",
")",
"elif",
"bordermode",
"==",
"'cycle'",
":",
"return",
"ichunks_cycle",
"(",
"iterable",
",",
"chunksize",
")",
"elif",
"bordermode",
"==",
"'replicate'",
":",
"return",
"ichunks_replicate",
"(",
"iterable",
",",
"chunksize",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'unknown bordermode=%r'",
"%",
"(",
"bordermode",
",",
")",
")"
] | r"""
generates successive n-sized chunks from ``iterable``.
Args:
iterable (list): input to iterate over
chunksize (int): size of sublist to return
bordermode (str): None, 'cycle', or 'replicate'
References:
http://stackoverflow.com/questions/434287/iterate-over-a-list-in-chunks
SeeAlso:
util_progress.get_num_chunks
CommandLine:
python -m utool.util_iter --exec-ichunks --show
Timeit:
>>> import utool as ut
>>> setup = ut.codeblock('''
from utool.util_iter import * # NOQA
iterable = list(range(100))
chunksize = 8
''')
>>> stmt_list = [
... 'list(ichunks(iterable, chunksize))',
... 'list(ichunks_noborder(iterable, chunksize))',
... 'list(ichunks_list(iterable, chunksize))',
... ]
>>> (passed, times, results) = ut.timeit_compare(stmt_list, setup)
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = [1, 2, 3, 4, 5, 6, 7]
>>> chunksize = 3
>>> genresult = ichunks(iterable, chunksize)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7]]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = (1, 2, 3, 4, 5, 6, 7)
>>> chunksize = 3
>>> bordermode = 'cycle'
>>> genresult = ichunks(iterable, chunksize, bordermode)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7, 1, 2]]
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> iterable = (1, 2, 3, 4, 5, 6, 7)
>>> chunksize = 3
>>> bordermode = 'replicate'
>>> genresult = ichunks(iterable, chunksize, bordermode)
>>> result = list(genresult)
>>> print(result)
[[1, 2, 3], [4, 5, 6], [7, 7, 7]] | [
"r",
"generates",
"successive",
"n",
"-",
"sized",
"chunks",
"from",
"iterable",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L340-L411 | train |
Erotemic/utool | utool/util_iter.py | ichunks_list | def ichunks_list(list_, chunksize):
"""
input must be a list.
SeeAlso:
ichunks
References:
http://stackoverflow.com/questions/434287/iterate-over-a-list-in-chunks
"""
return (list_[ix:ix + chunksize] for ix in range(0, len(list_), chunksize)) | python | def ichunks_list(list_, chunksize):
"""
input must be a list.
SeeAlso:
ichunks
References:
http://stackoverflow.com/questions/434287/iterate-over-a-list-in-chunks
"""
return (list_[ix:ix + chunksize] for ix in range(0, len(list_), chunksize)) | [
"def",
"ichunks_list",
"(",
"list_",
",",
"chunksize",
")",
":",
"return",
"(",
"list_",
"[",
"ix",
":",
"ix",
"+",
"chunksize",
"]",
"for",
"ix",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"list_",
")",
",",
"chunksize",
")",
")"
] | input must be a list.
SeeAlso:
ichunks
References:
http://stackoverflow.com/questions/434287/iterate-over-a-list-in-chunks | [
"input",
"must",
"be",
"a",
"list",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L458-L468 | train |
Erotemic/utool | utool/util_iter.py | interleave | def interleave(args):
r"""
zip followed by flatten
Args:
args (tuple): tuple of lists to interleave
SeeAlso:
You may actually be better off doing something like this:
a, b, = args
ut.flatten(ut.bzip(a, b))
ut.flatten(ut.bzip([1, 2, 3], ['-']))
[1, '-', 2, '-', 3, '-']
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> args = ([1, 2, 3, 4, 5], ['A', 'B', 'C', 'D', 'E', 'F', 'G'])
>>> genresult = interleave(args)
>>> result = ut.repr4(list(genresult), nl=False)
>>> print(result)
[1, 'A', 2, 'B', 3, 'C', 4, 'D', 5, 'E']
"""
arg_iters = list(map(iter, args))
cycle_iter = it.cycle(arg_iters)
for iter_ in cycle_iter:
yield six.next(iter_) | python | def interleave(args):
r"""
zip followed by flatten
Args:
args (tuple): tuple of lists to interleave
SeeAlso:
You may actually be better off doing something like this:
a, b, = args
ut.flatten(ut.bzip(a, b))
ut.flatten(ut.bzip([1, 2, 3], ['-']))
[1, '-', 2, '-', 3, '-']
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> args = ([1, 2, 3, 4, 5], ['A', 'B', 'C', 'D', 'E', 'F', 'G'])
>>> genresult = interleave(args)
>>> result = ut.repr4(list(genresult), nl=False)
>>> print(result)
[1, 'A', 2, 'B', 3, 'C', 4, 'D', 5, 'E']
"""
arg_iters = list(map(iter, args))
cycle_iter = it.cycle(arg_iters)
for iter_ in cycle_iter:
yield six.next(iter_) | [
"def",
"interleave",
"(",
"args",
")",
":",
"arg_iters",
"=",
"list",
"(",
"map",
"(",
"iter",
",",
"args",
")",
")",
"cycle_iter",
"=",
"it",
".",
"cycle",
"(",
"arg_iters",
")",
"for",
"iter_",
"in",
"cycle_iter",
":",
"yield",
"six",
".",
"next",
"(",
"iter_",
")"
] | r"""
zip followed by flatten
Args:
args (tuple): tuple of lists to interleave
SeeAlso:
You may actually be better off doing something like this:
a, b, = args
ut.flatten(ut.bzip(a, b))
ut.flatten(ut.bzip([1, 2, 3], ['-']))
[1, '-', 2, '-', 3, '-']
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> args = ([1, 2, 3, 4, 5], ['A', 'B', 'C', 'D', 'E', 'F', 'G'])
>>> genresult = interleave(args)
>>> result = ut.repr4(list(genresult), nl=False)
>>> print(result)
[1, 'A', 2, 'B', 3, 'C', 4, 'D', 5, 'E'] | [
"r",
"zip",
"followed",
"by",
"flatten"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L477-L505 | train |
Erotemic/utool | utool/util_iter.py | random_product | def random_product(items, num=None, rng=None):
"""
Yields `num` items from the cartesian product of items in a random order.
Args:
items (list of sequences): items to get caresian product of
packed in a list or tuple.
(note this deviates from api of it.product)
Example:
import utool as ut
items = [(1, 2, 3), (4, 5, 6, 7)]
rng = 0
list(ut.random_product(items, rng=0))
list(ut.random_product(items, num=3, rng=0))
"""
import utool as ut
rng = ut.ensure_rng(rng, 'python')
seen = set()
items = [list(g) for g in items]
max_num = ut.prod(map(len, items))
if num is None:
num = max_num
if num > max_num:
raise ValueError('num exceedes maximum number of products')
# TODO: make this more efficient when num is large
if num > max_num // 2:
for prod in ut.shuffle(list(it.product(*items)), rng=rng):
yield prod
else:
while len(seen) < num:
# combo = tuple(sorted(rng.choice(items, size, replace=False)))
idxs = tuple(rng.randint(0, len(g) - 1) for g in items)
if idxs not in seen:
seen.add(idxs)
prod = tuple(g[x] for g, x in zip(items, idxs))
yield prod | python | def random_product(items, num=None, rng=None):
"""
Yields `num` items from the cartesian product of items in a random order.
Args:
items (list of sequences): items to get caresian product of
packed in a list or tuple.
(note this deviates from api of it.product)
Example:
import utool as ut
items = [(1, 2, 3), (4, 5, 6, 7)]
rng = 0
list(ut.random_product(items, rng=0))
list(ut.random_product(items, num=3, rng=0))
"""
import utool as ut
rng = ut.ensure_rng(rng, 'python')
seen = set()
items = [list(g) for g in items]
max_num = ut.prod(map(len, items))
if num is None:
num = max_num
if num > max_num:
raise ValueError('num exceedes maximum number of products')
# TODO: make this more efficient when num is large
if num > max_num // 2:
for prod in ut.shuffle(list(it.product(*items)), rng=rng):
yield prod
else:
while len(seen) < num:
# combo = tuple(sorted(rng.choice(items, size, replace=False)))
idxs = tuple(rng.randint(0, len(g) - 1) for g in items)
if idxs not in seen:
seen.add(idxs)
prod = tuple(g[x] for g, x in zip(items, idxs))
yield prod | [
"def",
"random_product",
"(",
"items",
",",
"num",
"=",
"None",
",",
"rng",
"=",
"None",
")",
":",
"import",
"utool",
"as",
"ut",
"rng",
"=",
"ut",
".",
"ensure_rng",
"(",
"rng",
",",
"'python'",
")",
"seen",
"=",
"set",
"(",
")",
"items",
"=",
"[",
"list",
"(",
"g",
")",
"for",
"g",
"in",
"items",
"]",
"max_num",
"=",
"ut",
".",
"prod",
"(",
"map",
"(",
"len",
",",
"items",
")",
")",
"if",
"num",
"is",
"None",
":",
"num",
"=",
"max_num",
"if",
"num",
">",
"max_num",
":",
"raise",
"ValueError",
"(",
"'num exceedes maximum number of products'",
")",
"# TODO: make this more efficient when num is large",
"if",
"num",
">",
"max_num",
"//",
"2",
":",
"for",
"prod",
"in",
"ut",
".",
"shuffle",
"(",
"list",
"(",
"it",
".",
"product",
"(",
"*",
"items",
")",
")",
",",
"rng",
"=",
"rng",
")",
":",
"yield",
"prod",
"else",
":",
"while",
"len",
"(",
"seen",
")",
"<",
"num",
":",
"# combo = tuple(sorted(rng.choice(items, size, replace=False)))",
"idxs",
"=",
"tuple",
"(",
"rng",
".",
"randint",
"(",
"0",
",",
"len",
"(",
"g",
")",
"-",
"1",
")",
"for",
"g",
"in",
"items",
")",
"if",
"idxs",
"not",
"in",
"seen",
":",
"seen",
".",
"add",
"(",
"idxs",
")",
"prod",
"=",
"tuple",
"(",
"g",
"[",
"x",
"]",
"for",
"g",
",",
"x",
"in",
"zip",
"(",
"items",
",",
"idxs",
")",
")",
"yield",
"prod"
] | Yields `num` items from the cartesian product of items in a random order.
Args:
items (list of sequences): items to get caresian product of
packed in a list or tuple.
(note this deviates from api of it.product)
Example:
import utool as ut
items = [(1, 2, 3), (4, 5, 6, 7)]
rng = 0
list(ut.random_product(items, rng=0))
list(ut.random_product(items, num=3, rng=0)) | [
"Yields",
"num",
"items",
"from",
"the",
"cartesian",
"product",
"of",
"items",
"in",
"a",
"random",
"order",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L512-L549 | train |
Erotemic/utool | utool/util_iter.py | random_combinations | def random_combinations(items, size, num=None, rng=None):
"""
Yields `num` combinations of length `size` from items in random order
Args:
items (?):
size (?):
num (None): (default = None)
rng (RandomState): random number generator(default = None)
Yields:
tuple: combo
CommandLine:
python -m utool.util_iter random_combinations
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> items = list(range(10))
>>> size = 3
>>> num = 5
>>> rng = 0
>>> combos = list(random_combinations(items, size, num, rng))
>>> result = ('combos = %s' % (ut.repr2(combos),))
>>> print(result)
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> items = list(zip(range(10), range(10)))
>>> size = 3
>>> num = 5
>>> rng = 0
>>> combos = list(random_combinations(items, size, num, rng))
>>> result = ('combos = %s' % (ut.repr2(combos),))
>>> print(result)
"""
import scipy.misc
import numpy as np
import utool as ut
rng = ut.ensure_rng(rng, impl='python')
num_ = np.inf if num is None else num
# Ensure we dont request more than is possible
n_max = int(scipy.misc.comb(len(items), size))
num_ = min(n_max, num_)
if num is not None and num_ > n_max // 2:
# If num is too big just generate all combinations and shuffle them
combos = list(it.combinations(items, size))
rng.shuffle(combos)
for combo in combos[:num]:
yield combo
else:
# Otherwise yield randomly until we get something we havent seen
items = list(items)
combos = set()
while len(combos) < num_:
# combo = tuple(sorted(rng.choice(items, size, replace=False)))
combo = tuple(sorted(rng.sample(items, size)))
if combo not in combos:
# TODO: store indices instead of combo values
combos.add(combo)
yield combo | python | def random_combinations(items, size, num=None, rng=None):
"""
Yields `num` combinations of length `size` from items in random order
Args:
items (?):
size (?):
num (None): (default = None)
rng (RandomState): random number generator(default = None)
Yields:
tuple: combo
CommandLine:
python -m utool.util_iter random_combinations
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> items = list(range(10))
>>> size = 3
>>> num = 5
>>> rng = 0
>>> combos = list(random_combinations(items, size, num, rng))
>>> result = ('combos = %s' % (ut.repr2(combos),))
>>> print(result)
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> items = list(zip(range(10), range(10)))
>>> size = 3
>>> num = 5
>>> rng = 0
>>> combos = list(random_combinations(items, size, num, rng))
>>> result = ('combos = %s' % (ut.repr2(combos),))
>>> print(result)
"""
import scipy.misc
import numpy as np
import utool as ut
rng = ut.ensure_rng(rng, impl='python')
num_ = np.inf if num is None else num
# Ensure we dont request more than is possible
n_max = int(scipy.misc.comb(len(items), size))
num_ = min(n_max, num_)
if num is not None and num_ > n_max // 2:
# If num is too big just generate all combinations and shuffle them
combos = list(it.combinations(items, size))
rng.shuffle(combos)
for combo in combos[:num]:
yield combo
else:
# Otherwise yield randomly until we get something we havent seen
items = list(items)
combos = set()
while len(combos) < num_:
# combo = tuple(sorted(rng.choice(items, size, replace=False)))
combo = tuple(sorted(rng.sample(items, size)))
if combo not in combos:
# TODO: store indices instead of combo values
combos.add(combo)
yield combo | [
"def",
"random_combinations",
"(",
"items",
",",
"size",
",",
"num",
"=",
"None",
",",
"rng",
"=",
"None",
")",
":",
"import",
"scipy",
".",
"misc",
"import",
"numpy",
"as",
"np",
"import",
"utool",
"as",
"ut",
"rng",
"=",
"ut",
".",
"ensure_rng",
"(",
"rng",
",",
"impl",
"=",
"'python'",
")",
"num_",
"=",
"np",
".",
"inf",
"if",
"num",
"is",
"None",
"else",
"num",
"# Ensure we dont request more than is possible",
"n_max",
"=",
"int",
"(",
"scipy",
".",
"misc",
".",
"comb",
"(",
"len",
"(",
"items",
")",
",",
"size",
")",
")",
"num_",
"=",
"min",
"(",
"n_max",
",",
"num_",
")",
"if",
"num",
"is",
"not",
"None",
"and",
"num_",
">",
"n_max",
"//",
"2",
":",
"# If num is too big just generate all combinations and shuffle them",
"combos",
"=",
"list",
"(",
"it",
".",
"combinations",
"(",
"items",
",",
"size",
")",
")",
"rng",
".",
"shuffle",
"(",
"combos",
")",
"for",
"combo",
"in",
"combos",
"[",
":",
"num",
"]",
":",
"yield",
"combo",
"else",
":",
"# Otherwise yield randomly until we get something we havent seen",
"items",
"=",
"list",
"(",
"items",
")",
"combos",
"=",
"set",
"(",
")",
"while",
"len",
"(",
"combos",
")",
"<",
"num_",
":",
"# combo = tuple(sorted(rng.choice(items, size, replace=False)))",
"combo",
"=",
"tuple",
"(",
"sorted",
"(",
"rng",
".",
"sample",
"(",
"items",
",",
"size",
")",
")",
")",
"if",
"combo",
"not",
"in",
"combos",
":",
"# TODO: store indices instead of combo values",
"combos",
".",
"add",
"(",
"combo",
")",
"yield",
"combo"
] | Yields `num` combinations of length `size` from items in random order
Args:
items (?):
size (?):
num (None): (default = None)
rng (RandomState): random number generator(default = None)
Yields:
tuple: combo
CommandLine:
python -m utool.util_iter random_combinations
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> items = list(range(10))
>>> size = 3
>>> num = 5
>>> rng = 0
>>> combos = list(random_combinations(items, size, num, rng))
>>> result = ('combos = %s' % (ut.repr2(combos),))
>>> print(result)
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_iter import * # NOQA
>>> import utool as ut
>>> items = list(zip(range(10), range(10)))
>>> size = 3
>>> num = 5
>>> rng = 0
>>> combos = list(random_combinations(items, size, num, rng))
>>> result = ('combos = %s' % (ut.repr2(combos),))
>>> print(result) | [
"Yields",
"num",
"combinations",
"of",
"length",
"size",
"from",
"items",
"in",
"random",
"order"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_iter.py#L552-L616 | train |
chriso/gauged | gauged/drivers/__init__.py | parse_dsn | def parse_dsn(dsn_string):
"""Parse a connection string and return the associated driver"""
dsn = urlparse(dsn_string)
scheme = dsn.scheme.split('+')[0]
username = password = host = port = None
host = dsn.netloc
if '@' in host:
username, host = host.split('@')
if ':' in username:
username, password = username.split(':')
password = unquote(password)
username = unquote(username)
if ':' in host:
host, port = host.split(':')
port = int(port)
database = dsn.path.split('?')[0][1:]
query = dsn.path.split('?')[1] if '?' in dsn.path else dsn.query
kwargs = dict(parse_qsl(query, True))
if scheme == 'sqlite':
return SQLiteDriver, [dsn.path], {}
elif scheme == 'mysql':
kwargs['user'] = username or 'root'
kwargs['db'] = database
if port:
kwargs['port'] = port
if host:
kwargs['host'] = host
if password:
kwargs['passwd'] = password
return MySQLDriver, [], kwargs
elif scheme == 'postgresql':
kwargs['user'] = username or 'postgres'
kwargs['database'] = database
if port:
kwargs['port'] = port
if 'unix_socket' in kwargs:
kwargs['host'] = kwargs.pop('unix_socket')
elif host:
kwargs['host'] = host
if password:
kwargs['password'] = password
return PostgreSQLDriver, [], kwargs
else:
raise ValueError('Unknown driver %s' % dsn_string) | python | def parse_dsn(dsn_string):
"""Parse a connection string and return the associated driver"""
dsn = urlparse(dsn_string)
scheme = dsn.scheme.split('+')[0]
username = password = host = port = None
host = dsn.netloc
if '@' in host:
username, host = host.split('@')
if ':' in username:
username, password = username.split(':')
password = unquote(password)
username = unquote(username)
if ':' in host:
host, port = host.split(':')
port = int(port)
database = dsn.path.split('?')[0][1:]
query = dsn.path.split('?')[1] if '?' in dsn.path else dsn.query
kwargs = dict(parse_qsl(query, True))
if scheme == 'sqlite':
return SQLiteDriver, [dsn.path], {}
elif scheme == 'mysql':
kwargs['user'] = username or 'root'
kwargs['db'] = database
if port:
kwargs['port'] = port
if host:
kwargs['host'] = host
if password:
kwargs['passwd'] = password
return MySQLDriver, [], kwargs
elif scheme == 'postgresql':
kwargs['user'] = username or 'postgres'
kwargs['database'] = database
if port:
kwargs['port'] = port
if 'unix_socket' in kwargs:
kwargs['host'] = kwargs.pop('unix_socket')
elif host:
kwargs['host'] = host
if password:
kwargs['password'] = password
return PostgreSQLDriver, [], kwargs
else:
raise ValueError('Unknown driver %s' % dsn_string) | [
"def",
"parse_dsn",
"(",
"dsn_string",
")",
":",
"dsn",
"=",
"urlparse",
"(",
"dsn_string",
")",
"scheme",
"=",
"dsn",
".",
"scheme",
".",
"split",
"(",
"'+'",
")",
"[",
"0",
"]",
"username",
"=",
"password",
"=",
"host",
"=",
"port",
"=",
"None",
"host",
"=",
"dsn",
".",
"netloc",
"if",
"'@'",
"in",
"host",
":",
"username",
",",
"host",
"=",
"host",
".",
"split",
"(",
"'@'",
")",
"if",
"':'",
"in",
"username",
":",
"username",
",",
"password",
"=",
"username",
".",
"split",
"(",
"':'",
")",
"password",
"=",
"unquote",
"(",
"password",
")",
"username",
"=",
"unquote",
"(",
"username",
")",
"if",
"':'",
"in",
"host",
":",
"host",
",",
"port",
"=",
"host",
".",
"split",
"(",
"':'",
")",
"port",
"=",
"int",
"(",
"port",
")",
"database",
"=",
"dsn",
".",
"path",
".",
"split",
"(",
"'?'",
")",
"[",
"0",
"]",
"[",
"1",
":",
"]",
"query",
"=",
"dsn",
".",
"path",
".",
"split",
"(",
"'?'",
")",
"[",
"1",
"]",
"if",
"'?'",
"in",
"dsn",
".",
"path",
"else",
"dsn",
".",
"query",
"kwargs",
"=",
"dict",
"(",
"parse_qsl",
"(",
"query",
",",
"True",
")",
")",
"if",
"scheme",
"==",
"'sqlite'",
":",
"return",
"SQLiteDriver",
",",
"[",
"dsn",
".",
"path",
"]",
",",
"{",
"}",
"elif",
"scheme",
"==",
"'mysql'",
":",
"kwargs",
"[",
"'user'",
"]",
"=",
"username",
"or",
"'root'",
"kwargs",
"[",
"'db'",
"]",
"=",
"database",
"if",
"port",
":",
"kwargs",
"[",
"'port'",
"]",
"=",
"port",
"if",
"host",
":",
"kwargs",
"[",
"'host'",
"]",
"=",
"host",
"if",
"password",
":",
"kwargs",
"[",
"'passwd'",
"]",
"=",
"password",
"return",
"MySQLDriver",
",",
"[",
"]",
",",
"kwargs",
"elif",
"scheme",
"==",
"'postgresql'",
":",
"kwargs",
"[",
"'user'",
"]",
"=",
"username",
"or",
"'postgres'",
"kwargs",
"[",
"'database'",
"]",
"=",
"database",
"if",
"port",
":",
"kwargs",
"[",
"'port'",
"]",
"=",
"port",
"if",
"'unix_socket'",
"in",
"kwargs",
":",
"kwargs",
"[",
"'host'",
"]",
"=",
"kwargs",
".",
"pop",
"(",
"'unix_socket'",
")",
"elif",
"host",
":",
"kwargs",
"[",
"'host'",
"]",
"=",
"host",
"if",
"password",
":",
"kwargs",
"[",
"'password'",
"]",
"=",
"password",
"return",
"PostgreSQLDriver",
",",
"[",
"]",
",",
"kwargs",
"else",
":",
"raise",
"ValueError",
"(",
"'Unknown driver %s'",
"%",
"dsn_string",
")"
] | Parse a connection string and return the associated driver | [
"Parse",
"a",
"connection",
"string",
"and",
"return",
"the",
"associated",
"driver"
] | cda3bba2f3e92ce2fb4aa92132dcc0e689bf7976 | https://github.com/chriso/gauged/blob/cda3bba2f3e92ce2fb4aa92132dcc0e689bf7976/gauged/drivers/__init__.py#L14-L57 | train |
Thermondo/django-heroku-connect | heroku_connect/db/router.py | HerokuConnectRouter.db_for_write | def db_for_write(self, model, **hints):
"""
Prevent write actions on read-only tables.
Raises:
WriteNotSupportedError: If models.sf_access is ``read_only``.
"""
try:
if model.sf_access == READ_ONLY:
raise WriteNotSupportedError("%r is a read-only model." % model)
except AttributeError:
pass
return None | python | def db_for_write(self, model, **hints):
"""
Prevent write actions on read-only tables.
Raises:
WriteNotSupportedError: If models.sf_access is ``read_only``.
"""
try:
if model.sf_access == READ_ONLY:
raise WriteNotSupportedError("%r is a read-only model." % model)
except AttributeError:
pass
return None | [
"def",
"db_for_write",
"(",
"self",
",",
"model",
",",
"*",
"*",
"hints",
")",
":",
"try",
":",
"if",
"model",
".",
"sf_access",
"==",
"READ_ONLY",
":",
"raise",
"WriteNotSupportedError",
"(",
"\"%r is a read-only model.\"",
"%",
"model",
")",
"except",
"AttributeError",
":",
"pass",
"return",
"None"
] | Prevent write actions on read-only tables.
Raises:
WriteNotSupportedError: If models.sf_access is ``read_only``. | [
"Prevent",
"write",
"actions",
"on",
"read",
"-",
"only",
"tables",
"."
] | f390e0fbf256ee79b30bb88f9a8c9576c6c8d9b5 | https://github.com/Thermondo/django-heroku-connect/blob/f390e0fbf256ee79b30bb88f9a8c9576c6c8d9b5/heroku_connect/db/router.py#L26-L39 | train |
product-definition-center/pdc-client | pdc_client/runner.py | Runner.run_hook | def run_hook(self, hook, *args, **kwargs):
"""
Loop over all plugins and invoke function `hook` with `args` and
`kwargs` in each of them. If the plugin does not have the function, it
is skipped.
"""
for plugin in self.raw_plugins:
if hasattr(plugin, hook):
self.logger.debug('Calling hook {0} in plugin {1}'.format(hook, plugin.__name__))
getattr(plugin, hook)(*args, **kwargs) | python | def run_hook(self, hook, *args, **kwargs):
"""
Loop over all plugins and invoke function `hook` with `args` and
`kwargs` in each of them. If the plugin does not have the function, it
is skipped.
"""
for plugin in self.raw_plugins:
if hasattr(plugin, hook):
self.logger.debug('Calling hook {0} in plugin {1}'.format(hook, plugin.__name__))
getattr(plugin, hook)(*args, **kwargs) | [
"def",
"run_hook",
"(",
"self",
",",
"hook",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"plugin",
"in",
"self",
".",
"raw_plugins",
":",
"if",
"hasattr",
"(",
"plugin",
",",
"hook",
")",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"'Calling hook {0} in plugin {1}'",
".",
"format",
"(",
"hook",
",",
"plugin",
".",
"__name__",
")",
")",
"getattr",
"(",
"plugin",
",",
"hook",
")",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | Loop over all plugins and invoke function `hook` with `args` and
`kwargs` in each of them. If the plugin does not have the function, it
is skipped. | [
"Loop",
"over",
"all",
"plugins",
"and",
"invoke",
"function",
"hook",
"with",
"args",
"and",
"kwargs",
"in",
"each",
"of",
"them",
".",
"If",
"the",
"plugin",
"does",
"not",
"have",
"the",
"function",
"it",
"is",
"skipped",
"."
] | 7236fd8b72e675ebb321bbe337289d9fbeb6119f | https://github.com/product-definition-center/pdc-client/blob/7236fd8b72e675ebb321bbe337289d9fbeb6119f/pdc_client/runner.py#L134-L143 | train |
glormph/msstitch | src/app/writers/tsv.py | write_tsv | def write_tsv(headerfields, features, outfn):
"""Writes header and generator of lines to tab separated file.
headerfields - list of field names in header in correct order
features - generates 1 list per line that belong to header
outfn - filename to output to. Overwritten if exists
"""
with open(outfn, 'w') as fp:
write_tsv_line_from_list(headerfields, fp)
for line in features:
write_tsv_line_from_list([str(line[field]) for field
in headerfields], fp) | python | def write_tsv(headerfields, features, outfn):
"""Writes header and generator of lines to tab separated file.
headerfields - list of field names in header in correct order
features - generates 1 list per line that belong to header
outfn - filename to output to. Overwritten if exists
"""
with open(outfn, 'w') as fp:
write_tsv_line_from_list(headerfields, fp)
for line in features:
write_tsv_line_from_list([str(line[field]) for field
in headerfields], fp) | [
"def",
"write_tsv",
"(",
"headerfields",
",",
"features",
",",
"outfn",
")",
":",
"with",
"open",
"(",
"outfn",
",",
"'w'",
")",
"as",
"fp",
":",
"write_tsv_line_from_list",
"(",
"headerfields",
",",
"fp",
")",
"for",
"line",
"in",
"features",
":",
"write_tsv_line_from_list",
"(",
"[",
"str",
"(",
"line",
"[",
"field",
"]",
")",
"for",
"field",
"in",
"headerfields",
"]",
",",
"fp",
")"
] | Writes header and generator of lines to tab separated file.
headerfields - list of field names in header in correct order
features - generates 1 list per line that belong to header
outfn - filename to output to. Overwritten if exists | [
"Writes",
"header",
"and",
"generator",
"of",
"lines",
"to",
"tab",
"separated",
"file",
"."
] | ded7e5cbd813d7797dc9d42805778266e59ff042 | https://github.com/glormph/msstitch/blob/ded7e5cbd813d7797dc9d42805778266e59ff042/src/app/writers/tsv.py#L1-L12 | train |
glormph/msstitch | src/app/writers/tsv.py | write_tsv_line_from_list | def write_tsv_line_from_list(linelist, outfp):
"""Utility method to convert list to tsv line with carriage return"""
line = '\t'.join(linelist)
outfp.write(line)
outfp.write('\n') | python | def write_tsv_line_from_list(linelist, outfp):
"""Utility method to convert list to tsv line with carriage return"""
line = '\t'.join(linelist)
outfp.write(line)
outfp.write('\n') | [
"def",
"write_tsv_line_from_list",
"(",
"linelist",
",",
"outfp",
")",
":",
"line",
"=",
"'\\t'",
".",
"join",
"(",
"linelist",
")",
"outfp",
".",
"write",
"(",
"line",
")",
"outfp",
".",
"write",
"(",
"'\\n'",
")"
] | Utility method to convert list to tsv line with carriage return | [
"Utility",
"method",
"to",
"convert",
"list",
"to",
"tsv",
"line",
"with",
"carriage",
"return"
] | ded7e5cbd813d7797dc9d42805778266e59ff042 | https://github.com/glormph/msstitch/blob/ded7e5cbd813d7797dc9d42805778266e59ff042/src/app/writers/tsv.py#L15-L19 | train |
Erotemic/utool | utool/util_str.py | replace_between_tags | def replace_between_tags(text, repl_, start_tag, end_tag=None):
r"""
Replaces text between sentinal lines in a block of text.
Args:
text (str):
repl_ (str):
start_tag (str):
end_tag (str): (default=None)
Returns:
str: new_text
CommandLine:
python -m utool.util_str --exec-replace_between_tags
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> text = ut.codeblock(
'''
class:
# <FOO>
bar
# </FOO>
baz
''')
>>> repl_ = 'spam'
>>> start_tag = '# <FOO>'
>>> end_tag = '# </FOO>'
>>> new_text = replace_between_tags(text, repl_, start_tag, end_tag)
>>> result = ('new_text =\n%s' % (str(new_text),))
>>> print(result)
new_text =
class:
# <FOO>
spam
# </FOO>
baz
"""
new_lines = []
editing = False
lines = text.split('\n')
for line in lines:
if not editing:
new_lines.append(line)
if line.strip().startswith(start_tag):
new_lines.append(repl_)
editing = True
if end_tag is not None and line.strip().startswith(end_tag):
editing = False
new_lines.append(line)
new_text = '\n'.join(new_lines)
return new_text | python | def replace_between_tags(text, repl_, start_tag, end_tag=None):
r"""
Replaces text between sentinal lines in a block of text.
Args:
text (str):
repl_ (str):
start_tag (str):
end_tag (str): (default=None)
Returns:
str: new_text
CommandLine:
python -m utool.util_str --exec-replace_between_tags
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> text = ut.codeblock(
'''
class:
# <FOO>
bar
# </FOO>
baz
''')
>>> repl_ = 'spam'
>>> start_tag = '# <FOO>'
>>> end_tag = '# </FOO>'
>>> new_text = replace_between_tags(text, repl_, start_tag, end_tag)
>>> result = ('new_text =\n%s' % (str(new_text),))
>>> print(result)
new_text =
class:
# <FOO>
spam
# </FOO>
baz
"""
new_lines = []
editing = False
lines = text.split('\n')
for line in lines:
if not editing:
new_lines.append(line)
if line.strip().startswith(start_tag):
new_lines.append(repl_)
editing = True
if end_tag is not None and line.strip().startswith(end_tag):
editing = False
new_lines.append(line)
new_text = '\n'.join(new_lines)
return new_text | [
"def",
"replace_between_tags",
"(",
"text",
",",
"repl_",
",",
"start_tag",
",",
"end_tag",
"=",
"None",
")",
":",
"new_lines",
"=",
"[",
"]",
"editing",
"=",
"False",
"lines",
"=",
"text",
".",
"split",
"(",
"'\\n'",
")",
"for",
"line",
"in",
"lines",
":",
"if",
"not",
"editing",
":",
"new_lines",
".",
"append",
"(",
"line",
")",
"if",
"line",
".",
"strip",
"(",
")",
".",
"startswith",
"(",
"start_tag",
")",
":",
"new_lines",
".",
"append",
"(",
"repl_",
")",
"editing",
"=",
"True",
"if",
"end_tag",
"is",
"not",
"None",
"and",
"line",
".",
"strip",
"(",
")",
".",
"startswith",
"(",
"end_tag",
")",
":",
"editing",
"=",
"False",
"new_lines",
".",
"append",
"(",
"line",
")",
"new_text",
"=",
"'\\n'",
".",
"join",
"(",
"new_lines",
")",
"return",
"new_text"
] | r"""
Replaces text between sentinal lines in a block of text.
Args:
text (str):
repl_ (str):
start_tag (str):
end_tag (str): (default=None)
Returns:
str: new_text
CommandLine:
python -m utool.util_str --exec-replace_between_tags
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> text = ut.codeblock(
'''
class:
# <FOO>
bar
# </FOO>
baz
''')
>>> repl_ = 'spam'
>>> start_tag = '# <FOO>'
>>> end_tag = '# </FOO>'
>>> new_text = replace_between_tags(text, repl_, start_tag, end_tag)
>>> result = ('new_text =\n%s' % (str(new_text),))
>>> print(result)
new_text =
class:
# <FOO>
spam
# </FOO>
baz | [
"r",
"Replaces",
"text",
"between",
"sentinal",
"lines",
"in",
"a",
"block",
"of",
"text",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L75-L128 | train |
Erotemic/utool | utool/util_str.py | theta_str | def theta_str(theta, taustr=TAUSTR, fmtstr='{coeff:,.1f}{taustr}'):
r"""
Format theta so it is interpretable in base 10
Args:
theta (float) angle in radians
taustr (str): default 2pi
Returns:
str : theta_str - the angle in tau units
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> theta = 3.1415
>>> result = theta_str(theta)
>>> print(result)
0.5*2pi
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> theta = 6.9932
>>> taustr = 'tau'
>>> result = theta_str(theta, taustr)
>>> print(result)
1.1tau
"""
coeff = theta / TAU
theta_str = fmtstr.format(coeff=coeff, taustr=taustr)
return theta_str | python | def theta_str(theta, taustr=TAUSTR, fmtstr='{coeff:,.1f}{taustr}'):
r"""
Format theta so it is interpretable in base 10
Args:
theta (float) angle in radians
taustr (str): default 2pi
Returns:
str : theta_str - the angle in tau units
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> theta = 3.1415
>>> result = theta_str(theta)
>>> print(result)
0.5*2pi
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> theta = 6.9932
>>> taustr = 'tau'
>>> result = theta_str(theta, taustr)
>>> print(result)
1.1tau
"""
coeff = theta / TAU
theta_str = fmtstr.format(coeff=coeff, taustr=taustr)
return theta_str | [
"def",
"theta_str",
"(",
"theta",
",",
"taustr",
"=",
"TAUSTR",
",",
"fmtstr",
"=",
"'{coeff:,.1f}{taustr}'",
")",
":",
"coeff",
"=",
"theta",
"/",
"TAU",
"theta_str",
"=",
"fmtstr",
".",
"format",
"(",
"coeff",
"=",
"coeff",
",",
"taustr",
"=",
"taustr",
")",
"return",
"theta_str"
] | r"""
Format theta so it is interpretable in base 10
Args:
theta (float) angle in radians
taustr (str): default 2pi
Returns:
str : theta_str - the angle in tau units
Example1:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> theta = 3.1415
>>> result = theta_str(theta)
>>> print(result)
0.5*2pi
Example2:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> theta = 6.9932
>>> taustr = 'tau'
>>> result = theta_str(theta, taustr)
>>> print(result)
1.1tau | [
"r",
"Format",
"theta",
"so",
"it",
"is",
"interpretable",
"in",
"base",
"10"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L131-L161 | train |
Erotemic/utool | utool/util_str.py | bbox_str | def bbox_str(bbox, pad=4, sep=', '):
r""" makes a string from an integer bounding box """
if bbox is None:
return 'None'
fmtstr = sep.join(['%' + six.text_type(pad) + 'd'] * 4)
return '(' + fmtstr % tuple(bbox) + ')' | python | def bbox_str(bbox, pad=4, sep=', '):
r""" makes a string from an integer bounding box """
if bbox is None:
return 'None'
fmtstr = sep.join(['%' + six.text_type(pad) + 'd'] * 4)
return '(' + fmtstr % tuple(bbox) + ')' | [
"def",
"bbox_str",
"(",
"bbox",
",",
"pad",
"=",
"4",
",",
"sep",
"=",
"', '",
")",
":",
"if",
"bbox",
"is",
"None",
":",
"return",
"'None'",
"fmtstr",
"=",
"sep",
".",
"join",
"(",
"[",
"'%'",
"+",
"six",
".",
"text_type",
"(",
"pad",
")",
"+",
"'d'",
"]",
"*",
"4",
")",
"return",
"'('",
"+",
"fmtstr",
"%",
"tuple",
"(",
"bbox",
")",
"+",
"')'"
] | r""" makes a string from an integer bounding box | [
"r",
"makes",
"a",
"string",
"from",
"an",
"integer",
"bounding",
"box"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L164-L169 | train |
Erotemic/utool | utool/util_str.py | verts_str | def verts_str(verts, pad=1):
r""" makes a string from a list of integer verticies """
if verts is None:
return 'None'
fmtstr = ', '.join(['%' + six.text_type(pad) + 'd' +
', %' + six.text_type(pad) + 'd'] * 1)
return ', '.join(['(' + fmtstr % vert + ')' for vert in verts]) | python | def verts_str(verts, pad=1):
r""" makes a string from a list of integer verticies """
if verts is None:
return 'None'
fmtstr = ', '.join(['%' + six.text_type(pad) + 'd' +
', %' + six.text_type(pad) + 'd'] * 1)
return ', '.join(['(' + fmtstr % vert + ')' for vert in verts]) | [
"def",
"verts_str",
"(",
"verts",
",",
"pad",
"=",
"1",
")",
":",
"if",
"verts",
"is",
"None",
":",
"return",
"'None'",
"fmtstr",
"=",
"', '",
".",
"join",
"(",
"[",
"'%'",
"+",
"six",
".",
"text_type",
"(",
"pad",
")",
"+",
"'d'",
"+",
"', %'",
"+",
"six",
".",
"text_type",
"(",
"pad",
")",
"+",
"'d'",
"]",
"*",
"1",
")",
"return",
"', '",
".",
"join",
"(",
"[",
"'('",
"+",
"fmtstr",
"%",
"vert",
"+",
"')'",
"for",
"vert",
"in",
"verts",
"]",
")"
] | r""" makes a string from a list of integer verticies | [
"r",
"makes",
"a",
"string",
"from",
"a",
"list",
"of",
"integer",
"verticies"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L172-L178 | train |
Erotemic/utool | utool/util_str.py | remove_chars | def remove_chars(str_, char_list):
"""
removes all chars in char_list from str_
Args:
str_ (str):
char_list (list):
Returns:
str: outstr
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> str_ = '1, 2, 3, 4'
>>> char_list = [',']
>>> result = remove_chars(str_, char_list)
>>> print(result)
1 2 3 4
"""
outstr = str_[:]
for char in char_list:
outstr = outstr.replace(char, '')
return outstr | python | def remove_chars(str_, char_list):
"""
removes all chars in char_list from str_
Args:
str_ (str):
char_list (list):
Returns:
str: outstr
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> str_ = '1, 2, 3, 4'
>>> char_list = [',']
>>> result = remove_chars(str_, char_list)
>>> print(result)
1 2 3 4
"""
outstr = str_[:]
for char in char_list:
outstr = outstr.replace(char, '')
return outstr | [
"def",
"remove_chars",
"(",
"str_",
",",
"char_list",
")",
":",
"outstr",
"=",
"str_",
"[",
":",
"]",
"for",
"char",
"in",
"char_list",
":",
"outstr",
"=",
"outstr",
".",
"replace",
"(",
"char",
",",
"''",
")",
"return",
"outstr"
] | removes all chars in char_list from str_
Args:
str_ (str):
char_list (list):
Returns:
str: outstr
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> str_ = '1, 2, 3, 4'
>>> char_list = [',']
>>> result = remove_chars(str_, char_list)
>>> print(result)
1 2 3 4 | [
"removes",
"all",
"chars",
"in",
"char_list",
"from",
"str_"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L195-L218 | train |
Erotemic/utool | utool/util_str.py | get_minimum_indentation | def get_minimum_indentation(text):
r"""
returns the number of preceding spaces
Args:
text (str): unicode text
Returns:
int: indentation
CommandLine:
python -m utool.util_str --exec-get_minimum_indentation --show
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> text = ' foo\n bar'
>>> result = get_minimum_indentation(text)
>>> print(result)
3
"""
lines = text.split('\n')
indentations = [get_indentation(line_)
for line_ in lines if len(line_.strip()) > 0]
if len(indentations) == 0:
return 0
return min(indentations) | python | def get_minimum_indentation(text):
r"""
returns the number of preceding spaces
Args:
text (str): unicode text
Returns:
int: indentation
CommandLine:
python -m utool.util_str --exec-get_minimum_indentation --show
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> text = ' foo\n bar'
>>> result = get_minimum_indentation(text)
>>> print(result)
3
"""
lines = text.split('\n')
indentations = [get_indentation(line_)
for line_ in lines if len(line_.strip()) > 0]
if len(indentations) == 0:
return 0
return min(indentations) | [
"def",
"get_minimum_indentation",
"(",
"text",
")",
":",
"lines",
"=",
"text",
".",
"split",
"(",
"'\\n'",
")",
"indentations",
"=",
"[",
"get_indentation",
"(",
"line_",
")",
"for",
"line_",
"in",
"lines",
"if",
"len",
"(",
"line_",
".",
"strip",
"(",
")",
")",
">",
"0",
"]",
"if",
"len",
"(",
"indentations",
")",
"==",
"0",
":",
"return",
"0",
"return",
"min",
"(",
"indentations",
")"
] | r"""
returns the number of preceding spaces
Args:
text (str): unicode text
Returns:
int: indentation
CommandLine:
python -m utool.util_str --exec-get_minimum_indentation --show
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> text = ' foo\n bar'
>>> result = get_minimum_indentation(text)
>>> print(result)
3 | [
"r",
"returns",
"the",
"number",
"of",
"preceding",
"spaces"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L228-L255 | train |
Erotemic/utool | utool/util_str.py | indentjoin | def indentjoin(strlist, indent='\n ', suffix=''):
r"""
Convineince indentjoin
similar to '\n '.join(strlist) but indent is also prefixed
Args:
strlist (?):
indent (str):
suffix (str):
Returns:
str: joined list
"""
indent_ = indent
strlist = list(strlist)
if len(strlist) == 0:
return ''
return indent_ + indent_.join([six.text_type(str_) + suffix
for str_ in strlist]) | python | def indentjoin(strlist, indent='\n ', suffix=''):
r"""
Convineince indentjoin
similar to '\n '.join(strlist) but indent is also prefixed
Args:
strlist (?):
indent (str):
suffix (str):
Returns:
str: joined list
"""
indent_ = indent
strlist = list(strlist)
if len(strlist) == 0:
return ''
return indent_ + indent_.join([six.text_type(str_) + suffix
for str_ in strlist]) | [
"def",
"indentjoin",
"(",
"strlist",
",",
"indent",
"=",
"'\\n '",
",",
"suffix",
"=",
"''",
")",
":",
"indent_",
"=",
"indent",
"strlist",
"=",
"list",
"(",
"strlist",
")",
"if",
"len",
"(",
"strlist",
")",
"==",
"0",
":",
"return",
"''",
"return",
"indent_",
"+",
"indent_",
".",
"join",
"(",
"[",
"six",
".",
"text_type",
"(",
"str_",
")",
"+",
"suffix",
"for",
"str_",
"in",
"strlist",
"]",
")"
] | r"""
Convineince indentjoin
similar to '\n '.join(strlist) but indent is also prefixed
Args:
strlist (?):
indent (str):
suffix (str):
Returns:
str: joined list | [
"r",
"Convineince",
"indentjoin"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L357-L376 | train |
Erotemic/utool | utool/util_str.py | truncate_str | def truncate_str(str_, maxlen=110, truncmsg=' ~~~TRUNCATED~~~ '):
"""
Removes the middle part of any string over maxlen characters.
"""
if NO_TRUNCATE:
return str_
if maxlen is None or maxlen == -1 or len(str_) < maxlen:
return str_
else:
maxlen_ = maxlen - len(truncmsg)
lowerb = int(maxlen_ * .8)
upperb = maxlen_ - lowerb
tup = (str_[:lowerb], truncmsg, str_[-upperb:])
return ''.join(tup) | python | def truncate_str(str_, maxlen=110, truncmsg=' ~~~TRUNCATED~~~ '):
"""
Removes the middle part of any string over maxlen characters.
"""
if NO_TRUNCATE:
return str_
if maxlen is None or maxlen == -1 or len(str_) < maxlen:
return str_
else:
maxlen_ = maxlen - len(truncmsg)
lowerb = int(maxlen_ * .8)
upperb = maxlen_ - lowerb
tup = (str_[:lowerb], truncmsg, str_[-upperb:])
return ''.join(tup) | [
"def",
"truncate_str",
"(",
"str_",
",",
"maxlen",
"=",
"110",
",",
"truncmsg",
"=",
"' ~~~TRUNCATED~~~ '",
")",
":",
"if",
"NO_TRUNCATE",
":",
"return",
"str_",
"if",
"maxlen",
"is",
"None",
"or",
"maxlen",
"==",
"-",
"1",
"or",
"len",
"(",
"str_",
")",
"<",
"maxlen",
":",
"return",
"str_",
"else",
":",
"maxlen_",
"=",
"maxlen",
"-",
"len",
"(",
"truncmsg",
")",
"lowerb",
"=",
"int",
"(",
"maxlen_",
"*",
".8",
")",
"upperb",
"=",
"maxlen_",
"-",
"lowerb",
"tup",
"=",
"(",
"str_",
"[",
":",
"lowerb",
"]",
",",
"truncmsg",
",",
"str_",
"[",
"-",
"upperb",
":",
"]",
")",
"return",
"''",
".",
"join",
"(",
"tup",
")"
] | Removes the middle part of any string over maxlen characters. | [
"Removes",
"the",
"middle",
"part",
"of",
"any",
"string",
"over",
"maxlen",
"characters",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L379-L392 | train |
Erotemic/utool | utool/util_str.py | packstr | def packstr(instr, textwidth=160, breakchars=' ', break_words=True,
newline_prefix='', indentation='', nlprefix=None, wordsep=' ',
remove_newlines=True):
""" alias for pack_into. has more up to date kwargs """
if not isinstance(instr, six.string_types):
instr = repr(instr)
if nlprefix is not None:
newline_prefix = nlprefix
str_ = pack_into(instr, textwidth, breakchars, break_words, newline_prefix,
wordsep, remove_newlines)
if indentation != '':
str_ = indent(str_, indentation)
return str_ | python | def packstr(instr, textwidth=160, breakchars=' ', break_words=True,
newline_prefix='', indentation='', nlprefix=None, wordsep=' ',
remove_newlines=True):
""" alias for pack_into. has more up to date kwargs """
if not isinstance(instr, six.string_types):
instr = repr(instr)
if nlprefix is not None:
newline_prefix = nlprefix
str_ = pack_into(instr, textwidth, breakchars, break_words, newline_prefix,
wordsep, remove_newlines)
if indentation != '':
str_ = indent(str_, indentation)
return str_ | [
"def",
"packstr",
"(",
"instr",
",",
"textwidth",
"=",
"160",
",",
"breakchars",
"=",
"' '",
",",
"break_words",
"=",
"True",
",",
"newline_prefix",
"=",
"''",
",",
"indentation",
"=",
"''",
",",
"nlprefix",
"=",
"None",
",",
"wordsep",
"=",
"' '",
",",
"remove_newlines",
"=",
"True",
")",
":",
"if",
"not",
"isinstance",
"(",
"instr",
",",
"six",
".",
"string_types",
")",
":",
"instr",
"=",
"repr",
"(",
"instr",
")",
"if",
"nlprefix",
"is",
"not",
"None",
":",
"newline_prefix",
"=",
"nlprefix",
"str_",
"=",
"pack_into",
"(",
"instr",
",",
"textwidth",
",",
"breakchars",
",",
"break_words",
",",
"newline_prefix",
",",
"wordsep",
",",
"remove_newlines",
")",
"if",
"indentation",
"!=",
"''",
":",
"str_",
"=",
"indent",
"(",
"str_",
",",
"indentation",
")",
"return",
"str_"
] | alias for pack_into. has more up to date kwargs | [
"alias",
"for",
"pack_into",
".",
"has",
"more",
"up",
"to",
"date",
"kwargs"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L468-L480 | train |
Erotemic/utool | utool/util_str.py | byte_str | def byte_str(nBytes, unit='bytes', precision=2):
"""
representing the number of bytes with the chosen unit
Returns:
str
"""
#return (nBytes * ureg.byte).to(unit.upper())
if unit.lower().startswith('b'):
nUnit = nBytes
elif unit.lower().startswith('k'):
nUnit = nBytes / (2.0 ** 10)
elif unit.lower().startswith('m'):
nUnit = nBytes / (2.0 ** 20)
elif unit.lower().startswith('g'):
nUnit = nBytes / (2.0 ** 30)
elif unit.lower().startswith('t'):
nUnit = nBytes / (2.0 ** 40)
else:
raise NotImplementedError('unknown nBytes=%r unit=%r' % (nBytes, unit))
return repr2(nUnit, precision=precision) + ' ' + unit | python | def byte_str(nBytes, unit='bytes', precision=2):
"""
representing the number of bytes with the chosen unit
Returns:
str
"""
#return (nBytes * ureg.byte).to(unit.upper())
if unit.lower().startswith('b'):
nUnit = nBytes
elif unit.lower().startswith('k'):
nUnit = nBytes / (2.0 ** 10)
elif unit.lower().startswith('m'):
nUnit = nBytes / (2.0 ** 20)
elif unit.lower().startswith('g'):
nUnit = nBytes / (2.0 ** 30)
elif unit.lower().startswith('t'):
nUnit = nBytes / (2.0 ** 40)
else:
raise NotImplementedError('unknown nBytes=%r unit=%r' % (nBytes, unit))
return repr2(nUnit, precision=precision) + ' ' + unit | [
"def",
"byte_str",
"(",
"nBytes",
",",
"unit",
"=",
"'bytes'",
",",
"precision",
"=",
"2",
")",
":",
"#return (nBytes * ureg.byte).to(unit.upper())",
"if",
"unit",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"'b'",
")",
":",
"nUnit",
"=",
"nBytes",
"elif",
"unit",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"'k'",
")",
":",
"nUnit",
"=",
"nBytes",
"/",
"(",
"2.0",
"**",
"10",
")",
"elif",
"unit",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"'m'",
")",
":",
"nUnit",
"=",
"nBytes",
"/",
"(",
"2.0",
"**",
"20",
")",
"elif",
"unit",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"'g'",
")",
":",
"nUnit",
"=",
"nBytes",
"/",
"(",
"2.0",
"**",
"30",
")",
"elif",
"unit",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"'t'",
")",
":",
"nUnit",
"=",
"nBytes",
"/",
"(",
"2.0",
"**",
"40",
")",
"else",
":",
"raise",
"NotImplementedError",
"(",
"'unknown nBytes=%r unit=%r'",
"%",
"(",
"nBytes",
",",
"unit",
")",
")",
"return",
"repr2",
"(",
"nUnit",
",",
"precision",
"=",
"precision",
")",
"+",
"' '",
"+",
"unit"
] | representing the number of bytes with the chosen unit
Returns:
str | [
"representing",
"the",
"number",
"of",
"bytes",
"with",
"the",
"chosen",
"unit"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L671-L691 | train |
Erotemic/utool | utool/util_str.py | func_str | def func_str(func, args=[], kwargs={}, type_aliases=[], packed=False,
packkw=None, truncate=False):
"""
string representation of function definition
Returns:
str: a representation of func with args, kwargs, and type_aliases
Args:
func (function):
args (list): argument values (default = [])
kwargs (dict): kwargs values (default = {})
type_aliases (list): (default = [])
packed (bool): (default = False)
packkw (None): (default = None)
Returns:
str: func_str
CommandLine:
python -m utool.util_str --exec-func_str
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = byte_str
>>> args = [1024, 'MB']
>>> kwargs = dict(precision=2)
>>> type_aliases = []
>>> packed = False
>>> packkw = None
>>> _str = func_str(func, args, kwargs, type_aliases, packed, packkw)
>>> result = _str
>>> print(result)
byte_str(1024, 'MB', precision=2)
"""
import utool as ut
# if truncate:
# truncatekw = {'maxlen': 20}
# else:
truncatekw = {}
argrepr_list = ([] if args is None else
ut.get_itemstr_list(args, nl=False, truncate=truncate,
truncatekw=truncatekw))
kwrepr_list = ([] if kwargs is None else
ut.dict_itemstr_list(kwargs, explicit=True, nl=False,
truncate=truncate,
truncatekw=truncatekw))
repr_list = argrepr_list + kwrepr_list
argskwargs_str = ', '.join(repr_list)
_str = '%s(%s)' % (meta_util_six.get_funcname(func), argskwargs_str)
if packed:
packkw_ = dict(textwidth=80, nlprefix=' ', break_words=False)
if packkw is not None:
packkw_.update(packkw_)
_str = packstr(_str, **packkw_)
return _str | python | def func_str(func, args=[], kwargs={}, type_aliases=[], packed=False,
packkw=None, truncate=False):
"""
string representation of function definition
Returns:
str: a representation of func with args, kwargs, and type_aliases
Args:
func (function):
args (list): argument values (default = [])
kwargs (dict): kwargs values (default = {})
type_aliases (list): (default = [])
packed (bool): (default = False)
packkw (None): (default = None)
Returns:
str: func_str
CommandLine:
python -m utool.util_str --exec-func_str
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = byte_str
>>> args = [1024, 'MB']
>>> kwargs = dict(precision=2)
>>> type_aliases = []
>>> packed = False
>>> packkw = None
>>> _str = func_str(func, args, kwargs, type_aliases, packed, packkw)
>>> result = _str
>>> print(result)
byte_str(1024, 'MB', precision=2)
"""
import utool as ut
# if truncate:
# truncatekw = {'maxlen': 20}
# else:
truncatekw = {}
argrepr_list = ([] if args is None else
ut.get_itemstr_list(args, nl=False, truncate=truncate,
truncatekw=truncatekw))
kwrepr_list = ([] if kwargs is None else
ut.dict_itemstr_list(kwargs, explicit=True, nl=False,
truncate=truncate,
truncatekw=truncatekw))
repr_list = argrepr_list + kwrepr_list
argskwargs_str = ', '.join(repr_list)
_str = '%s(%s)' % (meta_util_six.get_funcname(func), argskwargs_str)
if packed:
packkw_ = dict(textwidth=80, nlprefix=' ', break_words=False)
if packkw is not None:
packkw_.update(packkw_)
_str = packstr(_str, **packkw_)
return _str | [
"def",
"func_str",
"(",
"func",
",",
"args",
"=",
"[",
"]",
",",
"kwargs",
"=",
"{",
"}",
",",
"type_aliases",
"=",
"[",
"]",
",",
"packed",
"=",
"False",
",",
"packkw",
"=",
"None",
",",
"truncate",
"=",
"False",
")",
":",
"import",
"utool",
"as",
"ut",
"# if truncate:",
"# truncatekw = {'maxlen': 20}",
"# else:",
"truncatekw",
"=",
"{",
"}",
"argrepr_list",
"=",
"(",
"[",
"]",
"if",
"args",
"is",
"None",
"else",
"ut",
".",
"get_itemstr_list",
"(",
"args",
",",
"nl",
"=",
"False",
",",
"truncate",
"=",
"truncate",
",",
"truncatekw",
"=",
"truncatekw",
")",
")",
"kwrepr_list",
"=",
"(",
"[",
"]",
"if",
"kwargs",
"is",
"None",
"else",
"ut",
".",
"dict_itemstr_list",
"(",
"kwargs",
",",
"explicit",
"=",
"True",
",",
"nl",
"=",
"False",
",",
"truncate",
"=",
"truncate",
",",
"truncatekw",
"=",
"truncatekw",
")",
")",
"repr_list",
"=",
"argrepr_list",
"+",
"kwrepr_list",
"argskwargs_str",
"=",
"', '",
".",
"join",
"(",
"repr_list",
")",
"_str",
"=",
"'%s(%s)'",
"%",
"(",
"meta_util_six",
".",
"get_funcname",
"(",
"func",
")",
",",
"argskwargs_str",
")",
"if",
"packed",
":",
"packkw_",
"=",
"dict",
"(",
"textwidth",
"=",
"80",
",",
"nlprefix",
"=",
"' '",
",",
"break_words",
"=",
"False",
")",
"if",
"packkw",
"is",
"not",
"None",
":",
"packkw_",
".",
"update",
"(",
"packkw_",
")",
"_str",
"=",
"packstr",
"(",
"_str",
",",
"*",
"*",
"packkw_",
")",
"return",
"_str"
] | string representation of function definition
Returns:
str: a representation of func with args, kwargs, and type_aliases
Args:
func (function):
args (list): argument values (default = [])
kwargs (dict): kwargs values (default = {})
type_aliases (list): (default = [])
packed (bool): (default = False)
packkw (None): (default = None)
Returns:
str: func_str
CommandLine:
python -m utool.util_str --exec-func_str
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = byte_str
>>> args = [1024, 'MB']
>>> kwargs = dict(precision=2)
>>> type_aliases = []
>>> packed = False
>>> packkw = None
>>> _str = func_str(func, args, kwargs, type_aliases, packed, packkw)
>>> result = _str
>>> print(result)
byte_str(1024, 'MB', precision=2) | [
"string",
"representation",
"of",
"function",
"definition"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L720-L778 | train |
Erotemic/utool | utool/util_str.py | func_defsig | def func_defsig(func, with_name=True):
"""
String of function definition signature
Args:
func (function): live python function
Returns:
str: defsig
CommandLine:
python -m utool.util_str --exec-func_defsig
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = func_str
>>> defsig = func_defsig(func)
>>> result = str(defsig)
>>> print(result)
func_str(func, args=[], kwargs={}, type_aliases=[], packed=False, packkw=None, truncate=False)
"""
import inspect
argspec = inspect.getargspec(func)
(args, varargs, varkw, defaults) = argspec
defsig = inspect.formatargspec(*argspec)
if with_name:
defsig = get_callable_name(func) + defsig
return defsig | python | def func_defsig(func, with_name=True):
"""
String of function definition signature
Args:
func (function): live python function
Returns:
str: defsig
CommandLine:
python -m utool.util_str --exec-func_defsig
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = func_str
>>> defsig = func_defsig(func)
>>> result = str(defsig)
>>> print(result)
func_str(func, args=[], kwargs={}, type_aliases=[], packed=False, packkw=None, truncate=False)
"""
import inspect
argspec = inspect.getargspec(func)
(args, varargs, varkw, defaults) = argspec
defsig = inspect.formatargspec(*argspec)
if with_name:
defsig = get_callable_name(func) + defsig
return defsig | [
"def",
"func_defsig",
"(",
"func",
",",
"with_name",
"=",
"True",
")",
":",
"import",
"inspect",
"argspec",
"=",
"inspect",
".",
"getargspec",
"(",
"func",
")",
"(",
"args",
",",
"varargs",
",",
"varkw",
",",
"defaults",
")",
"=",
"argspec",
"defsig",
"=",
"inspect",
".",
"formatargspec",
"(",
"*",
"argspec",
")",
"if",
"with_name",
":",
"defsig",
"=",
"get_callable_name",
"(",
"func",
")",
"+",
"defsig",
"return",
"defsig"
] | String of function definition signature
Args:
func (function): live python function
Returns:
str: defsig
CommandLine:
python -m utool.util_str --exec-func_defsig
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = func_str
>>> defsig = func_defsig(func)
>>> result = str(defsig)
>>> print(result)
func_str(func, args=[], kwargs={}, type_aliases=[], packed=False, packkw=None, truncate=False) | [
"String",
"of",
"function",
"definition",
"signature"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L781-L809 | train |
Erotemic/utool | utool/util_str.py | func_callsig | def func_callsig(func, with_name=True):
"""
String of function call signature
Args:
func (function): live python function
Returns:
str: callsig
CommandLine:
python -m utool.util_str --exec-func_callsig
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = func_str
>>> callsig = func_callsig(func)
>>> result = str(callsig)
>>> print(result)
func_str(func, args, kwargs, type_aliases, packed, packkw, truncate)
"""
import inspect
argspec = inspect.getargspec(func)
(args, varargs, varkw, defaults) = argspec
callsig = inspect.formatargspec(*argspec[0:3])
if with_name:
callsig = get_callable_name(func) + callsig
return callsig | python | def func_callsig(func, with_name=True):
"""
String of function call signature
Args:
func (function): live python function
Returns:
str: callsig
CommandLine:
python -m utool.util_str --exec-func_callsig
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = func_str
>>> callsig = func_callsig(func)
>>> result = str(callsig)
>>> print(result)
func_str(func, args, kwargs, type_aliases, packed, packkw, truncate)
"""
import inspect
argspec = inspect.getargspec(func)
(args, varargs, varkw, defaults) = argspec
callsig = inspect.formatargspec(*argspec[0:3])
if with_name:
callsig = get_callable_name(func) + callsig
return callsig | [
"def",
"func_callsig",
"(",
"func",
",",
"with_name",
"=",
"True",
")",
":",
"import",
"inspect",
"argspec",
"=",
"inspect",
".",
"getargspec",
"(",
"func",
")",
"(",
"args",
",",
"varargs",
",",
"varkw",
",",
"defaults",
")",
"=",
"argspec",
"callsig",
"=",
"inspect",
".",
"formatargspec",
"(",
"*",
"argspec",
"[",
"0",
":",
"3",
"]",
")",
"if",
"with_name",
":",
"callsig",
"=",
"get_callable_name",
"(",
"func",
")",
"+",
"callsig",
"return",
"callsig"
] | String of function call signature
Args:
func (function): live python function
Returns:
str: callsig
CommandLine:
python -m utool.util_str --exec-func_callsig
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = func_str
>>> callsig = func_callsig(func)
>>> result = str(callsig)
>>> print(result)
func_str(func, args, kwargs, type_aliases, packed, packkw, truncate) | [
"String",
"of",
"function",
"call",
"signature"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L812-L840 | train |
Erotemic/utool | utool/util_str.py | numpy_str | def numpy_str(arr, strvals=False, precision=None, pr=None,
force_dtype=False,
with_dtype=None, suppress_small=None, max_line_width=None,
threshold=None, **kwargs):
"""
suppress_small = False turns off scientific representation
"""
# strvals = kwargs.get('strvals', False)
itemsep = kwargs.get('itemsep', ' ')
# precision = kwargs.get('precision', None)
# suppress_small = kwargs.get('supress_small', None)
# max_line_width = kwargs.get('max_line_width', None)
# with_dtype = kwargs.get('with_dtype', False)
newlines = kwargs.pop('nl', kwargs.pop('newlines', 1))
data = arr
# if with_dtype and strvals:
# raise ValueError('cannot format with strvals and dtype')
separator = ',' + itemsep
if strvals:
prefix = ''
suffix = ''
else:
modname = type(data).__module__
# substitute shorthand for numpy module names
np_nice = 'np'
modname = re.sub('\\bnumpy\\b', np_nice, modname)
modname = re.sub('\\bma.core\\b', 'ma', modname)
class_name = type(data).__name__
if class_name == 'ndarray':
class_name = 'array'
prefix = modname + '.' + class_name + '('
if with_dtype:
dtype_repr = data.dtype.name
# dtype_repr = np.core.arrayprint.dtype_short_repr(data.dtype)
suffix = ',{}dtype={}.{})'.format(itemsep, np_nice, dtype_repr)
else:
suffix = ')'
if not strvals and data.size == 0 and data.shape != (0,):
# Special case for displaying empty data
prefix = modname + '.empty('
body = repr(tuple(map(int, data.shape)))
else:
body = np.array2string(data, precision=precision,
separator=separator,
suppress_small=suppress_small,
prefix=prefix,
max_line_width=max_line_width)
if not newlines:
# remove newlines if we need to
body = re.sub('\n *', '', body)
formatted = prefix + body + suffix
return formatted | python | def numpy_str(arr, strvals=False, precision=None, pr=None,
force_dtype=False,
with_dtype=None, suppress_small=None, max_line_width=None,
threshold=None, **kwargs):
"""
suppress_small = False turns off scientific representation
"""
# strvals = kwargs.get('strvals', False)
itemsep = kwargs.get('itemsep', ' ')
# precision = kwargs.get('precision', None)
# suppress_small = kwargs.get('supress_small', None)
# max_line_width = kwargs.get('max_line_width', None)
# with_dtype = kwargs.get('with_dtype', False)
newlines = kwargs.pop('nl', kwargs.pop('newlines', 1))
data = arr
# if with_dtype and strvals:
# raise ValueError('cannot format with strvals and dtype')
separator = ',' + itemsep
if strvals:
prefix = ''
suffix = ''
else:
modname = type(data).__module__
# substitute shorthand for numpy module names
np_nice = 'np'
modname = re.sub('\\bnumpy\\b', np_nice, modname)
modname = re.sub('\\bma.core\\b', 'ma', modname)
class_name = type(data).__name__
if class_name == 'ndarray':
class_name = 'array'
prefix = modname + '.' + class_name + '('
if with_dtype:
dtype_repr = data.dtype.name
# dtype_repr = np.core.arrayprint.dtype_short_repr(data.dtype)
suffix = ',{}dtype={}.{})'.format(itemsep, np_nice, dtype_repr)
else:
suffix = ')'
if not strvals and data.size == 0 and data.shape != (0,):
# Special case for displaying empty data
prefix = modname + '.empty('
body = repr(tuple(map(int, data.shape)))
else:
body = np.array2string(data, precision=precision,
separator=separator,
suppress_small=suppress_small,
prefix=prefix,
max_line_width=max_line_width)
if not newlines:
# remove newlines if we need to
body = re.sub('\n *', '', body)
formatted = prefix + body + suffix
return formatted | [
"def",
"numpy_str",
"(",
"arr",
",",
"strvals",
"=",
"False",
",",
"precision",
"=",
"None",
",",
"pr",
"=",
"None",
",",
"force_dtype",
"=",
"False",
",",
"with_dtype",
"=",
"None",
",",
"suppress_small",
"=",
"None",
",",
"max_line_width",
"=",
"None",
",",
"threshold",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"# strvals = kwargs.get('strvals', False)",
"itemsep",
"=",
"kwargs",
".",
"get",
"(",
"'itemsep'",
",",
"' '",
")",
"# precision = kwargs.get('precision', None)",
"# suppress_small = kwargs.get('supress_small', None)",
"# max_line_width = kwargs.get('max_line_width', None)",
"# with_dtype = kwargs.get('with_dtype', False)",
"newlines",
"=",
"kwargs",
".",
"pop",
"(",
"'nl'",
",",
"kwargs",
".",
"pop",
"(",
"'newlines'",
",",
"1",
")",
")",
"data",
"=",
"arr",
"# if with_dtype and strvals:",
"# raise ValueError('cannot format with strvals and dtype')",
"separator",
"=",
"','",
"+",
"itemsep",
"if",
"strvals",
":",
"prefix",
"=",
"''",
"suffix",
"=",
"''",
"else",
":",
"modname",
"=",
"type",
"(",
"data",
")",
".",
"__module__",
"# substitute shorthand for numpy module names",
"np_nice",
"=",
"'np'",
"modname",
"=",
"re",
".",
"sub",
"(",
"'\\\\bnumpy\\\\b'",
",",
"np_nice",
",",
"modname",
")",
"modname",
"=",
"re",
".",
"sub",
"(",
"'\\\\bma.core\\\\b'",
",",
"'ma'",
",",
"modname",
")",
"class_name",
"=",
"type",
"(",
"data",
")",
".",
"__name__",
"if",
"class_name",
"==",
"'ndarray'",
":",
"class_name",
"=",
"'array'",
"prefix",
"=",
"modname",
"+",
"'.'",
"+",
"class_name",
"+",
"'('",
"if",
"with_dtype",
":",
"dtype_repr",
"=",
"data",
".",
"dtype",
".",
"name",
"# dtype_repr = np.core.arrayprint.dtype_short_repr(data.dtype)",
"suffix",
"=",
"',{}dtype={}.{})'",
".",
"format",
"(",
"itemsep",
",",
"np_nice",
",",
"dtype_repr",
")",
"else",
":",
"suffix",
"=",
"')'",
"if",
"not",
"strvals",
"and",
"data",
".",
"size",
"==",
"0",
"and",
"data",
".",
"shape",
"!=",
"(",
"0",
",",
")",
":",
"# Special case for displaying empty data",
"prefix",
"=",
"modname",
"+",
"'.empty('",
"body",
"=",
"repr",
"(",
"tuple",
"(",
"map",
"(",
"int",
",",
"data",
".",
"shape",
")",
")",
")",
"else",
":",
"body",
"=",
"np",
".",
"array2string",
"(",
"data",
",",
"precision",
"=",
"precision",
",",
"separator",
"=",
"separator",
",",
"suppress_small",
"=",
"suppress_small",
",",
"prefix",
"=",
"prefix",
",",
"max_line_width",
"=",
"max_line_width",
")",
"if",
"not",
"newlines",
":",
"# remove newlines if we need to",
"body",
"=",
"re",
".",
"sub",
"(",
"'\\n *'",
",",
"''",
",",
"body",
")",
"formatted",
"=",
"prefix",
"+",
"body",
"+",
"suffix",
"return",
"formatted"
] | suppress_small = False turns off scientific representation | [
"suppress_small",
"=",
"False",
"turns",
"off",
"scientific",
"representation"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1112-L1170 | train |
Erotemic/utool | utool/util_str.py | list_str_summarized | def list_str_summarized(list_, list_name, maxlen=5):
"""
prints the list members when the list is small and the length when it is
large
"""
if len(list_) > maxlen:
return 'len(%s)=%d' % (list_name, len(list_))
else:
return '%s=%r' % (list_name, list_) | python | def list_str_summarized(list_, list_name, maxlen=5):
"""
prints the list members when the list is small and the length when it is
large
"""
if len(list_) > maxlen:
return 'len(%s)=%d' % (list_name, len(list_))
else:
return '%s=%r' % (list_name, list_) | [
"def",
"list_str_summarized",
"(",
"list_",
",",
"list_name",
",",
"maxlen",
"=",
"5",
")",
":",
"if",
"len",
"(",
"list_",
")",
">",
"maxlen",
":",
"return",
"'len(%s)=%d'",
"%",
"(",
"list_name",
",",
"len",
"(",
"list_",
")",
")",
"else",
":",
"return",
"'%s=%r'",
"%",
"(",
"list_name",
",",
"list_",
")"
] | prints the list members when the list is small and the length when it is
large | [
"prints",
"the",
"list",
"members",
"when",
"the",
"list",
"is",
"small",
"and",
"the",
"length",
"when",
"it",
"is",
"large"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1251-L1259 | train |
Erotemic/utool | utool/util_str.py | _rectify_countdown_or_bool | def _rectify_countdown_or_bool(count_or_bool):
"""
used by recrusive functions to specify which level to turn a bool on in
counting down yeilds True, True, ..., False
conting up yeilds False, False, False, ... True
Args:
count_or_bool (bool or int): if positive will count down, if negative
will count up, if bool will remain same
Returns:
int or bool: count_or_bool_
CommandLine:
python -m utool.util_str --test-_rectify_countdown_or_bool
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import _rectify_countdown_or_bool # NOQA
>>> count_or_bool = True
>>> a1 = (_rectify_countdown_or_bool(2))
>>> a2 = (_rectify_countdown_or_bool(1))
>>> a3 = (_rectify_countdown_or_bool(0))
>>> a4 = (_rectify_countdown_or_bool(-1))
>>> a5 = (_rectify_countdown_or_bool(-2))
>>> a6 = (_rectify_countdown_or_bool(True))
>>> a7 = (_rectify_countdown_or_bool(False))
>>> result = [a1, a2, a3, a4, a5, a6, a7]
>>> print(result)
[1.0, 0.0, 0, 0.0, -1.0, True, False]
[1.0, True, False, False, -1.0, True, False]
"""
if count_or_bool is True or count_or_bool is False:
count_or_bool_ = count_or_bool
elif isinstance(count_or_bool, int):
if count_or_bool == 0:
return 0
sign_ = math.copysign(1, count_or_bool)
count_or_bool_ = int(count_or_bool - sign_)
#if count_or_bool_ == 0:
# return sign_ == 1
else:
count_or_bool_ = False
return count_or_bool_ | python | def _rectify_countdown_or_bool(count_or_bool):
"""
used by recrusive functions to specify which level to turn a bool on in
counting down yeilds True, True, ..., False
conting up yeilds False, False, False, ... True
Args:
count_or_bool (bool or int): if positive will count down, if negative
will count up, if bool will remain same
Returns:
int or bool: count_or_bool_
CommandLine:
python -m utool.util_str --test-_rectify_countdown_or_bool
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import _rectify_countdown_or_bool # NOQA
>>> count_or_bool = True
>>> a1 = (_rectify_countdown_or_bool(2))
>>> a2 = (_rectify_countdown_or_bool(1))
>>> a3 = (_rectify_countdown_or_bool(0))
>>> a4 = (_rectify_countdown_or_bool(-1))
>>> a5 = (_rectify_countdown_or_bool(-2))
>>> a6 = (_rectify_countdown_or_bool(True))
>>> a7 = (_rectify_countdown_or_bool(False))
>>> result = [a1, a2, a3, a4, a5, a6, a7]
>>> print(result)
[1.0, 0.0, 0, 0.0, -1.0, True, False]
[1.0, True, False, False, -1.0, True, False]
"""
if count_or_bool is True or count_or_bool is False:
count_or_bool_ = count_or_bool
elif isinstance(count_or_bool, int):
if count_or_bool == 0:
return 0
sign_ = math.copysign(1, count_or_bool)
count_or_bool_ = int(count_or_bool - sign_)
#if count_or_bool_ == 0:
# return sign_ == 1
else:
count_or_bool_ = False
return count_or_bool_ | [
"def",
"_rectify_countdown_or_bool",
"(",
"count_or_bool",
")",
":",
"if",
"count_or_bool",
"is",
"True",
"or",
"count_or_bool",
"is",
"False",
":",
"count_or_bool_",
"=",
"count_or_bool",
"elif",
"isinstance",
"(",
"count_or_bool",
",",
"int",
")",
":",
"if",
"count_or_bool",
"==",
"0",
":",
"return",
"0",
"sign_",
"=",
"math",
".",
"copysign",
"(",
"1",
",",
"count_or_bool",
")",
"count_or_bool_",
"=",
"int",
"(",
"count_or_bool",
"-",
"sign_",
")",
"#if count_or_bool_ == 0:",
"# return sign_ == 1",
"else",
":",
"count_or_bool_",
"=",
"False",
"return",
"count_or_bool_"
] | used by recrusive functions to specify which level to turn a bool on in
counting down yeilds True, True, ..., False
conting up yeilds False, False, False, ... True
Args:
count_or_bool (bool or int): if positive will count down, if negative
will count up, if bool will remain same
Returns:
int or bool: count_or_bool_
CommandLine:
python -m utool.util_str --test-_rectify_countdown_or_bool
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import _rectify_countdown_or_bool # NOQA
>>> count_or_bool = True
>>> a1 = (_rectify_countdown_or_bool(2))
>>> a2 = (_rectify_countdown_or_bool(1))
>>> a3 = (_rectify_countdown_or_bool(0))
>>> a4 = (_rectify_countdown_or_bool(-1))
>>> a5 = (_rectify_countdown_or_bool(-2))
>>> a6 = (_rectify_countdown_or_bool(True))
>>> a7 = (_rectify_countdown_or_bool(False))
>>> result = [a1, a2, a3, a4, a5, a6, a7]
>>> print(result)
[1.0, 0.0, 0, 0.0, -1.0, True, False]
[1.0, True, False, False, -1.0, True, False] | [
"used",
"by",
"recrusive",
"functions",
"to",
"specify",
"which",
"level",
"to",
"turn",
"a",
"bool",
"on",
"in",
"counting",
"down",
"yeilds",
"True",
"True",
"...",
"False",
"conting",
"up",
"yeilds",
"False",
"False",
"False",
"...",
"True"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1266-L1310 | train |
Erotemic/utool | utool/util_str.py | repr2 | def repr2(obj_, **kwargs):
"""
Attempt to replace repr more configurable
pretty version that works the same in both 2 and 3
"""
kwargs['nl'] = kwargs.pop('nl', kwargs.pop('newlines', False))
val_str = _make_valstr(**kwargs)
return val_str(obj_) | python | def repr2(obj_, **kwargs):
"""
Attempt to replace repr more configurable
pretty version that works the same in both 2 and 3
"""
kwargs['nl'] = kwargs.pop('nl', kwargs.pop('newlines', False))
val_str = _make_valstr(**kwargs)
return val_str(obj_) | [
"def",
"repr2",
"(",
"obj_",
",",
"*",
"*",
"kwargs",
")",
":",
"kwargs",
"[",
"'nl'",
"]",
"=",
"kwargs",
".",
"pop",
"(",
"'nl'",
",",
"kwargs",
".",
"pop",
"(",
"'newlines'",
",",
"False",
")",
")",
"val_str",
"=",
"_make_valstr",
"(",
"*",
"*",
"kwargs",
")",
"return",
"val_str",
"(",
"obj_",
")"
] | Attempt to replace repr more configurable
pretty version that works the same in both 2 and 3 | [
"Attempt",
"to",
"replace",
"repr",
"more",
"configurable",
"pretty",
"version",
"that",
"works",
"the",
"same",
"in",
"both",
"2",
"and",
"3"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1317-L1324 | train |
Erotemic/utool | utool/util_str.py | repr2_json | def repr2_json(obj_, **kwargs):
""" hack for json reprs """
import utool as ut
kwargs['trailing_sep'] = False
json_str = ut.repr2(obj_, **kwargs)
json_str = str(json_str.replace('\'', '"'))
json_str = json_str.replace('(', '[')
json_str = json_str.replace(')', ']')
json_str = json_str.replace('None', 'null')
return json_str | python | def repr2_json(obj_, **kwargs):
""" hack for json reprs """
import utool as ut
kwargs['trailing_sep'] = False
json_str = ut.repr2(obj_, **kwargs)
json_str = str(json_str.replace('\'', '"'))
json_str = json_str.replace('(', '[')
json_str = json_str.replace(')', ']')
json_str = json_str.replace('None', 'null')
return json_str | [
"def",
"repr2_json",
"(",
"obj_",
",",
"*",
"*",
"kwargs",
")",
":",
"import",
"utool",
"as",
"ut",
"kwargs",
"[",
"'trailing_sep'",
"]",
"=",
"False",
"json_str",
"=",
"ut",
".",
"repr2",
"(",
"obj_",
",",
"*",
"*",
"kwargs",
")",
"json_str",
"=",
"str",
"(",
"json_str",
".",
"replace",
"(",
"'\\''",
",",
"'\"'",
")",
")",
"json_str",
"=",
"json_str",
".",
"replace",
"(",
"'('",
",",
"'['",
")",
"json_str",
"=",
"json_str",
".",
"replace",
"(",
"')'",
",",
"']'",
")",
"json_str",
"=",
"json_str",
".",
"replace",
"(",
"'None'",
",",
"'null'",
")",
"return",
"json_str"
] | hack for json reprs | [
"hack",
"for",
"json",
"reprs"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1327-L1336 | train |
Erotemic/utool | utool/util_str.py | list_str | def list_str(list_, **listkw):
r"""
Makes a pretty list string
Args:
list_ (list): input list
**listkw: nl, newlines, packed, truncate, nobr, nobraces, itemsep,
trailing_sep, truncatekw, strvals, recursive,
indent_, precision, use_numpy, with_dtype, force_dtype,
stritems, strkeys, align, explicit, sorted_, key_order,
key_order_metric, maxlen
Returns:
str: retstr
CommandLine:
python -m utool.util_str --test-list_str
python -m utool.util_str --exec-list_str --truncate=True
python -m utool.util_str --exec-list_str --truncate=0
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> list_ = [[(('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, '')],
>>> [(['--nodyn'], 1, False, ''), (['--nodyn'], 1, False, '')]]
>>> listkw = {'nl': 2}
>>> result = list_str(list_, **listkw)
>>> print(result)
[
[
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
],
[
(['--nodyn'], 1, False, ''),
(['--nodyn'], 1, False, ''),
],
]
"""
import utool as ut
newlines = listkw.pop('nl', listkw.pop('newlines', 1))
packed = listkw.pop('packed', False)
truncate = listkw.pop('truncate', False)
listkw['nl'] = _rectify_countdown_or_bool(newlines)
listkw['truncate'] = _rectify_countdown_or_bool(truncate)
listkw['packed'] = _rectify_countdown_or_bool(packed)
nobraces = listkw.pop('nobr', listkw.pop('nobraces', False))
itemsep = listkw.get('itemsep', ' ')
# Doesn't actually put in trailing comma if on same line
trailing_sep = listkw.get('trailing_sep', True)
with_comma = True
itemstr_list = get_itemstr_list(list_, **listkw)
is_tuple = isinstance(list_, tuple)
is_set = isinstance(list_, (set, frozenset, ut.oset))
is_onetup = isinstance(list_, (tuple)) and len(list_) <= 1
if nobraces:
lbr, rbr = '', ''
elif is_tuple:
lbr, rbr = '(', ')'
elif is_set:
lbr, rbr = '{', '}'
else:
lbr, rbr = '[', ']'
if len(itemstr_list) == 0:
newlines = False
if newlines is not False and (newlines is True or newlines > 0):
sep = ',\n' if with_comma else '\n'
if nobraces:
body_str = sep.join(itemstr_list)
if trailing_sep:
body_str += ','
retstr = body_str
else:
if packed:
# DEPRICATE?
joinstr = sep + itemsep * len(lbr)
body_str = joinstr.join([itemstr for itemstr in itemstr_list])
if trailing_sep:
body_str += ','
braced_body_str = (lbr + '' + body_str + '' + rbr)
else:
body_str = sep.join([
ut.indent(itemstr) for itemstr in itemstr_list])
if trailing_sep:
body_str += ','
braced_body_str = (lbr + '\n' + body_str + '\n' + rbr)
retstr = braced_body_str
else:
sep = ',' + itemsep if with_comma else itemsep
body_str = sep.join(itemstr_list)
if is_onetup:
body_str += ','
retstr = (lbr + body_str + rbr)
# TODO: rectify with dict_truncate
do_truncate = truncate is not False and (truncate is True or truncate == 0)
if do_truncate:
truncatekw = listkw.get('truncatekw', {})
retstr = truncate_str(retstr, **truncatekw)
return retstr | python | def list_str(list_, **listkw):
r"""
Makes a pretty list string
Args:
list_ (list): input list
**listkw: nl, newlines, packed, truncate, nobr, nobraces, itemsep,
trailing_sep, truncatekw, strvals, recursive,
indent_, precision, use_numpy, with_dtype, force_dtype,
stritems, strkeys, align, explicit, sorted_, key_order,
key_order_metric, maxlen
Returns:
str: retstr
CommandLine:
python -m utool.util_str --test-list_str
python -m utool.util_str --exec-list_str --truncate=True
python -m utool.util_str --exec-list_str --truncate=0
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> list_ = [[(('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, '')],
>>> [(['--nodyn'], 1, False, ''), (['--nodyn'], 1, False, '')]]
>>> listkw = {'nl': 2}
>>> result = list_str(list_, **listkw)
>>> print(result)
[
[
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
],
[
(['--nodyn'], 1, False, ''),
(['--nodyn'], 1, False, ''),
],
]
"""
import utool as ut
newlines = listkw.pop('nl', listkw.pop('newlines', 1))
packed = listkw.pop('packed', False)
truncate = listkw.pop('truncate', False)
listkw['nl'] = _rectify_countdown_or_bool(newlines)
listkw['truncate'] = _rectify_countdown_or_bool(truncate)
listkw['packed'] = _rectify_countdown_or_bool(packed)
nobraces = listkw.pop('nobr', listkw.pop('nobraces', False))
itemsep = listkw.get('itemsep', ' ')
# Doesn't actually put in trailing comma if on same line
trailing_sep = listkw.get('trailing_sep', True)
with_comma = True
itemstr_list = get_itemstr_list(list_, **listkw)
is_tuple = isinstance(list_, tuple)
is_set = isinstance(list_, (set, frozenset, ut.oset))
is_onetup = isinstance(list_, (tuple)) and len(list_) <= 1
if nobraces:
lbr, rbr = '', ''
elif is_tuple:
lbr, rbr = '(', ')'
elif is_set:
lbr, rbr = '{', '}'
else:
lbr, rbr = '[', ']'
if len(itemstr_list) == 0:
newlines = False
if newlines is not False and (newlines is True or newlines > 0):
sep = ',\n' if with_comma else '\n'
if nobraces:
body_str = sep.join(itemstr_list)
if trailing_sep:
body_str += ','
retstr = body_str
else:
if packed:
# DEPRICATE?
joinstr = sep + itemsep * len(lbr)
body_str = joinstr.join([itemstr for itemstr in itemstr_list])
if trailing_sep:
body_str += ','
braced_body_str = (lbr + '' + body_str + '' + rbr)
else:
body_str = sep.join([
ut.indent(itemstr) for itemstr in itemstr_list])
if trailing_sep:
body_str += ','
braced_body_str = (lbr + '\n' + body_str + '\n' + rbr)
retstr = braced_body_str
else:
sep = ',' + itemsep if with_comma else itemsep
body_str = sep.join(itemstr_list)
if is_onetup:
body_str += ','
retstr = (lbr + body_str + rbr)
# TODO: rectify with dict_truncate
do_truncate = truncate is not False and (truncate is True or truncate == 0)
if do_truncate:
truncatekw = listkw.get('truncatekw', {})
retstr = truncate_str(retstr, **truncatekw)
return retstr | [
"def",
"list_str",
"(",
"list_",
",",
"*",
"*",
"listkw",
")",
":",
"import",
"utool",
"as",
"ut",
"newlines",
"=",
"listkw",
".",
"pop",
"(",
"'nl'",
",",
"listkw",
".",
"pop",
"(",
"'newlines'",
",",
"1",
")",
")",
"packed",
"=",
"listkw",
".",
"pop",
"(",
"'packed'",
",",
"False",
")",
"truncate",
"=",
"listkw",
".",
"pop",
"(",
"'truncate'",
",",
"False",
")",
"listkw",
"[",
"'nl'",
"]",
"=",
"_rectify_countdown_or_bool",
"(",
"newlines",
")",
"listkw",
"[",
"'truncate'",
"]",
"=",
"_rectify_countdown_or_bool",
"(",
"truncate",
")",
"listkw",
"[",
"'packed'",
"]",
"=",
"_rectify_countdown_or_bool",
"(",
"packed",
")",
"nobraces",
"=",
"listkw",
".",
"pop",
"(",
"'nobr'",
",",
"listkw",
".",
"pop",
"(",
"'nobraces'",
",",
"False",
")",
")",
"itemsep",
"=",
"listkw",
".",
"get",
"(",
"'itemsep'",
",",
"' '",
")",
"# Doesn't actually put in trailing comma if on same line",
"trailing_sep",
"=",
"listkw",
".",
"get",
"(",
"'trailing_sep'",
",",
"True",
")",
"with_comma",
"=",
"True",
"itemstr_list",
"=",
"get_itemstr_list",
"(",
"list_",
",",
"*",
"*",
"listkw",
")",
"is_tuple",
"=",
"isinstance",
"(",
"list_",
",",
"tuple",
")",
"is_set",
"=",
"isinstance",
"(",
"list_",
",",
"(",
"set",
",",
"frozenset",
",",
"ut",
".",
"oset",
")",
")",
"is_onetup",
"=",
"isinstance",
"(",
"list_",
",",
"(",
"tuple",
")",
")",
"and",
"len",
"(",
"list_",
")",
"<=",
"1",
"if",
"nobraces",
":",
"lbr",
",",
"rbr",
"=",
"''",
",",
"''",
"elif",
"is_tuple",
":",
"lbr",
",",
"rbr",
"=",
"'('",
",",
"')'",
"elif",
"is_set",
":",
"lbr",
",",
"rbr",
"=",
"'{'",
",",
"'}'",
"else",
":",
"lbr",
",",
"rbr",
"=",
"'['",
",",
"']'",
"if",
"len",
"(",
"itemstr_list",
")",
"==",
"0",
":",
"newlines",
"=",
"False",
"if",
"newlines",
"is",
"not",
"False",
"and",
"(",
"newlines",
"is",
"True",
"or",
"newlines",
">",
"0",
")",
":",
"sep",
"=",
"',\\n'",
"if",
"with_comma",
"else",
"'\\n'",
"if",
"nobraces",
":",
"body_str",
"=",
"sep",
".",
"join",
"(",
"itemstr_list",
")",
"if",
"trailing_sep",
":",
"body_str",
"+=",
"','",
"retstr",
"=",
"body_str",
"else",
":",
"if",
"packed",
":",
"# DEPRICATE?",
"joinstr",
"=",
"sep",
"+",
"itemsep",
"*",
"len",
"(",
"lbr",
")",
"body_str",
"=",
"joinstr",
".",
"join",
"(",
"[",
"itemstr",
"for",
"itemstr",
"in",
"itemstr_list",
"]",
")",
"if",
"trailing_sep",
":",
"body_str",
"+=",
"','",
"braced_body_str",
"=",
"(",
"lbr",
"+",
"''",
"+",
"body_str",
"+",
"''",
"+",
"rbr",
")",
"else",
":",
"body_str",
"=",
"sep",
".",
"join",
"(",
"[",
"ut",
".",
"indent",
"(",
"itemstr",
")",
"for",
"itemstr",
"in",
"itemstr_list",
"]",
")",
"if",
"trailing_sep",
":",
"body_str",
"+=",
"','",
"braced_body_str",
"=",
"(",
"lbr",
"+",
"'\\n'",
"+",
"body_str",
"+",
"'\\n'",
"+",
"rbr",
")",
"retstr",
"=",
"braced_body_str",
"else",
":",
"sep",
"=",
"','",
"+",
"itemsep",
"if",
"with_comma",
"else",
"itemsep",
"body_str",
"=",
"sep",
".",
"join",
"(",
"itemstr_list",
")",
"if",
"is_onetup",
":",
"body_str",
"+=",
"','",
"retstr",
"=",
"(",
"lbr",
"+",
"body_str",
"+",
"rbr",
")",
"# TODO: rectify with dict_truncate",
"do_truncate",
"=",
"truncate",
"is",
"not",
"False",
"and",
"(",
"truncate",
"is",
"True",
"or",
"truncate",
"==",
"0",
")",
"if",
"do_truncate",
":",
"truncatekw",
"=",
"listkw",
".",
"get",
"(",
"'truncatekw'",
",",
"{",
"}",
")",
"retstr",
"=",
"truncate_str",
"(",
"retstr",
",",
"*",
"*",
"truncatekw",
")",
"return",
"retstr"
] | r"""
Makes a pretty list string
Args:
list_ (list): input list
**listkw: nl, newlines, packed, truncate, nobr, nobraces, itemsep,
trailing_sep, truncatekw, strvals, recursive,
indent_, precision, use_numpy, with_dtype, force_dtype,
stritems, strkeys, align, explicit, sorted_, key_order,
key_order_metric, maxlen
Returns:
str: retstr
CommandLine:
python -m utool.util_str --test-list_str
python -m utool.util_str --exec-list_str --truncate=True
python -m utool.util_str --exec-list_str --truncate=0
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> list_ = [[(('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, ''),
>>> (('--verbose-qt', '--verbqt'), 1, False, '')],
>>> [(['--nodyn'], 1, False, ''), (['--nodyn'], 1, False, '')]]
>>> listkw = {'nl': 2}
>>> result = list_str(list_, **listkw)
>>> print(result)
[
[
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
(('--verbose-qt', '--verbqt'), 1, False, ''),
],
[
(['--nodyn'], 1, False, ''),
(['--nodyn'], 1, False, ''),
],
] | [
"r",
"Makes",
"a",
"pretty",
"list",
"string"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1582-L1694 | train |
Erotemic/utool | utool/util_str.py | horiz_string | def horiz_string(*args, **kwargs):
"""
Horizontally concatenates strings reprs preserving indentation
Concats a list of objects ensuring that the next item in the list
is all the way to the right of any previous items.
Args:
*args: list of strings to concat
**kwargs: precision, sep
CommandLine:
python -m utool.util_str --test-horiz_string
Example1:
>>> # ENABLE_DOCTEST
>>> # Pretty printing of matrices demo / test
>>> import utool
>>> import numpy as np
>>> # Wouldn't it be nice if we could print this operation easily?
>>> B = np.array(((1, 2), (3, 4)))
>>> C = np.array(((5, 6), (7, 8)))
>>> A = B.dot(C)
>>> # Eg 1:
>>> result = (utool.hz_str('A = ', A, ' = ', B, ' * ', C))
>>> print(result)
A = [[19 22] = [[1 2] * [[5 6]
[43 50]] [3 4]] [7 8]]
Exam2:
>>> # Eg 2:
>>> str_list = ['A = ', str(B), ' * ', str(C)]
>>> horizstr = (utool.horiz_string(*str_list))
>>> result = (horizstr)
>>> print(result)
A = [[1 2] * [[5 6]
[3 4]] [7 8]]
"""
import unicodedata
precision = kwargs.get('precision', None)
sep = kwargs.get('sep', '')
if len(args) == 1 and not isinstance(args[0], six.string_types):
val_list = args[0]
else:
val_list = args
val_list = [unicodedata.normalize('NFC', ensure_unicode(val))
for val in val_list]
all_lines = []
hpos = 0
# for each value in the list or args
for sx in range(len(val_list)):
# Ensure value is a string
val = val_list[sx]
str_ = None
if precision is not None:
# Hack in numpy precision
if util_type.HAVE_NUMPY:
try:
if isinstance(val, np.ndarray):
str_ = np.array_str(val, precision=precision,
suppress_small=True)
except ImportError:
pass
if str_ is None:
str_ = six.text_type(val_list[sx])
# continue with formating
lines = str_.split('\n')
line_diff = len(lines) - len(all_lines)
# Vertical padding
if line_diff > 0:
all_lines += [' ' * hpos] * line_diff
# Add strings
for lx, line in enumerate(lines):
all_lines[lx] += line
hpos = max(hpos, len(all_lines[lx]))
# Horizontal padding
for lx in range(len(all_lines)):
hpos_diff = hpos - len(all_lines[lx])
all_lines[lx] += ' ' * hpos_diff + sep
all_lines = [line.rstrip(' ') for line in all_lines]
ret = '\n'.join(all_lines)
return ret | python | def horiz_string(*args, **kwargs):
"""
Horizontally concatenates strings reprs preserving indentation
Concats a list of objects ensuring that the next item in the list
is all the way to the right of any previous items.
Args:
*args: list of strings to concat
**kwargs: precision, sep
CommandLine:
python -m utool.util_str --test-horiz_string
Example1:
>>> # ENABLE_DOCTEST
>>> # Pretty printing of matrices demo / test
>>> import utool
>>> import numpy as np
>>> # Wouldn't it be nice if we could print this operation easily?
>>> B = np.array(((1, 2), (3, 4)))
>>> C = np.array(((5, 6), (7, 8)))
>>> A = B.dot(C)
>>> # Eg 1:
>>> result = (utool.hz_str('A = ', A, ' = ', B, ' * ', C))
>>> print(result)
A = [[19 22] = [[1 2] * [[5 6]
[43 50]] [3 4]] [7 8]]
Exam2:
>>> # Eg 2:
>>> str_list = ['A = ', str(B), ' * ', str(C)]
>>> horizstr = (utool.horiz_string(*str_list))
>>> result = (horizstr)
>>> print(result)
A = [[1 2] * [[5 6]
[3 4]] [7 8]]
"""
import unicodedata
precision = kwargs.get('precision', None)
sep = kwargs.get('sep', '')
if len(args) == 1 and not isinstance(args[0], six.string_types):
val_list = args[0]
else:
val_list = args
val_list = [unicodedata.normalize('NFC', ensure_unicode(val))
for val in val_list]
all_lines = []
hpos = 0
# for each value in the list or args
for sx in range(len(val_list)):
# Ensure value is a string
val = val_list[sx]
str_ = None
if precision is not None:
# Hack in numpy precision
if util_type.HAVE_NUMPY:
try:
if isinstance(val, np.ndarray):
str_ = np.array_str(val, precision=precision,
suppress_small=True)
except ImportError:
pass
if str_ is None:
str_ = six.text_type(val_list[sx])
# continue with formating
lines = str_.split('\n')
line_diff = len(lines) - len(all_lines)
# Vertical padding
if line_diff > 0:
all_lines += [' ' * hpos] * line_diff
# Add strings
for lx, line in enumerate(lines):
all_lines[lx] += line
hpos = max(hpos, len(all_lines[lx]))
# Horizontal padding
for lx in range(len(all_lines)):
hpos_diff = hpos - len(all_lines[lx])
all_lines[lx] += ' ' * hpos_diff + sep
all_lines = [line.rstrip(' ') for line in all_lines]
ret = '\n'.join(all_lines)
return ret | [
"def",
"horiz_string",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"import",
"unicodedata",
"precision",
"=",
"kwargs",
".",
"get",
"(",
"'precision'",
",",
"None",
")",
"sep",
"=",
"kwargs",
".",
"get",
"(",
"'sep'",
",",
"''",
")",
"if",
"len",
"(",
"args",
")",
"==",
"1",
"and",
"not",
"isinstance",
"(",
"args",
"[",
"0",
"]",
",",
"six",
".",
"string_types",
")",
":",
"val_list",
"=",
"args",
"[",
"0",
"]",
"else",
":",
"val_list",
"=",
"args",
"val_list",
"=",
"[",
"unicodedata",
".",
"normalize",
"(",
"'NFC'",
",",
"ensure_unicode",
"(",
"val",
")",
")",
"for",
"val",
"in",
"val_list",
"]",
"all_lines",
"=",
"[",
"]",
"hpos",
"=",
"0",
"# for each value in the list or args",
"for",
"sx",
"in",
"range",
"(",
"len",
"(",
"val_list",
")",
")",
":",
"# Ensure value is a string",
"val",
"=",
"val_list",
"[",
"sx",
"]",
"str_",
"=",
"None",
"if",
"precision",
"is",
"not",
"None",
":",
"# Hack in numpy precision",
"if",
"util_type",
".",
"HAVE_NUMPY",
":",
"try",
":",
"if",
"isinstance",
"(",
"val",
",",
"np",
".",
"ndarray",
")",
":",
"str_",
"=",
"np",
".",
"array_str",
"(",
"val",
",",
"precision",
"=",
"precision",
",",
"suppress_small",
"=",
"True",
")",
"except",
"ImportError",
":",
"pass",
"if",
"str_",
"is",
"None",
":",
"str_",
"=",
"six",
".",
"text_type",
"(",
"val_list",
"[",
"sx",
"]",
")",
"# continue with formating",
"lines",
"=",
"str_",
".",
"split",
"(",
"'\\n'",
")",
"line_diff",
"=",
"len",
"(",
"lines",
")",
"-",
"len",
"(",
"all_lines",
")",
"# Vertical padding",
"if",
"line_diff",
">",
"0",
":",
"all_lines",
"+=",
"[",
"' '",
"*",
"hpos",
"]",
"*",
"line_diff",
"# Add strings",
"for",
"lx",
",",
"line",
"in",
"enumerate",
"(",
"lines",
")",
":",
"all_lines",
"[",
"lx",
"]",
"+=",
"line",
"hpos",
"=",
"max",
"(",
"hpos",
",",
"len",
"(",
"all_lines",
"[",
"lx",
"]",
")",
")",
"# Horizontal padding",
"for",
"lx",
"in",
"range",
"(",
"len",
"(",
"all_lines",
")",
")",
":",
"hpos_diff",
"=",
"hpos",
"-",
"len",
"(",
"all_lines",
"[",
"lx",
"]",
")",
"all_lines",
"[",
"lx",
"]",
"+=",
"' '",
"*",
"hpos_diff",
"+",
"sep",
"all_lines",
"=",
"[",
"line",
".",
"rstrip",
"(",
"' '",
")",
"for",
"line",
"in",
"all_lines",
"]",
"ret",
"=",
"'\\n'",
".",
"join",
"(",
"all_lines",
")",
"return",
"ret"
] | Horizontally concatenates strings reprs preserving indentation
Concats a list of objects ensuring that the next item in the list
is all the way to the right of any previous items.
Args:
*args: list of strings to concat
**kwargs: precision, sep
CommandLine:
python -m utool.util_str --test-horiz_string
Example1:
>>> # ENABLE_DOCTEST
>>> # Pretty printing of matrices demo / test
>>> import utool
>>> import numpy as np
>>> # Wouldn't it be nice if we could print this operation easily?
>>> B = np.array(((1, 2), (3, 4)))
>>> C = np.array(((5, 6), (7, 8)))
>>> A = B.dot(C)
>>> # Eg 1:
>>> result = (utool.hz_str('A = ', A, ' = ', B, ' * ', C))
>>> print(result)
A = [[19 22] = [[1 2] * [[5 6]
[43 50]] [3 4]] [7 8]]
Exam2:
>>> # Eg 2:
>>> str_list = ['A = ', str(B), ' * ', str(C)]
>>> horizstr = (utool.horiz_string(*str_list))
>>> result = (horizstr)
>>> print(result)
A = [[1 2] * [[5 6]
[3 4]] [7 8]] | [
"Horizontally",
"concatenates",
"strings",
"reprs",
"preserving",
"indentation"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1795-L1879 | train |
Erotemic/utool | utool/util_str.py | str_between | def str_between(str_, startstr, endstr):
r"""
gets substring between two sentianl strings
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> str_ = '\n INSERT INTO vsone(\n'
>>> startstr = 'INSERT'
>>> endstr = '('
>>> result = str_between(str_, startstr, endstr)
>>> print(result)
"""
if startstr is None:
startpos = 0
else:
startpos = str_.find(startstr) + len(startstr)
if endstr is None:
endpos = None
else:
endpos = str_.find(endstr)
if endpos == -1:
endpos = None
newstr = str_[startpos:endpos]
return newstr | python | def str_between(str_, startstr, endstr):
r"""
gets substring between two sentianl strings
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> str_ = '\n INSERT INTO vsone(\n'
>>> startstr = 'INSERT'
>>> endstr = '('
>>> result = str_between(str_, startstr, endstr)
>>> print(result)
"""
if startstr is None:
startpos = 0
else:
startpos = str_.find(startstr) + len(startstr)
if endstr is None:
endpos = None
else:
endpos = str_.find(endstr)
if endpos == -1:
endpos = None
newstr = str_[startpos:endpos]
return newstr | [
"def",
"str_between",
"(",
"str_",
",",
"startstr",
",",
"endstr",
")",
":",
"if",
"startstr",
"is",
"None",
":",
"startpos",
"=",
"0",
"else",
":",
"startpos",
"=",
"str_",
".",
"find",
"(",
"startstr",
")",
"+",
"len",
"(",
"startstr",
")",
"if",
"endstr",
"is",
"None",
":",
"endpos",
"=",
"None",
"else",
":",
"endpos",
"=",
"str_",
".",
"find",
"(",
"endstr",
")",
"if",
"endpos",
"==",
"-",
"1",
":",
"endpos",
"=",
"None",
"newstr",
"=",
"str_",
"[",
"startpos",
":",
"endpos",
"]",
"return",
"newstr"
] | r"""
gets substring between two sentianl strings
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> import utool as ut
>>> str_ = '\n INSERT INTO vsone(\n'
>>> startstr = 'INSERT'
>>> endstr = '('
>>> result = str_between(str_, startstr, endstr)
>>> print(result) | [
"r",
"gets",
"substring",
"between",
"two",
"sentianl",
"strings"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1885-L1910 | train |
Erotemic/utool | utool/util_str.py | get_callable_name | def get_callable_name(func):
""" Works on must functionlike objects including str, which has no func_name
Args:
func (function):
Returns:
str:
CommandLine:
python -m utool.util_str --exec-get_callable_name
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = len
>>> result = get_callable_name(func)
>>> print(result)
len
"""
try:
return meta_util_six.get_funcname(func)
except AttributeError:
if isinstance(func, type):
return repr(func).replace('<type \'', '').replace('\'>', '')
elif hasattr(func, '__name__'):
return func.__name__
else:
raise NotImplementedError(('cannot get func_name of func=%r'
'type(func)=%r') % (func, type(func))) | python | def get_callable_name(func):
""" Works on must functionlike objects including str, which has no func_name
Args:
func (function):
Returns:
str:
CommandLine:
python -m utool.util_str --exec-get_callable_name
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = len
>>> result = get_callable_name(func)
>>> print(result)
len
"""
try:
return meta_util_six.get_funcname(func)
except AttributeError:
if isinstance(func, type):
return repr(func).replace('<type \'', '').replace('\'>', '')
elif hasattr(func, '__name__'):
return func.__name__
else:
raise NotImplementedError(('cannot get func_name of func=%r'
'type(func)=%r') % (func, type(func))) | [
"def",
"get_callable_name",
"(",
"func",
")",
":",
"try",
":",
"return",
"meta_util_six",
".",
"get_funcname",
"(",
"func",
")",
"except",
"AttributeError",
":",
"if",
"isinstance",
"(",
"func",
",",
"type",
")",
":",
"return",
"repr",
"(",
"func",
")",
".",
"replace",
"(",
"'<type \\''",
",",
"''",
")",
".",
"replace",
"(",
"'\\'>'",
",",
"''",
")",
"elif",
"hasattr",
"(",
"func",
",",
"'__name__'",
")",
":",
"return",
"func",
".",
"__name__",
"else",
":",
"raise",
"NotImplementedError",
"(",
"(",
"'cannot get func_name of func=%r'",
"'type(func)=%r'",
")",
"%",
"(",
"func",
",",
"type",
"(",
"func",
")",
")",
")"
] | Works on must functionlike objects including str, which has no func_name
Args:
func (function):
Returns:
str:
CommandLine:
python -m utool.util_str --exec-get_callable_name
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> func = len
>>> result = get_callable_name(func)
>>> print(result)
len | [
"Works",
"on",
"must",
"functionlike",
"objects",
"including",
"str",
"which",
"has",
"no",
"func_name"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L1913-L1942 | train |
Erotemic/utool | utool/util_str.py | multi_replace | def multi_replace(str_, search_list, repl_list):
r"""
Performs multiple replace functions foreach item in search_list and
repl_list.
Args:
str_ (str): string to search
search_list (list): list of search strings
repl_list (list or str): one or multiple replace strings
Returns:
str: str_
CommandLine:
python -m utool.util_str --exec-multi_replace
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> str_ = 'foo. bar: baz; spam-eggs --- eggs+spam'
>>> search_list = ['.', ':', '---']
>>> repl_list = '@'
>>> str_ = multi_replace(str_, search_list, repl_list)
>>> result = ('str_ = %s' % (str(str_),))
>>> print(result)
str_ = foo@ bar@ baz; spam-eggs @ eggs+spam
"""
if isinstance(repl_list, six.string_types):
repl_list_ = [repl_list] * len(search_list)
else:
repl_list_ = repl_list
newstr = str_
assert len(search_list) == len(repl_list_), 'bad lens'
for search, repl in zip(search_list, repl_list_):
newstr = newstr.replace(search, repl)
return newstr | python | def multi_replace(str_, search_list, repl_list):
r"""
Performs multiple replace functions foreach item in search_list and
repl_list.
Args:
str_ (str): string to search
search_list (list): list of search strings
repl_list (list or str): one or multiple replace strings
Returns:
str: str_
CommandLine:
python -m utool.util_str --exec-multi_replace
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> str_ = 'foo. bar: baz; spam-eggs --- eggs+spam'
>>> search_list = ['.', ':', '---']
>>> repl_list = '@'
>>> str_ = multi_replace(str_, search_list, repl_list)
>>> result = ('str_ = %s' % (str(str_),))
>>> print(result)
str_ = foo@ bar@ baz; spam-eggs @ eggs+spam
"""
if isinstance(repl_list, six.string_types):
repl_list_ = [repl_list] * len(search_list)
else:
repl_list_ = repl_list
newstr = str_
assert len(search_list) == len(repl_list_), 'bad lens'
for search, repl in zip(search_list, repl_list_):
newstr = newstr.replace(search, repl)
return newstr | [
"def",
"multi_replace",
"(",
"str_",
",",
"search_list",
",",
"repl_list",
")",
":",
"if",
"isinstance",
"(",
"repl_list",
",",
"six",
".",
"string_types",
")",
":",
"repl_list_",
"=",
"[",
"repl_list",
"]",
"*",
"len",
"(",
"search_list",
")",
"else",
":",
"repl_list_",
"=",
"repl_list",
"newstr",
"=",
"str_",
"assert",
"len",
"(",
"search_list",
")",
"==",
"len",
"(",
"repl_list_",
")",
",",
"'bad lens'",
"for",
"search",
",",
"repl",
"in",
"zip",
"(",
"search_list",
",",
"repl_list_",
")",
":",
"newstr",
"=",
"newstr",
".",
"replace",
"(",
"search",
",",
"repl",
")",
"return",
"newstr"
] | r"""
Performs multiple replace functions foreach item in search_list and
repl_list.
Args:
str_ (str): string to search
search_list (list): list of search strings
repl_list (list or str): one or multiple replace strings
Returns:
str: str_
CommandLine:
python -m utool.util_str --exec-multi_replace
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> str_ = 'foo. bar: baz; spam-eggs --- eggs+spam'
>>> search_list = ['.', ':', '---']
>>> repl_list = '@'
>>> str_ = multi_replace(str_, search_list, repl_list)
>>> result = ('str_ = %s' % (str(str_),))
>>> print(result)
str_ = foo@ bar@ baz; spam-eggs @ eggs+spam | [
"r",
"Performs",
"multiple",
"replace",
"functions",
"foreach",
"item",
"in",
"search_list",
"and",
"repl_list",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L2213-L2248 | train |
Erotemic/utool | utool/util_str.py | pluralize | def pluralize(wordtext, num=2, plural_suffix='s'):
r"""
Heuristically changes a word to its plural form if `num` is not 1
Args:
wordtext (str): word in singular form
num (int): a length of an associated list if applicable (default = 2)
plural_suffix (str): heurstic plural form (default = 's')
Returns:
str: pluralized form. Can handle some genitive cases
CommandLine:
python -m utool.util_str pluralize
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> wordtext = 'foo'
>>> result = pluralize(wordtext)
>>> print(result)
foos
"""
if num == 1:
return wordtext
else:
if wordtext.endswith('\'s'):
return wordtext[:-2] + 's\''
else:
return wordtext + plural_suffix
return (wordtext + plural_suffix) if num != 1 else wordtext | python | def pluralize(wordtext, num=2, plural_suffix='s'):
r"""
Heuristically changes a word to its plural form if `num` is not 1
Args:
wordtext (str): word in singular form
num (int): a length of an associated list if applicable (default = 2)
plural_suffix (str): heurstic plural form (default = 's')
Returns:
str: pluralized form. Can handle some genitive cases
CommandLine:
python -m utool.util_str pluralize
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> wordtext = 'foo'
>>> result = pluralize(wordtext)
>>> print(result)
foos
"""
if num == 1:
return wordtext
else:
if wordtext.endswith('\'s'):
return wordtext[:-2] + 's\''
else:
return wordtext + plural_suffix
return (wordtext + plural_suffix) if num != 1 else wordtext | [
"def",
"pluralize",
"(",
"wordtext",
",",
"num",
"=",
"2",
",",
"plural_suffix",
"=",
"'s'",
")",
":",
"if",
"num",
"==",
"1",
":",
"return",
"wordtext",
"else",
":",
"if",
"wordtext",
".",
"endswith",
"(",
"'\\'s'",
")",
":",
"return",
"wordtext",
"[",
":",
"-",
"2",
"]",
"+",
"'s\\''",
"else",
":",
"return",
"wordtext",
"+",
"plural_suffix",
"return",
"(",
"wordtext",
"+",
"plural_suffix",
")",
"if",
"num",
"!=",
"1",
"else",
"wordtext"
] | r"""
Heuristically changes a word to its plural form if `num` is not 1
Args:
wordtext (str): word in singular form
num (int): a length of an associated list if applicable (default = 2)
plural_suffix (str): heurstic plural form (default = 's')
Returns:
str: pluralized form. Can handle some genitive cases
CommandLine:
python -m utool.util_str pluralize
Example:
>>> # ENABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> wordtext = 'foo'
>>> result = pluralize(wordtext)
>>> print(result)
foos | [
"r",
"Heuristically",
"changes",
"a",
"word",
"to",
"its",
"plural",
"form",
"if",
"num",
"is",
"not",
"1"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L2251-L2281 | train |
Erotemic/utool | utool/util_str.py | quantstr | def quantstr(typestr, num, plural_suffix='s'):
r"""
Heuristically generates an english phrase relating to the quantity of
something. This is useful for writing user messages.
Args:
typestr (str): singular form of the word
num (int): quanity of the type
plural_suffix (str): heurstic plural form (default = 's')
Returns:
str: quantity phrase
CommandLine:
python -m utool.util_str quantity_str
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> items = [1, 2, 3]
>>> result = 'The list contains ' + (quantstr('item', len(items)))
>>> items = [1]
>>> result += '\nThe list contains ' + (quantstr('item', len(items)))
>>> items = []
>>> result += '\nThe list contains ' + (quantstr('item', len(items)))
>>> print(result)
The list contains 3 items
The list contains 1 item
The list contains 0 items
"""
return six.text_type(num) + ' ' + pluralize(typestr, num, plural_suffix) | python | def quantstr(typestr, num, plural_suffix='s'):
r"""
Heuristically generates an english phrase relating to the quantity of
something. This is useful for writing user messages.
Args:
typestr (str): singular form of the word
num (int): quanity of the type
plural_suffix (str): heurstic plural form (default = 's')
Returns:
str: quantity phrase
CommandLine:
python -m utool.util_str quantity_str
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> items = [1, 2, 3]
>>> result = 'The list contains ' + (quantstr('item', len(items)))
>>> items = [1]
>>> result += '\nThe list contains ' + (quantstr('item', len(items)))
>>> items = []
>>> result += '\nThe list contains ' + (quantstr('item', len(items)))
>>> print(result)
The list contains 3 items
The list contains 1 item
The list contains 0 items
"""
return six.text_type(num) + ' ' + pluralize(typestr, num, plural_suffix) | [
"def",
"quantstr",
"(",
"typestr",
",",
"num",
",",
"plural_suffix",
"=",
"'s'",
")",
":",
"return",
"six",
".",
"text_type",
"(",
"num",
")",
"+",
"' '",
"+",
"pluralize",
"(",
"typestr",
",",
"num",
",",
"plural_suffix",
")"
] | r"""
Heuristically generates an english phrase relating to the quantity of
something. This is useful for writing user messages.
Args:
typestr (str): singular form of the word
num (int): quanity of the type
plural_suffix (str): heurstic plural form (default = 's')
Returns:
str: quantity phrase
CommandLine:
python -m utool.util_str quantity_str
Example:
>>> # DISABLE_DOCTEST
>>> from utool.util_str import * # NOQA
>>> items = [1, 2, 3]
>>> result = 'The list contains ' + (quantstr('item', len(items)))
>>> items = [1]
>>> result += '\nThe list contains ' + (quantstr('item', len(items)))
>>> items = []
>>> result += '\nThe list contains ' + (quantstr('item', len(items)))
>>> print(result)
The list contains 3 items
The list contains 1 item
The list contains 0 items | [
"r",
"Heuristically",
"generates",
"an",
"english",
"phrase",
"relating",
"to",
"the",
"quantity",
"of",
"something",
".",
"This",
"is",
"useful",
"for",
"writing",
"user",
"messages",
"."
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L2284-L2314 | train |
Erotemic/utool | utool/util_str.py | msgblock | def msgblock(key, text, side='|'):
""" puts text inside a visual ascii block """
blocked_text = ''.join(
[' + --- ', key, ' ---\n'] +
[' ' + side + ' ' + line + '\n' for line in text.split('\n')] +
[' L ___ ', key, ' ___\n']
)
return blocked_text | python | def msgblock(key, text, side='|'):
""" puts text inside a visual ascii block """
blocked_text = ''.join(
[' + --- ', key, ' ---\n'] +
[' ' + side + ' ' + line + '\n' for line in text.split('\n')] +
[' L ___ ', key, ' ___\n']
)
return blocked_text | [
"def",
"msgblock",
"(",
"key",
",",
"text",
",",
"side",
"=",
"'|'",
")",
":",
"blocked_text",
"=",
"''",
".",
"join",
"(",
"[",
"' + --- '",
",",
"key",
",",
"' ---\\n'",
"]",
"+",
"[",
"' '",
"+",
"side",
"+",
"' '",
"+",
"line",
"+",
"'\\n'",
"for",
"line",
"in",
"text",
".",
"split",
"(",
"'\\n'",
")",
"]",
"+",
"[",
"' L ___ '",
",",
"key",
",",
"' ___\\n'",
"]",
")",
"return",
"blocked_text"
] | puts text inside a visual ascii block | [
"puts",
"text",
"inside",
"a",
"visual",
"ascii",
"block"
] | 3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a | https://github.com/Erotemic/utool/blob/3b27e1f4e6e6fb23cd8744af7b7195b57d99e03a/utool/util_str.py#L2317-L2324 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.