def test_load_attribute(self): # already imported self.assertIdentical(modules.load_attribute('sys.path'), sys.path) # unimported myfoo = modules.load_attribute('mod_testpack.mod_test2.foo') # "Unable to import" # pylint: disable=F0401 from mod_testpack.mod_test2 import foo self.assertIdentical(foo, myfoo) # nonexisting attribute self.assertRaises( modules.FailedImport, modules.load_attribute, 'snakeoil.froznicator') # nonexisting top-level self.assertRaises( modules.FailedImport, modules.load_attribute, 'spork_does_not_exist.foo') # not an attr self.assertRaises( modules.FailedImport, modules.load_attribute, 'sys') # not imported yet self.assertRaises( modules.FailedImport, modules.load_attribute, 'mod_testpack.mod_test3')
def convert_string(central, value, arg_type): """Conversion func for a string-based DictConfigSection.""" if not isinstance(value, str): raise ValueError( 'convert_string invoked with non str instance: ' f'val({value!r}), arg_type({arg_type!r})' ) if arg_type == 'callable': try: func = modules.load_attribute(value) except modules.FailedImport as e: raise errors.ConfigurationError(f'cannot import {value!r}') from e if not callable(func): raise errors.ConfigurationError(f'{value!r} is not callable') return func elif arg_type.startswith('refs:'): return list(LazyNamedSectionRef(central, arg_type, ref) for ref in str_to_list(value)) elif arg_type.startswith('ref:'): return LazyNamedSectionRef(central, arg_type, str_to_str(value)) elif arg_type == 'repr': return 'str', value func = _str_converters.get(arg_type) if func is None: raise errors.ConfigurationError(f'unknown type {arg_type!r}') return func(value)
def test_load_attribute(self): # already imported self.assertIdentical(modules.load_attribute('sys.path'), sys.path) # unimported myfoo = modules.load_attribute('mod_testpack.mod_test2.foo') # "Unable to import" # pylint: disable=F0401 from mod_testpack.mod_test2 import foo self.assertIdentical(foo, myfoo) # nonexisting attribute self.assertRaises(modules.FailedImport, modules.load_attribute, 'snakeoil.froznicator') # nonexisting top-level self.assertRaises(modules.FailedImport, modules.load_attribute, 'spork_does_not_exist.foo') # not an attr self.assertRaises(modules.FailedImport, modules.load_attribute, 'sys') # not imported yet self.assertRaises(modules.FailedImport, modules.load_attribute, 'mod_testpack.mod_test3')
def test_load_attribute(self): # already imported assert modules.load_attribute('sys.path') is sys.path # unimported myfoo = modules.load_attribute('mod_testpack.mod_test2.foo') # "Unable to import" # pylint: disable=F0401 from mod_testpack.mod_test2 import foo assert foo is myfoo # nonexisting attribute with pytest.raises(modules.FailedImport): modules.load_attribute('snakeoil.froznicator') # nonexisting top-level with pytest.raises(modules.FailedImport): modules.load_attribute('spork_does_not_exist.foo') # not an attr with pytest.raises(modules.FailedImport): modules.load_attribute('sys') # not imported yet with pytest.raises(modules.FailedImport): modules.load_attribute('mod_testpack.mod_test3')
def python_namespace_type(value, module=False, attribute=False): """ return the object from python namespace that value specifies :param value: python namespace, snakeoil.modules for example :param module: if true, the object must be a module :param attribute: if true, the object must be a non-module :raises ValueError: if the conditions aren't met, or import fails """ try: if module: return import_module(value) elif attribute: return modules.load_attribute(value) return modules.load_any(value) except (ImportError, modules.FailedImport) as err: compatibility.raise_from(argparse.ArgumentTypeError(str(err)))
def format_version(project, file_in_the_repo, api_version): from snakeoil import modules cwd = os.path.dirname(os.path.abspath(file_in_the_repo)) try: version_info = modules.load_attribute( '%s._verinfo.version_info' % (project,)) except modules.FailedImport: version_info = get_git_version(cwd) if not version_info: s = "extend version info unavailable" elif version_info['tag'] == api_version: s = 'released %s' % (version_info['date'],) else: s = ('vcs version %s, date %s' % (version_info['rev'], version_info['date'])) return '%s %s\n%s' % (project, api_version, s)
def format_version(project, file_in_the_repo, api_version): from snakeoil import modules cwd = os.path.dirname(os.path.abspath(file_in_the_repo)) try: version_info = modules.load_attribute('%s._verinfo.version_info' % (project, )) except modules.FailedImport: version_info = get_git_version(cwd) if not version_info: s = "extend version info unavailable" elif version_info['tag'] == api_version: s = 'released %s' % (version_info['date'], ) else: s = ('vcs version %s, date %s' % (version_info['rev'], version_info['date'])) return '%s %s\n%s' % (project, api_version, s)
if isinstance(filename, basestring) and fchksum is not None: return long(fchksum.fmd5t(filename)[0], 16) return chksum_loop_over_file(filename, md5.new)[0] chksum_types["md5"] = MD5Chksummer() # expand this to load all available at some point for k, v, str_size in (("sha1", "SHA", sha1_size), ("sha256", "SHA256", sha256_size), ("sha512", "SHA512", sha512_size), ("rmd160", "RIPEMD", rmd160_size)): if k in chksum_types: continue try: chksum_types[k] = Chksummer(k, modules.load_attribute( "Crypto.Hash.%s.new" % v), str_size) except modules.FailedImport: pass del k, v for modulename, chksumname, size in [ ('sha', 'sha1', sha1_size), ('md5', 'md5', md5_size), ]: if chksumname not in chksum_types: chksum_types[chksumname] = Chksummer(chksumname, modules.load_attribute('%s.new' % (modulename,)), size) del modulename, chksumname try:
def render_value(self, central, name, arg_type): value = self.section[name] if arg_type == 'callable': if len(value) != 1: raise errors.ConfigurationError('only one argument required') value = value[0] if not isinstance(value, basestring): raise errors.ConfigurationError( 'need a callable, not a section') try: value = modules.load_attribute(value) except modules.FailedImport: raise errors.ConfigurationError('cannot import %r' % (value,)) if not callable(value): raise errors.ConfigurationError('%r is not callable' % value) return value elif arg_type.startswith('ref:'): if len(value) != 1: raise errors.ConfigurationError('only one argument required') value = value[0] if isinstance(value, basestring): # it's a section ref return basics.LazyNamedSectionRef(central, arg_type, value) else: # it's an anonymous inline section return basics.LazyUnnamedSectionRef(central, arg_type, ConfigSection(value)) elif arg_type.startswith('refs:'): result = [] for ref in value: if isinstance(ref, basestring): # it's a section ref result.append(basics.LazyNamedSectionRef( central, arg_type, ref)) else: # it's an anonymous inline section result.append(basics.LazyUnnamedSectionRef( central, arg_type, ConfigSection(ref))) return None, result, None elif arg_type == 'list': if not isinstance(value, basestring): # sequence value = ' '.join(value) return None, basics.str_to_list(value), None elif arg_type == 'repr': if len(value) == 1: value = value[0] if isinstance(value, basestring): return 'str', value return 'ref', ConfigSection(value) if all(isinstance(v, basestring) for v in value): return 'list', list(value) result = [] for v in value: if not isinstance(v, basestring): v = ConfigSection(v) result.append(v) return 'refs', result else: if len(value) != 1: raise errors.ConfigurationError('only one argument required') if not isinstance(value[0], basestring): raise errors.ConfigurationError( '%r should be a string' % value) if arg_type == 'str': return [None, basics.str_to_str(value[0]), None] elif arg_type == 'bool': return basics.str_to_bool(value[0]) else: raise errors.ConfigurationError( 'unsupported type %r' % (arg_type,))
else: chksum_types[chksumname] = Chksummer( chksumname, partial(hashlib.new, hashlibname), size) del hashlibname, chksumname # expand this to load all available at some point for k, v, str_size in ( ("sha1", "SHA", sha1_size), ("sha256", "SHA256", sha256_size), ("sha512", "SHA512", sha512_size), ("rmd160", "RIPEMD", rmd160_size), ): if k in chksum_types: continue try: chksum_types[k] = Chksummer(k, modules.load_attribute( "Crypto.Hash.%s.new" % v), str_size) except modules.FailedImport: pass del k, v class SizeUpdater(object): def __init__(self): self.count = 0 def update(self, data): self.count += len(data) def hexdigest(self): return "%x" % self.count
]: try: hashlib.new(hashlibname) except ValueError: pass # This hash is not available. else: chksum_types[chksumname] = Chksummer(chksumname, partial(hashlib.new, hashlibname), size) del hashlibname, chksumname if 'whirlpool' not in chksum_types: # Fallback to the python implementation. chksum_types['whirlpool'] = Chksummer( 'whirlpool', modules.load_attribute('snakeoil.chksum._whirlpool.Whirlpool'), whirlpool_size) # expand this to load all available at some point for k, v, str_size in ( ("sha1", "SHA", sha1_size), ("sha256", "SHA256", sha256_size), ("sha512", "SHA512", sha512_size), ("rmd160", "RIPEMD", rmd160_size), ): if k in chksum_types: continue try: chksum_types[k] = Chksummer( k, modules.load_attribute("Crypto.Hash.%s.new" % v), str_size) except modules.FailedImport: