def _stored(self, key, default=None): value, expires = default, None with suppress(OSError): with open(self.__file_path(key), 'rb') as file: with suppress(Exception): (value, expires) = pickle.load(file) return value, expires
def create(self, path, is_dir=True, parents=True): path = pathlib.Path(path) if is_dir: with suppress(Exception): path.mkdir(parents=parents) else: parent_dir = path.parent with suppress(Exception): parent_dir.mkdir(parents=parents) path.touch() return str(path)
def instantiate(self, definition): item = definition['item'] if hasattr(item, '__ioc_definition__'): definition.update(item.__ioc_definition__) args, kwargs = [], {} is_lambda = definition.get('call_type', None) == FUNCTION_TYPE sig = signature(item) if 'container' in sig.parameters: kwargs['container'] = self.container if 'init' in definition: init = definition['init'] updated_args, updated_kwargs = self.get_args_kwargs(init) args.extend(updated_args) kwargs.update(updated_kwargs) if isfunction(init): sig = signature(init) if 'container' in sig.parameters: kwargs['container'] = self.container init = init(*args, **kwargs) definition['init'] = init if not is_lambda: args, kwargs = self.get_args_kwargs(init) item = item(*args, **kwargs) if is_lambda and isinstance(item, str): # Special case for items that might be retrieved via lambda expressions with suppress(Exception): definition['item'] = self.container.load_item_from_string(item) item, args, kwargs = self.instantiate(definition) return item, args, kwargs
def test(self): """Runs the unit tests for the project. """ current_directory = os.getcwd() os.chdir(os.path.join(current_directory, '..')) try: app_module = os.environ['APP_MODULE'] test_runner = None cli_args = '' sys.argv = [sys.argv.pop(0)] try: import pytest test_runner = 'pytest' cli_args = '--cov {0}'.format(app_module) except: with suppress(ImportError): import nose test_runner = 'nose' cli_args = '--cover-package={0}'.format(app_module) if test_runner: sys.modules[test_runner].main(cli_args.split(' ')) else: raise ConsoleError( "You must install either 'nose' or 'py.test' to run the unit tests.") except: _no_application_error() os.chdir(current_directory)
def register_components(self): """Register any components specified with the application. Components can include the following modules: - dependencies - events - models - routes - views Registering a component will merge any configuration settings within the above modules prior to the application booting. An example component might look like: /component /views /index.html /routes.py /views.py """ types = ('dependencies', 'events', 'routes', 'models', 'views') for component in self.config['components']: for type_ in types: with contextmanagers.suppress(Exception): type_component = imports.load_definition_from_string( '{}.{}.{}'.format(component, type_, type_)) if type_ == 'dependencies': self.container.update(type_component) if not isinstance(type_component, ModuleType): self._config[type_] = dict_deep_update( self._config.get(type_, {}), type_component) self._config['views'][ 'renderers']['jinja2']['config']['packages'].append( (component, 'views'))
def _load(self): try: with open(self.__file_path(), 'rb') as file: with suppress(Exception): return pickle.load(file) except: return ()
def __delitem__(self, key): if not self.data: self.load() with suppress(KeyError): del self.data[key] if self.autosave: self.save()
def _save(self, expires): with open(self.__file_path(), 'wb') as file: with suppress(Exception): pickle.dump( (self.data, expires), file, pickle.HIGHEST_PROTOCOL)
def build_route(self, **definition): """Converts a route definition into a specific route. """ for strategy in self._build_strategies: with suppress(TypeError): return strategy(**definition) raise Exception( 'No strategy is capable of building route {0}'.format(definition))
def clear(self): """Clears the flash messages from the container and session. This is called automatically after the flash messages have been iterated over. """ with suppress(KeyError): del self.session[self.session_key] self.messages = collections.OrderedDict() self.__write_to_session()
def get_form_vars(environ, dict_type): """Convert environ vars into GET/POST/FILES objects. Process all get and post vars from a <form> and return MultiDict of each. """ if environ['REQUEST_METHOD'] == 'PUT' and not environ.get('CONTENT_TYPE'): environ['CONTENT_TYPE'] = 'application/x-www-form-urlencoded' field_storage = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ, keep_blank_values=True) post_dict, files_dict = dict_type(), dict_type() with suppress(Exception): post_dict._mutable = True files_dict._mutable = True post, files = _process_field_storage(field_storage, post_dict, files_dict) with suppress(Exception): post.make_immutable() files.make_immutable() return post, files
def invalidate(self): """Invalidate the data that has been bound on the form. This is called automatically when data is bound to the form and sets the forms validity to invalid. """ attrs = ('_data', '_raw_data', '_errors', '_form_errors') for attr in attrs: with suppress(AttributeError): delattr(self, attr) self._validated = self._valid = False
def add_func_to_arg_list(self, func, name, prefixed_name): index = None try: index = [arg[0] for arg in func.__args__].index(prefixed_name) except: with suppress(Exception): idx = [arg[0] for arg in func.__args__].index(name) del func.__args__[idx] func.__args__.append((prefixed_name, self.kwargs)) if index: func.__args__[index] = (self.arg_name, self.kwargs)
def execute(self, args): """Execute the runner and any commands the user has specified. """ if not args: args = sys.argv[:] self._name = os.path.basename(args.pop(0)) execute = True help = '-h' method = help namespace = None # Always show help if invalid command try: namespace, method, *_ = args except: with suppress(Exception): namespace = args[0] execute = False args.append(method) if namespace: args = args[1:] if namespace == help: namespace = None # Add the relevant commands parser = argparse.ArgumentParser() try: self.attach_commands(parser, namespace) except ConsoleError as exc: self._handle_exc(exc) # Parse the input parsed_args = parser.parse_args(args) if execute: instance, method, args = parsed_args.command try: kwargs = {arg_name: getattr(parsed_args, arg_name) for attr, arg_name in args.items()} return getattr(instance, method)(**kwargs) except ConsoleError as exc: self._handle_exc(exc)
def _process_field_storage(fs, post, files): with suppress(Exception): for name in fs: field = fs[name] if isinstance(name, str) else name if isinstance(field, list): _process_field_storage(field, post, files) elif field.filename: # An uploaded file, create a new File tuple to resolve the # not indexable issue. files[field.name] = File( field.file, field.filename, field.name, field.type, field.type_options, field.disposition, field.disposition_options, field.headers, field) else: post[field.name] = field.value return post, files
def _destroy(self): with suppress(OSError): os.unlink(self.__file_path())
def execute(self, **kwargs): actual_kwargs = kwargs.copy() with suppress(Exception): del actual_kwargs['action'] method = self.get_execute_method(**kwargs) return method(**actual_kwargs) or {}
# -*- coding: utf-8 -*- import collections from watson.http.sessions import StorageMixin from watson.common import imports from watson.common.contextmanagers import suppress from watson.http.sessions.serializers import Json with suppress(ImportError): import redis class Storage(StorageMixin): """A redis based storage adapter for session data. """ client = None serializer = None serializer_class = Json encoding = 'utf-8' def __init__(self, id=None, timeout=None, autosave=True, config=None): super(Storage, self).__init__(id, timeout, autosave) settings = {'host': 'localhost', 'port': 6379, 'db': 0} if config: self._process_config(config) self.config = collections.ChainMap(config or {}, settings) self.serializer = self.serializer_class() def _process_config(self, config): if 'serializer_class' in config: self.serializer_class = imports.load_definition_from_string( config['serializer_class'])
def __delitem__(self, key): with suppress(OSError): os.unlink(self.__file_path(key))
def __setitem__(self, key, value, timeout=0): expires = datetime.now() + timedelta( seconds=int(timeout)) if timeout else None with open(self.__file_path(key), 'wb') as file: with suppress(Exception): pickle.dump((value, expires), file, pickle.HIGHEST_PROTOCOL)
def test_ignored_exception(): with suppress(Exception): raise Exception assert True