45. utils
— A collection of miscellaneous utility functions.¶
The pyformex.utils module contains a wide variety of utilitary functions. Because there are so many and they are so widely used, the utils module is imported in the environment where scripts and apps are executed, so that users can always call the utils functions without explicitely importing the module.
45.1. Module attributes¶
- utils.FileTypes¶
A collection of
FileType
records. Each FileType instance holds the definition of a file type, and is accessible from this dict with a simple mnemonic key. These are the ones that are commonly used in pyFormex. But users can add their own definitions too, just by creating an instance ofFileType
.- Type:
Examples
>>> for k,v in FileTypes.items(): print(f"{k} = '{v}'")
all = 'All files (*)'
ccx = 'CalCuliX files (*.dat *.inp)'
dcm = 'DICOM images (*.dcm)'
dxf = 'AutoCAD DXF files (*.dxf)'
dxftext = 'Converted AutoCAD files (*.dxftext)'
flavia = 'flavia results (*.flavia.msh *.flavia.res)'
gts = 'GTS files (*.gts)'
gz = 'Compressed files (*.gz *.bz2)'
html = 'Web pages (*.html)'
icon = 'Icons (*.xpm)'
img = 'Images (*.png *.jpg *.jpeg *.eps *.gif *.bmp)'
inp = 'Abaqus or CalCuliX input files (*.inp)'
neu = 'Gambit Neutral files (*.neu)'
obj = 'Wavefront OBJ files (*.obj)'
off = 'Geomview object files (*.off)'
pgf = 'pyFormex geometry files (*.pgf)'
ply = 'Stanford Polygon File Format files (*.ply)'
png = 'PNG images (*.png)'
poly = 'Polygon files (*.off *.obj *.ply)'
postproc = 'Postproc scripts (*.post.py)'
pyformex = 'pyFormex scripts (*.py)'
pyf = 'pyFormex projects (*.pyf)'
python = 'Python files (*.py)'
pzf = 'pyFormex zip files (*.pzf)'
smesh = 'Tetgen surface mesh files (*.smesh)'
stl = 'STL files (*.stl)'
stlb = 'Binary STL files (*.stl)'
surface = 'Surface models (*.gts *.stl *.off *.obj *.ply)'
tetsurf = 'Tetgen surface (*.smesh)'
tetgen = 'Tetgen files (*.poly *.smesh *.ele *.face *.edge *.node *.neigh)'
video = 'Video (*.mp4)'
vtk = 'VTK types (*.vtk *.vtp)'
vtp = 'vtkPolyData file (*.vtp)'
geometry = 'All Geometry files (*.gts *.inp *.neu *.obj *.off *.pgf *.ply *.pzf *.stl *.vtk *.vtp)'
45.2. Classes defined in module utils¶
- class utils.FileType(key, text, *suffixes)[source]¶
A class for holding file types and the related filename patterns.
- Parameters:
key (str) – A short and unique mnemonic string, by preference lower case, that wil be used as lookup key for this FileType definition in the global
FileTypes
collection.text (str) – A textual description of the file type.
*suffixes (sequence of str) – All remaining parameters are file suffixes that should be used to filter files that are supposed to be of this type. Any number of suffixes is allowed. If None are provided, all files will match the file type.
See also
FileTypes
the set of FileType’s knownd by pyFormex
- suffixes(compr=False)[source]¶
Return a list of file suffixes for the FileType.
- Parameters:
compr (bool) – If True, the file suffixes for compressed files of this type are automatically added.
Examples
>>> FileTypes['pgf'].suffixes() ['pgf'] >>> FileTypes['pgf'].suffixes(compr=True) ['pgf', 'pgf.gz', 'pgf.bz2'] >>> FileTypes['all'].suffixes() []
- patterns(compr=False)[source]¶
Return a list with the file patterns matching the FileType.
- Parameters:
compr (bool) – If True, the file suffixes for compressed files of this type are automatically added.
Examples
>>> FileTypes['pgf'].patterns() ['*.pgf'] >>> FileTypes['pgf'].patterns(compr=True) ['*.pgf', '*.pgf.gz', '*.pgf.bz2'] >>> FileTypes['all'].patterns() ['*']
- desc(compr=False)[source]¶
Create a filetype description compatible with Qt Widgets.
- Parameters:
compr (bool) – If True, the file patterns for compressed files are automatically added.
- Returns:
str – A string that can be directly used in the Qt File Dialog widgets to filter the selectable files. This string has the format:
file type text (*.ext1 *.ext2)
Examples
>>> FileTypes['img'].desc() 'Images (*.png *.jpg *.jpeg *.eps *.gif *.bmp)' >>> fileDescription('inp') 'Abaqus or CalCuliX input files (*.inp)' >>> fileDescription('doc') 'DOC files (*.doc)' >>> fileDescription('*.inp') '*.inp' >>> fileDescription('pgf',compr=True) 'pyFormex geometry files (*.pgf *.pgf.gz *.pgf.bz2)'
- class utils.DictDiff(current_dict, past_dict)[source]¶
A class to compute the difference between two dictionaries
- Parameters:
- class utils.Namespace[source]¶
A SimpleNamespace subclass that also has dict access methods.
The NameSpace class adds three dunder methods to the
types.SimpleNamespace
class: __getitem__, __setitem__ and__delitem__. This allows the attributes also to be accessed with dict methods. Furthermore, it defines an _attrs method to get a list of the defined attributes.Examples
>>> S = Namespace(a=0, b=1) >>> print(S) Namespace(a=0, b=1) >>> S['c'] = 2 >>> S.a = 3 >>> print(S) Namespace(a=3, b=1, c=2) >>> print(S.a, S['a']) 3 3 >>> del S.a >>> T = Namespace(**{'b':1, 'c':2}) >>> print(S, T) Namespace(b=1, c=2) Namespace(b=1, c=2) >>> print(S == T) True >>> del S['c'] >>> print(S == T) False >>> print(T._attrs()) ['b', 'c']
45.3. Functions defined in module utils¶
- utils.pzf_register(clas)[source]¶
Class decorator to allow load from PZF format.
Adding this decoratot to a class registers the class with the
pzffile
module. Objects in a PZF file with class name equal to clas.__name__ will then be restored using this class.
- utils.memoize(func)[source]¶
Remember the result of an instance method call.
This is a decorator function that saves the result of an instance method call into the instance. Subsequent use of the function will return the result from memory instead of recomputing it.
Notes
If the decorated function has no arguments other than self, this decorator can be stacked with @property to create a cached property.
The result is saved in a dict with the function name and its arguments as key. The dict is stored as an instance attribute _memory. It is created automatically on first used of a memoizing method.
Examples
We create a class with a single method, returning a list of 10 random ints in the range from 0 to 20. The method’s result is memoized. >>> class C: … @memoize … def random_ints(self): … print(“Computing random ints”) … return [random.randint(0,20) for i in range(10)]
We create an instance and call the random_ints method.
>>> c = C() >>> a = c.random_ints() Computing random ints >>> print(len(a), min(a) >= 0, max(a) <= 20) 10 True True
When calling the random_ints method again, the method is not actually executed, but the memoized values are returned, so they are the same as the previous.
>>> b = c.random_ints() >>> print(len(b), a == b) 10 True
If we create another instance, we get other values, because the memoizing is done per instance.
>>> b = C().random_ints() Computing random ints >>> print(len(b), a == b) 10 False
The results are stored in the _memory attribute. They can be deleted to force recomputation.
>>> print(c._memory) {'random_ints': [...]}
- utils.rev_lookup(dictionary, value, default=None)[source]¶
Reverse lookup in a dict
Lookup a value in a dict, and return its key (the first match).
- Parameters:
dictionary (dict) – The dict in which to lookup a value
value (anything) – The value to lookup in the dict
default (anything) – The key to return if the value was not found
- Returns:
key (anything) – The first key in the dict whose value matches the given
value
, ordefault
if no match was found.
- utils.warningCategory(category)[source]¶
Return a warning category and its alias
The input can be a category or an alias. Returns both as a tuple (alias, category). Invalid values return the default category (‘W’, Warning).
- utils.warningAction(action)[source]¶
Return a warning action and its alias
The input can be an action string or an alias. Returns both as a tuple (alias, action). Invalid values return the default action (‘i’, ‘ignore’).
- utils.filterWarning(message, module='', category='U', action='i', save=False)[source]¶
Add a warning message to the warnings filter.
category can be a Warning subclass or a key in the _warn_category dict
If save is True, the filter is saved in the user settings for future sessions.
- utils.resetWarningFilters()[source]¶
Reset the warning filters
Reset the warning filters to the Python defaults plus the ones listed in the ‘warnings/filters’ configuration variable.
- utils.warning(message, level=<class 'UserWarning'>, stacklevel=3)[source]¶
Decorator to add a warning to a function.
Adding this decorator to a function will warn the user with the supplied message when the decorated function gets executed for the first time in a session. An option is provided to switch off this warning in future sessions.
Decorating a function is done as follows:
@utils.warning('This is the message shown to the user') def function(args): ...
- utils.deprecated(message, stacklevel=4)[source]¶
Decorator to deprecate a function
This is like
warning()
, but the level is set to FutureWarning.
- utils.deprecated_by(old, new, stacklevel=4)[source]¶
Decorator to deprecate a function by another one.
Adding this decorator to a function will warn the user with a message that the old function is deprecated in favor of new, at the first execution of old.
See also:
deprecated()
.
- utils.deprecated_future()[source]¶
Decorator to warn that a function may be deprecated in future.
See also:
deprecated()
.
- utils.system(args, *, verbose=False, wait=True, **kargs)[source]¶
Execute a command through the operating system.
This is a wrapper around the
process.run()
function, aimed particularly at the pyFormex GUI user. It has one extra parameter: verbose. Seeprocess.run()
for the other parameters.- Parameters:
verbose (bool) – If True, the command, and a report of its outcome in case of failure, timeout or error exit, are written to stdout.
- Returns:
DoneProcess
or subprocess.Popen – If wait is True, returns aDoneProcess
with the outcome of the command. If wait is False, returns a subprocess.Popen which can be used to communicate with the started subprocess.
See also
process.run
run a system command in a subprocess
command
call
system()
with some other defaults
Examples
>>> P = system("pwd") >>> P.stdout.strip('\n') == os.getcwd() True
>>> P = system('true') >>> P DoneProcess(args=['true'], returncode=0, stdout='', stderr='') >>> P = system('false', capture_output=False) >>> P DoneProcess(args=['false'], returncode=1) >>> P = system('False', verbose=True) Running command: False DoneProcess report args: ['False'] Command failed to run! returncode: 127
>>> P = system("sleep 5", timeout=1, verbose=True) Running command: sleep 5 DoneProcess report args: ['sleep', '5'] returncode: -1 stdout: stderr: timedout: True
- utils.command(args, verbose=True, check=True, **kargs)[source]¶
Run an external command in a user friendly way.
This is equivalent with
system()
with verbose=True by default.
- utils.matchMany(regexps, target)[source]¶
Return multiple regular expression matches of the same target string.
- utils.matchAny(regexps, target)[source]¶
Check whether target matches any of the regular expressions.
- utils.matchNone(regexps, target)[source]¶
Check whether target matches none of the regular expressions.
- utils.matchAll(regexps, target)[source]¶
Check whether targets matches all of the regular expressions.
- utils.fileDescription(ftype, compr=False)[source]¶
Return a description of the specified file type(s).
- Parameters:
ftype (str or list of str) – The file type (or types) for which a description is requested. The case of the string(s) is ignored: it is converted to lower case.
- Returns:
str of list of str – The file description(s) corresponding with the specified file type(s). The return value(s) depend(s) on the value of the input string(s) in the the following way (see Examples below):
if it is a key in the
file_description
dict, the corresponding value is returned;if it is a string of only alphanumerical characters: it is interpreted as a file extension and the corresponding return value is
FTYPE files (*.ftype)
;any other string is returned as as: this allows the user to compose his filters himself.
Examples
>>> fileDescription('img') 'Images (*.png *.jpg *.jpeg *.eps *.gif *.bmp)' >>> fileDescription(['stl','all']) ['STL files (*.stl)', 'All files (*)'] >>> fileDescription('inp') 'Abaqus or CalCuliX input files (*.inp)' >>> fileDescription('doc') 'DOC files (*.doc)' >>> fileDescription('Video (*.mp4 *.ogv)') 'Video (*.mp4 *.ogv)' >>> fileDescription('pgf',compr=True) 'pyFormex geometry files (*.pgf *.pgf.gz *.pgf.bz2)'
- utils.fileTypes(ftype, compr=False)[source]¶
Return the list of file extension types for a given type.
- Parameters:
ftype (str) – The file type (see
fileDescription()
.compr (bool,optional) – If True, the compressed file types are automatically added.
- Returns:
list of str – A list of the normalized matching extensions for this type. Normalized extension do not have the leading dot and are lower case only.
Examples
>>> fileTypes('pgf') ['pgf'] >>> fileTypes('pgf',compr=True) ['pgf', 'pgf.gz', 'pgf.bz2']
- utils.fileTypesFromFilter(fdesc)[source]¶
Extract the filetypes from a file type descriptor.
A file type descriptor is a string consisting of an initial part followed by a second part enclosed in parentheses. The second part is a space separated list of glob patterns. An example file descriptor is ‘file type text (*.ext1 *.ext2)’. This is the format as returned by
FileType.desc()
.- Parameters:
- Returns:
desc (str) – The file type description text.
ext (list of str) – A list of the matching extensions (without dot) for this type. An empty string means that any extension is accepted.
Examples
>>> fileTypesFromFilter(FileTypes['img'].desc()) ['png', 'jpg', 'jpeg', 'eps', 'gif', 'bmp'] >>> fileTypesFromFilter(FileTypes['pgf'].desc(compr=True)) ['pgf', 'pgf.gz', 'pgf.bz2'] >>> fileTypesFromFilter('* *.png') ['', 'png'] >>> fileTypesFromFilter('Images (*.png *.jpg *.jpeg)') ['png', 'jpg', 'jpeg']
- utils.setFiletypeFromFilter(filename, fdesc)[source]¶
Make sure a filename has an acceptable suffix.
- Parameters:
- Returns:
Path – If filename had a suffix included in accept, returns the input filename unaltered. Else returns the filename with a dot and the first suffix from accepted appeded to it.
Examples
>>> setFiletypeFromFilter('image01.jpg', 'Images (*.png *.jpg *.jpeg)') Path('image01.jpg') >>> setFiletypeFromFilter('image01', 'Images (*.png *.jpg *.jpeg)') Path('image01.png')
- utils.okURL(url)[source]¶
Check that an URL is displayable in the browser.
- Parameters:
url (URL) – The URL to be checked.
- Returns:
bool – True if
url
starts with a protocol that is either ‘http:’, ‘https:’ or ‘file:’; else False
- utils.projectName(fn)[source]¶
Derive a project name from a file name.
The project name is the basename of the file without the extension. It is equivalent with Path(fn).stem
Examples
>>> projectName('aa/bb/cc.dd') 'cc' >>> projectName('cc.dd') 'cc' >>> projectName('cc') 'cc'
- utils.findIcon(name)[source]¶
Return the file name for an icon with given name.
- Parameters:
name (str) – Name of the icon: this is the stem fof the filename.
- Returns:
str – The full path name of an icon file with the specified name, found in the pyFormex icon folder, or the question mark icon file, if no match was found.
Examples
>>> print(findIcon('view-xr-yu').relative_to(pf.cfg['pyformexdir'])) icons/view-xr-yu.xpm >>> print(findIcon('right').relative_to(pf.cfg['pyformexdir'])) icons/64x64/right.png >>> print(findIcon('xyz').relative_to(pf.cfg['pyformexdir'])) icons/question.xpm >>> print(findIcon('recording').relative_to(pf.cfg['pyformexdir'])) icons/recording.gif
- utils.listIconNames(dirs=None, types=None)[source]¶
Return the list of available icons by their name.
- Parameters:
- Returns:
list of str – A sorted list of the icon names available in the pyFormex icons folder.
Examples
>>> listIconNames()[:4] ['clock', 'dist-angle', 'down', 'down'] >>> listIconNames([pf.cfg['icondir'] / '64x64'])[:4] ['down', 'ff', 'info', 'lamp'] >>> listIconNames(types=['.xpm'])[:4] ['clock', 'dist-angle', 'down', 'empty']
- utils.sourceFiles(relative=False, symlinks=True, extended=False)[source]¶
Return the list of pyFormex .py source files.
- Parameters:
relative (bool) – If True, returned filenames are relative to the current directory.
symlinks (bool) – If False, files that are symbolic links are retained in the list. The default is to remove them.
extended (bool) – If True, also return the .py files in all the paths in the configured appdirs and scriptdirs.
- Returns:
list of str – A list of filenames of .py files in the pyFormex source tree, and, if
extended
is True, .py files in the configured app and script dirs as well.
- utils.grepSource(pattern, options='', relative=True, verbose=False)[source]¶
Finds pattern in the pyFormex source files.
Uses the grep program to find all occurrences of some specified pattern text in the pyFormex source .py files (including the examples). Extra options can be passed to the grep command. See man grep for more info.
Returns the output of the grep command.
- utils.moduleList(package='all')[source]¶
Return a list of all pyFormex modules in a subpackage.
This is like
sourceFiles()
, but returns the files in a Python module syntax.
- utils.findModuleSource(module)[source]¶
Find the path of the source file of a module
module is either an imported module (pkg.mod) or a string with the module name (‘pkg.mod’), imported or not. Returns the source file from which the module was/would be loaded when imported. Raises an error if the module can not be imported or does not have a source file.
- utils.humanSize(size, units, ndigits=-1)[source]¶
Convert a number to a human size.
Large numbers are often represented in a more human readable form using k, M, G prefixes. This function returns the input size as a number with the specified prefix.
- Parameters:
size (int or float) – A number to be converted to human readable form.
units (str) – A string specifying the target units. The first character should be one of k,K,M,G,T,P,E,Z,Y. ‘k’ and ‘K’ are equivalent. A second character ‘i’ can be added to use binary (K=1024) prefixes instead of decimal (k=1000).
ndigits (int, optional) – If provided and >=0, the result will be rounded to this number of decimal digits.
- Returns:
float – The input value in the specified units and possibly rounded to
ndigits
.
Examples
>>> humanSize(1234567890,'k') 1234567.89 >>> humanSize(1234567890,'M',0) 1235.0 >>> humanSize(1234567890,'G',3) 1.235 >>> humanSize(1234567890,'Gi',3) 1.15
- utils.setSaneLocale(localestring='')[source]¶
Set a sane local configuration for LC_NUMERIC.
localestring is the locale string to be set, e.g. ‘en_US.UTF-8’ or ‘C.UTF-8’ for no locale.
Sets the
LC_ALL
locale to the specified string if that is not empty, and (always) setsLC_NUMERIC
andLC_COLLATE
to ‘C.UTF-8’.Changing the LC_NUMERIC setting is a very bad idea! It makes floating point values to be read or written with a comma instead of a the decimal point. Of course this makes input and output files completely incompatible. You will often not be able to process these files any further and create a lot of troubles for yourself and other people if you use an LC_NUMERIC setting different from the standard.
Because we do not want to help you shoot yourself in the foot, this function always sets
LC_NUMERIC
back to a sane ‘C’ value and we call this function when pyFormex is starting up.
- utils.rreplace(source, old, new, count=1)[source]¶
Replace substrings starting from the right.
Replaces count occurrences of old substring with a new substring. This is like str.replace, but counting starts from the right. The default count=1 replaces only the last occurrence, and is identical to str.replace (which is then preferred).
- Parameters:
- Returns:
str – The string with the replacements made. If source was a subclass of str, the returned string will be of the same subclass.
Examples
>>> print(rreplace('abababa', 'ab', '+de')) abab+dea >>> print(rreplace('abababa', 'ab', '+de', 2)) ab+de+dea >>> for i in (0, 1, 2, 3, 4, -1): ... print(f"{i}: {rreplace('abcabcabc', 'ab', '-ef', i)}") 0: abcabcabc 1: abcabc-efc 2: abc-efc-efc 3: -efc-efc-efc 4: -efc-efc-efc -1: -efc-efc-efc >>> rreplace(Path('dirname/filename.ext'), 'name.e', 'name00.n') Path('dirname/filename00.nxt')
- utils.strNorm(s)[source]¶
Normalize a string.
Text normalization removes all ‘&’ characters and converts it to lower case.
>>> strNorm("&MenuItem") 'menuitem'
- utils.slugify(text, delim='-')[source]¶
Convert a string into a URL-ready readable ascii text.
Examples
>>> slugify("http://example.com/blog/[Some] _ Article's Title--") 'http-example-com-blog-some-article-s-title' >>> slugify("&MenuItem") 'menuitem'
- utils.textFormat(text)[source]¶
Detect text format
- Parameters:
text (str) – A multiline string in one of the supported formats: plain text, html, rest, markdown
- Returns:
format (str) – The detected format: one of ‘plain’, ‘html’, ‘rest’ or ‘markdown’
Examples
>>> textFormat('''.. ... Header ... ------ ... ''') 'rest'
- utils.convertText(text, format='')[source]¶
Convert a text to a format recognized by Qt.
Input text format is plain, rest, markdown or html. Output text format is plain, markdown or html, with rest being converted to html.
- Parameters:
- Returns:
text (str) – The converted text, being either plain markdown or html.
format (str) – The output format: ‘plain’, ‘markdown’ or ‘html’
Notes
For the conversion of reStructuredText to work, the Python docutils have to be installed on the system.
Examples
>>> convertText('''.. ... Header ... ------ ... ''')[0].startswith('<?xml') True
- utils.forceReST(text, underline=False)[source]¶
Convert a text string to have it recognized as reStructuredText.
- Parameters:
- Returns:
str – The input text with two lines prepended: a line with ‘..’ and a blank line. The pyFormex text display functions will then recognize the text as being reStructuredText. Since the ‘..’ starts a comment in reStructuredText, the extra lines are not displayed. If underline=True, an extra line is added below the (original) first line, to make that line appear as a header.
Examples
>>> print(forceReST('Header\nBody', underline=True)) .. Header ------ Body
- utils.underlineHeader(s, c='-')[source]¶
Underline the first line of a text.
- Parameters:
s (str) – A multiline string.
c (char, optional) – The character to use for underlining. Default is ‘-‘.
- Returns:
str – A multiline string with the original text plus an extra line inserted below the first line. The new line has the same length as the first, but all characters are equal to the specified char.
>>> print(underlineHeader(“Hello World”))
Hello World
———–
- utils.sameLength(lines, length=-1, adjust='l')[source]¶
Make a sequence of strings the same length.
- Parameters:
length (int) – The required length of the lines. If negative, the length is set to the maximum input line length.
adjust ('l' | 'c' | 'r') – How the input lines are adjusted to respectively the left, the center or the right of the total length of the line.
Examples
>>> sameLength(['a', 'bb', 'ccc']) ['a ', 'bb ', 'ccc'] >>> sameLength(['a', 'bb', 'ccc'], adjust='c') [' a ', ' bb', 'ccc'] >>> sameLength(['a', 'bb', 'ccc'], adjust='r') [' a', ' bb', 'ccc'] >>> sameLength(['a', 'bb', 'ccc'], length=2) ['a ', 'bb', 'cc']
- utils.framedText(text, padding=[0, 2, 0, 2], border=[1, 2, 1, 2], margin=[0, 0, 0, 0], borderchar='####', adjust='l')[source]¶
Create a text with a frame around it.
- Parameters:
padding (list of int) – Number of blank spaces around text, at the top, right, bottom, left.
border (list of int) – Border width, at the top, right, bottom, left.
margin (list of int) – Number of blank spaces around border, at the top, right, bottom, left.
borderchar (str) – Border charater, at the top, right, bottom, left.
width (int) – Intended width of the
adjust ('l' | 'c' | 'r') – Adjust the text to the left, center or right.
- Returns:
str – A multiline string with the formatted framed text.
Examples
>>> print(framedText("Hello World,\nThis is me calling",adjust='c')) ########################## ## Hello World, ## ## This is me calling ## ########################## >>> print(framedText("Hello World,\nThis is me calling",margin=[1,0,0,3])) ########################## ## Hello World, ## ## This is me calling ## ##########################
- utils.prefixText(text, prefix)[source]¶
Add a prefix to all lines of a text.
- Parameters:
- Returns:
str – A multiline string with the input lines prefixed with prefix.
Examples
>>> print(prefixText("line1\nline2","** ")) ** line1 ** line2
- utils.timeEval(s, glob=None)[source]¶
Return the time needed for evaluating a string.
s is a string with a valid Python instructions. The string is evaluated using Python’s eval() and the difference in seconds between the current time before and after the evaluation is printed. The result of the evaluation is returned.
This is a simple method to measure the time spent in some operation. It should not be used for microlevel instructions though, because the overhead of the time calls. Use Python’s timeit module to measure microlevel execution time.
- utils.is_script(appname)[source]¶
Checks whether an application name is rather a script name
- Parameters:
appname (str) – The name of a script file or an app.
- Returns:
bool – True if appname ends with ‘.py’, or contains a ‘/’.
- utils.prefixDict(d, prefix='')[source]¶
Prefix all the keys of a dict with the given prefix.
- Parameters:
- Returns:
dict – A dict with the same contents as the input, but where all keys have been prefixed with the given prefix string.
Examples
>>> prefixDict({'a':0,'b':1},'p_') {'p_a': 0, 'p_b': 1}
- utils.subDict(d, prefix='', strip=True, remove=False)[source]¶
Return a dict with the items whose key starts with prefix.
- Parameters:
- Returns:
dict – A dict with all the items from
d
whose key starts withprefix
. The keys in the returned dict will have the prefix stripped off, unless strip=False is specified.
Examples
>>> subDict({'p_a':0,'q_a':1,'p_b':2}, 'p_') {'a': 0, 'b': 2} >>> subDict({'p_a':0,'q_a':1,'p_b':2}, 'p_', strip=False) {'p_a': 0, 'p_b': 2} >>> a = {'p_a':0,'q_a':1,'p_b':2} >>> b = subDict(a, 'p_', remove=True, strip=False) >>> a, b ({'q_a': 1}, {'p_a': 0, 'p_b': 2})
- utils.selectDict(d, keys, remove=False)[source]¶
Return a dict with the items whose key is in keys.
- Parameters:
- Returns:
dict – A dict with all the items from
d
whose key is inkeys
.
See also
removeDict
the complementary operation, returns items not in
keys
.
Examples
>>> d = dict([(c,c*c) for c in range(4)]) >>> print(d) {0: 0, 1: 1, 2: 4, 3: 9} >>> selectDict(d,[2,0]) {2: 4, 0: 0} >>> print(d) {0: 0, 1: 1, 2: 4, 3: 9} >>> selectDict(d,[2,0,6],remove=True) {2: 4, 0: 0} >>> print(d) {1: 1, 3: 9}
- utils.removeDict(d, keys)[source]¶
Return a dict with the specified keys removed.
- Parameters:
- Returns:
dict – A dict with all the items from
d
whose key is not inkeys
.
See also
selectDict
the complementary operation returning the items in
keys
Examples
>>> d = dict([(c,c*c) for c in range(6)]) >>> removeDict(d,[4,0]) {1: 1, 2: 4, 3: 9, 5: 25}
- utils.mutexkeys(d, keys)[source]¶
Enforce a set of mutually exclusive keys in a dictionary.
This makes sure that d has only one of the specified keys. It modifies the dictionary inplace.
- Parameters:
d (dict) – The input dictionary.
keys – A list of dictionary keys that are mutually exclusive.
Examples
>>> d = {'a':0, 'b':1, 'c':2} >>> mutexkeys(d, ['b', 'c', 'a']) >>> print(d) {'b': 1}
- utils.refreshDict(d, src)[source]¶
Refresh a dict with values from another dict.
The values in the dict d are update with those in src. Unlike the dict.update method, this will only update existing keys but not add new keys.
- utils.inverseDict(d)[source]¶
Return the inverse of a dictionary.
Returns a dict with keys and values interchanged.
Example:
>>> inverseDict({'a':0,'b':1}) {0: 'a', 1: 'b'}
- utils.selectDictValues(d, values)[source]¶
Return the keys in a dict which have a specified value
d: a dict where all the keys are strings.
values: a list/set of values.
The return value is a list with all the keys from d whose value is in keys.
Example:
>>> d = dict([(c,c*c) for c in range(6)]) >>> selectDictValues(d,range(10)) [0, 1, 2, 3]
- utils.totalMemSize(o, handlers={}, verbose=False)[source]¶
Return the approximate total memory footprint of an object.
This function returns the approximate total memory footprint of an object and all of its contents.
Automatically finds the contents of the following builtin containers and their subclasses: tuple, list, deque, dict, set and frozenset. To search other containers, add handlers to iterate over their contents:
- handlers = {SomeContainerClass: iter,
OtherContainerClass: OtherContainerClass.get_elements}
Adapted from http://code.activestate.com/recipes/577504/