utool._internal package

Submodules

utool._internal.meta_util_arg module

utool._internal.meta_util_arg.get_argflag(flag)

utool._internal.meta_util_arg.get_argval(argstr, type_=None, default=None)

Returns a value of an argument specified on the command line after some flag

CommandLine:

python -c “import utool; print([(type(x), x) for x in [utool.get_argval(’–quest’)]])” –quest=”holy grail” python -c “import utool; print([(type(x), x) for x in [utool.get_argval(’–quest’)]])” –quest=”42” python -c “import utool; print([(type(x), x) for x in [utool.get_argval(’–quest’)]])” –quest=42 python -c “import utool; print([(type(x), x) for x in [utool.get_argval(’–quest’)]])” –quest 42 python -c “import utool; print([(type(x), x) for x in [utool.get_argval(’–quest’, float)]])” –quest 42

Example

>>> # DISABLE_DOCTEST
>>> from utool.util_arg import *  # NOQA
>>> import sys
>>> sys.argv.extend(['--spam', 'eggs', '--quest=holy grail', '--ans=42'])
>>> get_argval('--spam', type_=str, default=None)
eggs
>>> get_argval('--quest', type_=str, default=None)
holy grail
>>> get_argval('--ans', type_=int, default=None)
42

utool._internal.meta_util_cache module

utool._internal.meta_util_cache.global_cache_read(key, appname=None, **kwargs)

utool._internal.meta_util_constants module

utool._internal.meta_util_cplat module

utool._internal.meta_util_cplat.get_app_resource_dir(*args, **kwargs)

Returns a writable directory for an application

Parameters:

• appname – the name of the application
• args – any other subdirectories may be specified

utool._internal.meta_util_cplat.get_resource_dir()

Returns a directory which should be writable for any application

utool._internal.meta_util_dbg module

utool._internal.meta_util_dbg.get_caller_lineno(N=0, strict=True)

utool._internal.meta_util_dbg.get_caller_name(N=0, strict=True)

Standalone version of get_caller_name

utool._internal.meta_util_dbg.get_stack_frame(N=0, strict=True)

utool._internal.meta_util_git module

utool._internal.meta_util_iter module

utool._internal.meta_util_iter.ensure_iterable(obj)

Parameters:obj (scalar or iterable) – Returns:obj if it was iterable otherwise [obj] Return type:it3erable

CommandLine:

python -m utool._internal.meta_util_iter –test-ensure_iterable

Timeit:

%timeit ut.ensure_iterable([1]) %timeit ut.ensure_iterable(1) %timeit ut.ensure_iterable(np.array(1)) %timeit ut.ensure_iterable([1]) %timeit [1]

Example

>>> # DISABLE_DOCTEST
>>> from utool._internal.meta_util_iter import *  # NOQA
>>> # build test data
>>> obj_list = [3, [3], '3', (3,), [3,4,5]]
>>> # execute function
>>> result = [ensure_iterable(obj) for obj in obj_list]
>>> # verify results
>>> result = str(result)
>>> print(result)
[[3], [3], ['3'], (3,), [3, 4, 5]]

utool._internal.meta_util_iter.isiterable(obj)

Returns if the object can be iterated over and is NOT a string # TODO: implement isscalar similar to numpy

Parameters:obj (scalar or iterable) – Returns: Return type:bool

CommandLine:

python -m utool._internal.meta_util_iter –test-isiterable

Example

>>> # DISABLE_DOCTEST
>>> from utool._internal.meta_util_iter import *  # NOQA
>>> # build test data
>>> obj_list = [3, [3], '3', (3,), [3,4,5]]
>>> # execute function
>>> result = [isiterable(obj) for obj in obj_list]
>>> # verify results
>>> print(result)
[False, True, False, True, True]

utool._internal.meta_util_iter.isscalar(obj)

utool._internal.meta_util_path module

utool._internal.meta_util_path.ensuredir(dpath)

utool._internal.meta_util_path.truepath(path)

Normalizes and returns absolute path with so specs

utool._internal.meta_util_path.unixjoin(*args)

Like os.path.join, but uses forward slashes on win32

utool._internal.meta_util_path.unixpath(path)

TODO: rename to unix_truepath Corrects fundamental problems with windows paths.~

utool._internal.meta_util_six module

utool._internal.meta_util_six.ensure_unicode(str_)

Todo

rob gp “isinstance(.*\bstr\b)”

utool._internal.meta_util_six.get_funccode(func)

utool._internal.meta_util_six.get_funcdoc(func)

utool._internal.meta_util_six.get_funcglobals(func)

