From e1f2d5e3b8299b5aa86b6b31379896940306593e Mon Sep 17 00:00:00 2001 From: Roman Mogilatov Date: Mon, 9 Mar 2015 00:01:39 +0200 Subject: [PATCH] making pep257 and flake8 happy --- objects/__init__.py | 8 +- objects/catalog.py | 37 ++---- objects/injections.py | 32 ++--- objects/providers.py | 263 ++++++++++++++++-------------------------- 4 files changed, 124 insertions(+), 216 deletions(-) diff --git a/objects/__init__.py b/objects/__init__.py index 70e3e631..b249cb20 100644 --- a/objects/__init__.py +++ b/objects/__init__.py @@ -1,6 +1,4 @@ -""" -`Objects` library. -""" +"""Objects.""" from .catalog import AbstractCatalog, overrides from .providers import (Provider, NewInstance, Singleton, Class, Object, @@ -8,11 +6,11 @@ from .providers import (Provider, NewInstance, Singleton, Class, Object, from .injections import InitArg, Attribute, Method -__all__ = ['AbstractCatalog', 'overrides', +__all__ = ('AbstractCatalog', 'overrides', # Providers 'Provider', 'NewInstance', 'Singleton', 'Class', 'Object', 'Function', 'Value', # Injections - 'InitArg', 'Attribute', 'Method'] + 'InitArg', 'Attribute', 'Method') diff --git a/objects/catalog.py b/objects/catalog.py index 56826245..f81272b0 100644 --- a/objects/catalog.py +++ b/objects/catalog.py @@ -1,28 +1,18 @@ -""" -Catalog module. -""" +"""Catalog module.""" from .providers import Provider class AbstractCatalog(object): - """ - Abstract object provides catalog. - """ + + """Abstract object provides catalog.""" def __init__(self, *used_providers): - """ - Initializer. - """ + """Initializer.""" self.__used_providers__ = set(used_providers) def __getattribute__(self, item): - """ - Returns providers. - - :param item: - :return: - """ + """Return providers.""" attribute = super(AbstractCatalog, self).__getattribute__(item) if item in ('__used_providers__',): return attribute @@ -34,9 +24,7 @@ class AbstractCatalog(object): @classmethod def __all_providers__(cls, provider_type=Provider): - """ - Returns set of all class providers. - """ + """Return set of all class providers.""" providers = set() for attr_name in set(dir(cls)) - set(dir(AbstractCatalog)): provider = getattr(cls, attr_name) @@ -48,23 +36,18 @@ class AbstractCatalog(object): @classmethod def __override___(cls, overriding): """ - Overrides current catalog providers by overriding catalog providers. + Override current catalog providers by overriding catalog providers. :param overriding: AbstractCatalog """ - overriden = overriding.__all_providers__() - cls.__all_providers__() - for name, provider in overriden: + overridden = overriding.__all_providers__() - cls.__all_providers__() + for name, provider in overridden: overridden_provider = getattr(cls, name) overridden_provider.__override__(provider) def overrides(catalog): - """ - Catalog overriding decorator. - - :param catalog: - :return: - """ + """Catalog overriding decorator.""" def decorator(overriding_catalog): catalog.__override___(overriding_catalog) return overriding_catalog diff --git a/objects/injections.py b/objects/injections.py index 2c64940e..a039243e 100644 --- a/objects/injections.py +++ b/objects/injections.py @@ -1,43 +1,33 @@ -""" -Injections module. -""" +"""Injections module.""" class Injection(object): - """ - Base injection class. - """ + + """Base injection class.""" def __init__(self, name, injectable): - """ - Initializer. - """ + """Initializer.""" self.name = name self.injectable = injectable @property def value(self): - """ - Returns injectable value. - """ + """Return injectable value.""" if hasattr(self.injectable, '__is_objects_provider__'): return self.injectable() return self.injectable class InitArg(Injection): - """ - Init argument injection. - """ + + """Init argument injection.""" class Attribute(Injection): - """ - Attribute injection. - """ + + """Attribute injection.""" class Method(Injection): - """ - Method injection. - """ + + """Method injection.""" diff --git a/objects/providers.py b/objects/providers.py index 4e7b2a57..9753d737 100644 --- a/objects/providers.py +++ b/objects/providers.py @@ -1,6 +1,4 @@ -""" -Standard providers. -""" +"""Standard providers.""" from collections import Iterable from .injections import ( @@ -12,46 +10,35 @@ from .injections import ( class Provider(object): - """ - Base provider class. - """ + + """Base provider class.""" __is_objects_provider__ = True __overridden_by__ = list() def __init__(self): - """ - Initializer. - """ + """Initializer.""" self.__overridden_by__ = list() def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" raise NotImplementedError() def __override__(self, provider): - """ - Overrides provider with another provider. - """ + """Override provider with another provider.""" self.__overridden_by__.append(provider) def delegate(self): - """ - Returns provider delegate. - """ + """Return provider delegate.""" return ProviderDelegate(self) class ProviderDelegate(Provider): - """ - Provider's delegate. - """ + + """Provider's delegate.""" def __init__(self, delegated): - """ - Initializer. + """Initializer. :type delegated: Provider """ @@ -59,153 +46,116 @@ class ProviderDelegate(Provider): super(ProviderDelegate, self).__init__() def __call__(self): - """ - Returns provided instance. - """ + """Return provided instance.""" return self.delegated.__call__ -def prepare_injections(injections): - """ - Prepares injections list to injection. - """ - return [(injection.name, injection.value) for injection in injections] - - -def fetch_injections(injections, injection_type): - """ - Fetches injections of injection type from list. - """ - return tuple([injection - for injection in injections - if isinstance(injection, injection_type)]) - - class NewInstance(Provider): - """ + + """New instance provider. + New instance providers will create and return new instance on every call. """ def __init__(self, provides, *injections): - """ - Initializer. - """ + """Initializer.""" self.provides = provides - self.init_injections = fetch_injections(injections, InitArg) - self.attribute_injections = fetch_injections(injections, Attribute) - self.method_injections = fetch_injections(injections, Method) + self.init_injections = _fetch_injections(injections, InitArg) + self.attribute_injections = _fetch_injections(injections, Attribute) + self.method_injections = _fetch_injections(injections, Method) super(NewInstance, self).__init__() def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" if self.__overridden_by__: return self.__overridden_by__[-1].__call__(*args, **kwargs) - init_injections = prepare_injections(self.init_injections) - init_injections = dict(init_injections) + init_injections = dict(((injection.name, injection.value) + for injection in self.init_injections)) init_injections.update(kwargs) - provided = self.provides(*args, **init_injections) + instance = self.provides(*args, **init_injections) - attribute_injections = prepare_injections(self.attribute_injections) - for name, injectable in attribute_injections: - setattr(provided, name, injectable) + if not self.attribute_injections: + for injection in self.attribute_injections: + setattr(instance, injection.name, injection.value) - method_injections = prepare_injections(self.method_injections) - for name, injectable in method_injections: - getattr(provided, name)(injectable) + if not self.method_injections: + for injection in self.method_injections: + getattr(instance, injection.name)(injection.value) - return provided + return instance class Singleton(NewInstance): - """ + + """Singleton provider. + Singleton provider will create instance once and return it on every call. """ def __init__(self, *args, **kwargs): - """ - Initializer. - """ + """Initializer.""" self.instance = None super(Singleton, self).__init__(*args, **kwargs) def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" if not self.instance: self.instance = super(Singleton, self).__call__(*args, **kwargs) return self.instance def _reset_instance(self): - """ - Resets instance. - """ + """Reset instance.""" self.instance = None class Scoped(Singleton): - """ - Scoped provider will create instance once for every scope and return it on every call. + + """Scoped provider. + + Scoped provider will create instance once for every scope and return it + on every call. """ def __init__(self, *args, **kwargs): - """ - Initializer. - """ + """Initializer.""" self.is_in_scope = None super(Scoped, self).__init__(*args, **kwargs) def in_scope(self): - """ - Sets provider in "in scope" state. - """ + """Set provider in "in scope" state.""" self.is_in_scope = True self._reset_instance() def out_of_scope(self): - """ - Sets provider in "out of scope" state. - """ + """Set provider in "out of scope" state.""" self.is_in_scope = False self._reset_instance() def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" if not self.is_in_scope: - raise RuntimeError('Trying to provide {} while provider is not in scope'.format(self.provides)) + raise RuntimeError('Trying to provide {} '.format(self.provides) + + 'while provider is not in scope') return super(Scoped, self).__call__(*args, **kwargs) def __enter__(self): - """ - With __enter__() implementation. Makes provider to be in scope. - """ + """Make provider to be in scope.""" self.in_scope() return self def __exit__(self, *_): - """ - With __exit__() implementation. Makes provider to be out of scope. - """ + """Make provider to be out of scope.""" self.out_of_scope() class ExternalDependency(Provider): - """ - External dependency provider. - """ + + """External dependency provider.""" def __init__(self, instance_of): - """ - Initializer - - :param instance_of: type - """ + """Initializer.""" if not isinstance(instance_of, Iterable): instance_of = (instance_of,) self.instance_of = instance_of @@ -213,163 +163,150 @@ class ExternalDependency(Provider): super(ExternalDependency, self).__init__() def satisfy(self, provider): - """ - Satisfies an external dependency. - - :param provider: Provider - """ + """Satisfy an external dependency.""" self.dependency = provider def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" if not self.dependency: raise ValueError('Dependency is not satisfied') result = self.dependency.__call__(*args, **kwargs) - if not any((isinstance(result, possible_type) for possible_type in self.instance_of)): - raise TypeError('{} is not an instance of {}'.format(result, self.instance_of)) + is_instance = any((isinstance(result, possible_type) + for possible_type in self.instance_of)) + + if not is_instance: + raise TypeError('{} is not an '.format(result) + + 'instance of {}'.format(self.instance_of)) return result class _StaticProvider(Provider): - """ + + """Static provider. + Static provider is base implementation that provides exactly the same as it got on input. """ def __init__(self, provides): - """ - Initializer. - """ + """Initializer.""" self.provides = provides super(_StaticProvider, self).__init__() def __call__(self): - """ - Returns provided instance. - """ + """Return provided instance.""" if self.__overridden_by__: return self.__overridden_by__[-1].__call__() return self.provides class Class(_StaticProvider): - """ - Class provider provides class. - """ + + """Class provider provides class.""" class Object(_StaticProvider): - """ - Object provider provides object. - """ + + """Object provider provides object.""" class Function(_StaticProvider): - """ - Function provider provides function. - """ + + """Function provider provides function.""" class Value(_StaticProvider): - """ - Value provider provides value. - """ + + """Value provider provides value.""" class Callable(Provider): - """ + + """Callable provider. + Callable provider will provide callable calls with some predefined dependencies injections. """ def __init__(self, calls, *injections): - """ - Initializer. - """ + """Initializer.""" self.calls = calls - self.injections = fetch_injections(injections, Injection) + self.injections = _fetch_injections(injections, Injection) super(Callable, self).__init__() def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" if self.__overridden_by__: return self.__overridden_by__[-1].__call__(*args, **kwargs) - injections = prepare_injections(self.injections) - injections = dict(injections) + injections = dict(((injection.name, injection.value) + for injection in self.injections)) injections.update(kwargs) return self.calls(*args, **injections) class _DeferredConfig(Provider): - """ + + """Deferred config provider. + Deferred config providers provide an value from the root config object. """ def __init__(self, paths, root_config): - """ - Initializer. - """ + """Initializer.""" self.paths = paths self.root_config = root_config super(_DeferredConfig, self).__init__() def __getattr__(self, item): - """ - Returns instance of deferred config. - """ + """Return instance of deferred config.""" return _DeferredConfig(paths=self.paths + (item,), root_config=self.root_config) def __call__(self, *args, **kwargs): - """ - Returns provided instance. - """ + """Return provided instance.""" return self.root_config(self.paths) class Config(Provider): - """ + + """Config provider. + Config provider provides dict values. Also config provider creates deferred config objects for all undefined attribute calls. """ def __init__(self, value=None): - """ - Initializer. - """ + """Initializer.""" if not value: value = dict() self.value = value super(Config, self).__init__() def update_from(self, value): - """ - Updates current value from another one. - """ + """Update current value from another one.""" self.value.update(value) def __getattr__(self, item): - """ - Returns instance of deferred config. - """ + """Return instance of deferred config.""" return _DeferredConfig(paths=(item,), root_config=self) def __call__(self, paths=None): - """ - Returns provided instance. - """ + """Return provided instance.""" value = self.value if paths: for path in paths: value = value[path] return value + + +def _fetch_injections(injections, injection_type): + """Fetch injections of injection type from list.""" + return tuple([injection + for injection in injections + if isinstance(injection, injection_type)])