def test_call_overridden(selector, switch):
overriding_provider1 = providers.Selector(switch, one=providers.Object(2))
overriding_provider2 = providers.Selector(switch, one=providers.Object(3))
selector.override(overriding_provider1)
selector.override(overriding_provider2)
with switch.override("one"):
assert selector() == 3
def test_deepcopy_from_memo(self):
provider = providers.Selector(self.selector)
provider_copy_memo = providers.Selector(self.selector)
provider_copy = providers.deepcopy(
provider,
memo={id(provider): provider_copy_memo},
)
self.assertIs(provider_copy, provider_copy_memo)
def test_call_overridden(self):
provider = providers.Selector(self.selector,
sample=providers.Object(1))
overriding_provider1 = providers.Selector(self.selector,
sample=providers.Object(2))
overriding_provider2 = providers.Selector(self.selector,
sample=providers.Object(3))
provider.override(overriding_provider1)
provider.override(overriding_provider2)
with self.selector.override('sample'):
self.assertEqual(provider(), 3)
def selector(selector_type, switch, one, two):
if selector_type == "default":
return providers.Selector(switch, one=one, two=two)
elif selector_type == "empty":
return providers.Selector()
elif selector_type == "sys-streams":
return providers.Selector(
switch,
stdin=providers.Object(sys.stdin),
stdout=providers.Object(sys.stdout),
stderr=providers.Object(sys.stderr),
)
else:
raise ValueError("Unknown selector type \"{0}\"".format(selector_type))
def test_deepcopy(self):
provider = providers.Selector(self.selector)
provider_copy = providers.deepcopy(provider)
self.assertIsNot(provider, provider_copy)
self.assertIsInstance(provider, providers.Selector)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
movie: providers.Factory[entities.Movie] = providers.Factory(entities.Movie)
csv_finder = providers.Singleton(
finders.CsvMovieFinder,
movie_factory=movie.provider,
path=config.finder.csv.path,
delimiter=config.finder.csv.delimiter,
)
sqlite_finder = providers.Singleton(
finders.SqliteMovieFinder,
movie_factory=movie.provider,
path=config.finder.sqlite.path,
)
orm_sqlite_finder = providers.Singleton(
finders.ORMSqliteFinder,
movie_factory=movie.provider,
path=config.finder.sqlite.path,
)
finder = providers.Selector(
config.finder.type,
csv=csv_finder,
sqlite=sqlite_finder,
orm_sqlite=orm_sqlite_finder,
)
lister = providers.Factory(listers.MovieLister, movie_finder=finder)
class Container(containers.DeclarativeContainer):
app = flask.Application(Flask, __name__)
# Configuración
config = providers.Configuration('config')
# Dependencias
logger = providers.Singleton(logging.Logger, name='logger')
psycopg2_data_manager = providers.Singleton(Psycopg2DataManager,
user=config.username,
password=config.password,
host=config.host,
port=config.port,
db_name=config.db_name)
sqlalchemy_orm_data_manager = providers.Singleton(SqlAlchemyORMDataManager,
user=config.username,
password=config.password,
host=config.host,
port=config.port,
db_name=config.db_name)
# Servicios
gestor_pedidos = providers.Selector(
config.data_handler,
psycopg2=providers.Singleton(GestorPedidos, psycopg2_data_manager,
logger),
sqlalchemy=providers.Singleton(GestorPedidos,
sqlalchemy_orm_data_manager, logger),
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration(yaml_files=["config.yml"])
movie = providers.Factory(entities.Movie)
csv_finder = providers.Singleton(
finders.CsvMovieFinder,
movie_factory=movie.provider,
path=config.finder.csv.path,
delimiter=config.finder.csv.delimiter,
)
sqlite_finder = providers.Singleton(
finders.SqliteMovieFinder,
movie_factory=movie.provider,
path=config.finder.sqlite.path,
)
finder = providers.Selector(
config.finder.type,
csv=csv_finder,
sqlite=sqlite_finder,
)
lister = providers.Factory(
listers.MovieLister,
movie_finder=finder,
)
class ApplicationContainer(containers.DeclarativeContainer):
_config = providers.Configuration('app')
_configParser = providers.Callable(App.cliParser)
_config.from_dict(_configParser())
main = providers.Selector(_config.cmd,
info=providers.Callable(App.info),
distribute=providers.Callable(App.distribute),
cashimport=providers.Callable(App.cashimport))
def test_traverse_overridden():
provider1 = providers.Callable(list)
provider2 = providers.Callable(dict)
selector1 = providers.Selector(lambda: "provider1", provider1=provider1)
provider = providers.Selector(
lambda: "provider2",
provider2=provider2,
)
provider.override(selector1)
all_providers = list(provider.traverse())
assert len(all_providers) == 3
assert provider1 in all_providers
assert provider2 in all_providers
assert selector1 in all_providers
def test_traverse_overridden(self):
provider1 = providers.Callable(list)
provider2 = providers.Callable(dict)
selector1 = providers.Selector(lambda: 'provider1', provider1=provider1)
provider = providers.Selector(
lambda: 'provider2',
provider2=provider2,
)
provider.override(selector1)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 3)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
self.assertIn(selector1, all_providers)
class CloudContainer(containers.DeclarativeContainer):
config = providers.Configuration(strict=True)
filehost = providers.Selector(
config.cloud.filehost,
anonfiles=providers.Factory(AnonFilesHost),
gofiles=providers.Factory(GoFilesHost),
none=providers.Factory(NoneFilesHost),
)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
selector = providers.Selector(
config.one_or_another,
one=providers.Factory(SomeClass),
another=providers.Factory(SomeOtherClass),
)
def getMetadataObj(cls):
config = PipelineContainer.config
metadata_selector = providers.Selector(
config.METADATA_RULES.metadata_prepclass,
defaultmetadataprep=providers.Factory(DefaultMetadataPrep,
config=config.provider),
filemetadataprep=providers.Factory(FileMetadataPrep,
config=config.provider),
)
return metadata_selector()
def test_call_undefined_provider(self):
provider = providers.Selector(
self.selector,
one=providers.Object(1),
two=providers.Object(2),
)
with self.selector.override('three'):
with self.assertRaises(errors.Error):
provider()
def test_call_selector_is_none(self):
provider = providers.Selector(
self.selector,
one=providers.Object(1),
two=providers.Object(2),
)
with self.selector.override(None):
with self.assertRaises(errors.Error):
provider()
def test_call_with_context_args(self):
provider = providers.Selector(
self.selector,
one=providers.Callable(lambda *args, **kwargs: (args, kwargs)),
)
with self.selector.override('one'):
args, kwargs = provider(1, 2, three=3, four=4)
self.assertEqual(args, (1, 2))
self.assertEqual(kwargs, {'three': 3, 'four': 4})
def test_call_any_callable(self):
provider = providers.Selector(
functools.partial(next, itertools.cycle(['one', 'two'])),
one=providers.Object(1),
two=providers.Object(2),
)
self.assertEqual(provider(), 1)
self.assertEqual(provider(), 2)
self.assertEqual(provider(), 1)
self.assertEqual(provider(), 2)
def test_getattr_attribute_error(self):
provider_one = providers.Object(1)
provider_two = providers.Object(2)
provider = providers.Selector(
self.selector,
one=provider_one,
two=provider_two,
)
with self.assertRaises(AttributeError):
_ = provider.provider_three
def test_getattr(self):
provider_one = providers.Object(1)
provider_two = providers.Object(2)
provider = providers.Selector(
self.selector,
one=provider_one,
two=provider_two,
)
self.assertIs(provider.one, provider_one)
self.assertIs(provider.two, provider_two)
def test_call(self):
provider = providers.Selector(
self.selector,
one=providers.Object(1),
two=providers.Object(2),
)
with self.selector.override('one'):
self.assertEqual(provider(), 1)
with self.selector.override('two'):
self.assertEqual(provider(), 2)
def test_init_optional(self):
one = providers.Object(1)
two = providers.Object(2)
provider = providers.Selector()
provider.set_selector(self.selector)
provider.set_providers(one=one, two=two)
self.assertEqual(provider.providers, {'one': one, 'two': two})
with self.selector.override('one'):
self.assertEqual(provider(), one())
with self.selector.override('two'):
self.assertEqual(provider(), two())
def test_providers_attribute(self):
provider_one = providers.Object(1)
provider_two = providers.Object(2)
provider = providers.Selector(
self.selector,
one=provider_one,
two=provider_two,
)
self.assertEqual(provider.providers, {
'one': provider_one,
'two': provider_two
})
def test_deepcopy_overridden(self):
provider = providers.Selector(self.selector)
object_provider = providers.Object(object())
provider.override(object_provider)
provider_copy = providers.deepcopy(provider)
object_provider_copy = provider_copy.overridden[0]
self.assertIsNot(provider, provider_copy)
self.assertIsInstance(provider, providers.Selector)
self.assertIsNot(object_provider, object_provider_copy)
self.assertIsInstance(object_provider_copy, providers.Object)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
component = providers.Selector(
config.type,
standard=providers.Factory(
components.Component,
param=config.param,
),
all_caps=providers.Factory(
components.AllCaps,
param=config.param,
),
)
def test_repr(self):
provider = providers.Selector(
self.selector,
one=providers.Object(1),
two=providers.Object(2),
)
self.assertIn(
'<dependency_injector.providers.Selector({0}'.format(
repr(self.selector)),
repr(provider),
)
self.assertIn('one={0}'.format(repr(provider.one)), repr(provider))
self.assertIn('two={0}'.format(repr(provider.two)), repr(provider))
self.assertIn('at {0}'.format(hex(id(provider))), repr(provider))
def test_traverse():
switch = lambda: "provider1"
provider1 = providers.Callable(list)
provider2 = providers.Callable(dict)
provider = providers.Selector(
switch,
provider1=provider1,
provider2=provider2,
)
all_providers = list(provider.traverse())
assert len(all_providers) == 2
assert provider1 in all_providers
assert provider2 in all_providers
def test_traverse(self):
switch = lambda: 'provider1'
provider1 = providers.Callable(list)
provider2 = providers.Callable(dict)
provider = providers.Selector(
switch,
provider1=provider1,
provider2=provider2,
)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 2)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
def executeRulesDf(cls, df, ruleset):
config = PipelineContainer.config
metadata_selector = providers.Selector(
config.METADATA_RULES.rules_metadata_prepclass,
defaultmetadataprep=providers.Factory(DefaultMetadataPrep,
config=config.provider),
filemetadataprep=providers.Factory(FileMetadataPrep,
config=config.provider),
)
##PipelineContainer.metadata_factory.override(
## providers.Factory(DefaultMetadataPrep,
## config=config.provider
## ),
##)
##metadata_prep = PipelineContainer.metadata_factory()
metadata_prep = metadata_selector()
ruleset = metadata_prep.rulesprep(ruleset)
key_columns = ruleset.keycolumns
rule_columns = key_columns + [
expr(rl.getsqlexp()) for rl in ruleset.rulelist
]
rule_and = expr(' and '.join(
[rl.getcolname() for rl in ruleset.rulelist]))
rule_result_df = df.select(*rule_columns) \
.withColumn('result_and',rule_and)
rule_category = ruleset.category
if rule_category == 'filter':
filter_df = rule_result_df.filter(
rule_result_df.result_and == 'true')
result_df = df.join(filter_df, key_columns,
'inner').select(*df.columns)
else:
result_df = df
ruledict = dict([('validdf', result_df), ('originaldf', df),
('keycolumnslist', key_columns),
('rulecategory', rule_category),
('rulesetname', ruleset.rulesetname)])
def wrapper(ruledict):
def get(dfname):
return ruledict[dfname]
return get
return wrapper(ruledict)
class TestContainer(containers.DeclarativeContainer):
settings = providers.Configuration()
root_container = providers.Container(
NestedContainer,
settings=settings,
)
not_root_container = providers.Selector(
settings.container,
using_factory=providers.Factory(
NestedContainer,
settings=settings,
),
using_container=providers.Container(
NestedContainer,
settings=settings,
))