utool._internal.meta_util_six.get_funcname(func)

utool._internal.meta_util_six.set_funcdoc(func, newdoc)

utool._internal.meta_util_six.set_funcname(func, newname)

utool._internal.py2_syntax_funcs module

utool._internal.py2_syntax_funcs.ignores_exc_tb(*args, **kwargs)

PYTHON 2 ONLY VERSION – needs to be in its own file for syntactic reasons

ignore_exc_tb decorates a function and remove both itself and the function from any exception traceback that occurs.

This is useful to decorate other trivial decorators which are polluting your stacktrace.

utool._internal.randomwrap module

This is a minimal Python client for Mads Haahr’s random number generator at www.random.org

# This tiny set of functions only implements a subset of the HTTP interface available. In particular it only uses the ‘live’ # random number generator, and doesn’t offer the option of using the alternative ‘stored’ random # number sets. However, it should be obvious how to extend it by sending requests with different parameters. # The web service code is modelled on Mark Pilgrim’s “Dive into Python” tutorial at http://www.diveintopython.org/http_web_services # This client by George Dunbar, University of Warwick (Copyright George Dunbar, 2008) # It is distributed under the Gnu General Public License.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

See <http://www.gnu.org/licenses/> for a copy of the GNU General Public License. For use that falls outside this license, please contact me.

To use in a python script or at the interactive prompt (randomwrapy.py has to be in the Python search path, of course):

from randomwrapy import *

rnumlistwithoutreplacement(0, 12)

# returns a list of the integers 0 - 12 inclusive, in a random order

rnumlistwithreplacement(12, 5)

# returns 12 integers from the range [0, 5]

rnumlistwithreplacement(12, 5, 2)

# returns 12 integers from the range [2, 5]

rrandom()

# returns a random float in the range [0, 1]

reportquota()

# tells you how many bits you have available; visit www.random.org/quota for more information

Arguments where given are (must be) numbers, of course. There is almost no error checking in these scripts! For example, if the web site is down, Python will simply raise an exception and report the http error code. See worldrandom.py for an alternative implementation that goes a little further with error checking.

utool._internal.randomwrap.build_request_parameterNR(min, max)

utool._internal.randomwrap.build_request_parameterWR(howmany, min, max)

utool._internal.randomwrap.checkquota()

utool._internal.randomwrap.reportquota()

utool._internal.randomwrap.rnumlistwithoutreplacement(min, max)

Returns a randomly ordered list of the integers between min and max

utool._internal.randomwrap.rnumlistwithreplacement(howmany, max, min=0)

Returns a list of howmany integers with a maximum value = max. The minimum value defaults to zero.

utool._internal.randomwrap.rrandom()

Get the next random number in the range [0.0, 1.0]. Returns a float.

utool._internal.util_importer module

NEEDS CLEANUP SO IT EITHER DOES THE IMPORTS OR GENERATES THE FILE

python -c “import utool”

utool._internal.util_importer.dynamic_import(modname, import_tuples, developing=True, ignore_froms=[], dump=False, ignore_startswith=[], ignore_endswith=[], ignore_list=[], check_not_imported=True, return_initstr=False, verbose=False)

MAIN ENTRY POINT

Dynamically import listed util libraries and their attributes. Create reload_subs function.

Using __import__ like this is typically not considered good style However, it is better than import * and this will generate the good file text that can be used when the module is ‘frozen”

Returns:

init_inject_str - by default all imports are executed in this

function and only the remainig code needed to be executed is returned to define the reload logic.

str, str: init_inject_str, init_str - if return_initstr is True then

also returns init_str defining the from imports.

Return type:str

Ignore:

ignore_startswith = [] ignore_endswith = [] check_not_imported = True verbose = True

utool._internal.util_importer.make_import_tuples(module_path, exclude_modnames=[])

Infer the import_tuples from a module_path

utool._internal.util_importer.make_initstr(modname, import_tuples, verbose=False)

Just creates the string representation. Does no importing.

utool._internal.win32_send_keys module

Check that SendInput can work the way we want it to

The tips and tricks at http://www.pinvoke.net/default.aspx/user32.sendinput is useful!

exception utool._internal.win32_send_keys.KeySequenceError

Bases: Exception

Exception raised when a key sequence string has a syntax error

utool._internal.win32_send_keys.SendKeys(keys, pause=0.05, with_spaces=False, with_tabs=False, with_newlines=False, turn_off_numlock=True)

Parse the keys and type them

Module contents

Need to hack to make work for internal modules and reload subs properly

Regen Command:

cd /home/joncrall/code/utool/utool/_internal makeinit.py -x win32_send_keys