def test_assisted_building_is_supported():
class Fetcher:
def fetch(self, user_id):
assert user_id == 333
return {'name': 'John'}
class Processor:
@noninjectable('provider_id')
@inject
@noninjectable('user_id')
def __init__(self, fetcher: Fetcher, user_id: int, provider_id: str):
assert provider_id == 'not injected'
data = fetcher.fetch(user_id)
self.name = data['name']
def configure(binder):
binder.bind(int, to=897)
binder.bind(str, to='injected')
injector = Injector(configure)
processor_builder = injector.get(AssistedBuilder[Processor])
with pytest.raises(CallError):
processor_builder.build()
processor = processor_builder.build(user_id=333, provider_id='not injected')
assert processor.name == 'John'
def test_avoid_circular_dependency_with_method_injection():
class Interface(object):
pass
class A(object):
@inject(i=Interface)
def __init__(self, i):
self.i = i
# Even though A needs B (via Interface) and B.method() needs A, they are
# resolved at different times, avoiding circular dependencies.
class B(object):
@inject(a=A)
def method(self, a):
self.a = a
def configure(binder):
binder.bind(Interface, to=B)
binder.bind(A)
binder.bind(B)
injector = Injector(configure)
a = injector.get(A)
assert (isinstance(a.i, B))
b = injector.get(B)
b.method()
assert (isinstance(b.a, A))
def test_things_dont_break_in_presence_of_args_or_kwargs():
class A:
@inject
def __init__(self, s: str, *args: int, **kwargs: str):
assert not args
assert not kwargs
injector = Injector()
# The following line used to fail with something like this:
# Traceback (most recent call last):
# File "/ve/injector/injector_test_py3.py", line 192,
# in test_things_dont_break_in_presence_of_args_or_kwargs
# injector.get(A)
# File "/ve/injector/injector.py", line 707, in get
# result = scope_instance.get(key, binding.provider).get(self)
# File "/ve/injector/injector.py", line 142, in get
# return injector.create_object(self._cls)
# File "/ve/injector/injector.py", line 744, in create_object
# init(instance, **additional_kwargs)
# File "/ve/injector/injector.py", line 1082, in inject
# kwargs=kwargs
# File "/ve/injector/injector.py", line 851, in call_with_injection
# **dependencies)
# File "/ve/injector/injector_test_py3.py", line 189, in __init__
# assert not kwargs
# AssertionError: assert not {'args': 0, 'kwargs': ''}
injector.get(A)
def __init__(self, options): packageName=options.package assert packageName, "需要使用 -p 來指定要載入的編碼法（輸入法或描繪法）模組名稱" package = __import__(packageName, fromlist=["coding"]) output_format=options.output_format quiet=options.quiet writer = self.computeWriter(package.codingType, quiet, output_format) def configure(binder): binder.bind(CodingConfig, to=CodingConfig(package)) binder.bind(Package, to=package) binder.bind(Writer, to=writer) injector = Injector([configure, PackageModule()]) structureManager = injector.get(StructureManager) injector = Injector([configure, PackageModule(), ManagerModule(structureManager)]) mainManager=injector.get(MainManager) mainManager.compute() mainManager.write()
class TestBuilder(object):
"""
"""
def setup_method(self, method):
self.injector = Injector([SandboxModuleTest()])
self.dispatcher = self.injector.get(Dispatcher)
self.builder = self.injector.get(Builder)
self._composer = self.injector.get(Composer)
self._build = Mock()
self.builder.build = self._build
self.builder._composer = self._composer
def test_build_not_sandbox_image(self):
images = ['external1', 'sandbox/internal1']
calls = ['internal1:master']
options = {
'<flavour>': 'with_external_component',
'--force': True
}
self.dispatcher.build_all(options)
for call in calls:
self._build.assert_any_call(call)
assert mock.call('external1') not in self._build.mock_calls
def test_implicit_injection_fails_when_annotations_are_missing():
class A(object):
def __init__(self, n):
self.n = n
injector = Injector()
with pytest.raises(CallError):
injector.get(A)
def test_call_to_method_with_legitimate_call_error_raises_type_error():
class A(object):
def __init__(self):
max()
injector = Injector()
with pytest.raises(TypeError):
injector.get(A)
def test_mutating_dict_while_iterating_it_bug(self):
bindings = dict(('_' + str(i), str) for i in range(1000))
@inject(**bindings)
class X(object):
pass
injector = Injector()
injector.get(X)
def test_inject_with_missing_dependency():
A, _ = prepare_basic_injection()
def configure(binder):
binder.bind(A)
injector = Injector(configure, auto_bind=False)
with pytest.raises(UnsatisfiedRequirement):
injector.get(A)
def test_get_default_injected_instances(self):
A, B = self.prepare()
def configure(binder):
binder.bind(A)
binder.bind(B)
injector = Injector(configure)
assert injector.get(Injector) is injector
assert injector.get(Binder) is injector.binder
def test_injecting_into_method_of_object_that_is_falseish_works():
# regression test
class X(dict):
@inject(s=str)
def __init__(self, s):
pass
injector = Injector()
injector.get(X)
def test_get_default_injected_instances():
A, B = prepare_basic_injection()
def configure(binder):
binder.bind(A)
binder.bind(B)
injector = Injector(configure)
assert (injector.get(Injector) is injector)
assert (injector.get(Binder) is injector.binder)
def test_injection_fails_when_injector_cant_install_itself_into_an_object_with_slots():
try:
class ClassName(object):
__slots__ = ()
injector = Injector()
injector.get(ClassName)
except Exception as e:
check_exception_contains_stuff(e, ('ClassName', '__slots__'))
else:
assert False, 'Should have raised an exception and it didn\'t'
def test_transitive_injection_with_missing_dependency(self):
A, B, _ = self.prepare()
def configure(binder):
binder.bind(A)
binder.bind(B)
injector = Injector(configure, auto_bind=False)
with pytest.raises(UnsatisfiedRequirement):
injector.get(A)
with pytest.raises(UnsatisfiedRequirement):
injector.get(B)
def test_using_an_assisted_builder_with_a_provider_raises_an_injector_error():
class A:
pass
class MyModule(Module):
@provider
def provide_a(self, builder: AssistedBuilder[A]) -> A:
return builder.build()
injector = Injector(MyModule)
with pytest.raises(Error):
injector.get(A)
def test_bind_using_key():
Name = Key('name')
Age = Key('age')
class MyModule(Module):
@provides(Name)
def provides_name(self):
return 'Bob'
def configure(self, binder):
binder.bind(Age, to=25)
injector = Injector(MyModule())
assert (injector.get(Age) == 25)
assert (injector.get(Name) == 'Bob')
def test_bind_using_key():
Name = Key("name")
Age = Key("age")
class MyModule(Module):
@provides(Name)
def provides_name(self):
return "Bob"
def configure(self, binder):
binder.bind(Age, to=25)
injector = Injector(MyModule())
assert injector.get(Age) == 25
assert injector.get(Name) == "Bob"
def test_injecting_undecorated_class_with_missing_dependencies_raises_the_right_error():
class ClassA(object):
def __init__(self, parameter):
pass
class ClassB(object):
@inject(a=ClassA)
def __init__(self, a):
pass
injector = Injector()
try:
injector.get(ClassB)
except CallError as ce:
check_exception_contains_stuff(ce, ('ClassA.__init__', 'ClassB'))
def test_call_to_method_containing_noninjectable_and_unsatisfied_dependencies_raises_the_right_error():
class A(object):
@inject(something=str)
def fun(self, something, something_different):
pass
injector = Injector()
a = injector.get(A)
try:
a.fun()
except CallError as ce:
assert (ce.args[0] == a)
# We cannot really check for function identity here... Error is raised after calling
# original function but from outside we have access to function already decorated
function = A.fun
# Python 3 compatibility
try:
function = function.__func__
except AttributeError:
pass
assert (ce.args[1].__name__ == function.__name__)
assert (ce.args[2] == ())
assert (ce.args[3] == {'something': str()})
def test_auto_bind():
class A(object):
pass
injector = Injector()
assert (isinstance(injector.get(A), A))
def test_threadlocal():
@threadlocal
class A(object):
def __init__(self):
pass
def configure(binder):
binder.bind(A)
injector = Injector(configure)
a1 = injector.get(A)
a2 = injector.get(A)
assert (a1 is a2)
a3 = [None]
ready = threading.Event()
def inject_a3():
a3[0] = injector.get(A)
ready.set()
threading.Thread(target=inject_a3).start()
ready.wait(1.0)
assert (a2 is not a3[0] and a3[0] is not None)
def test_dependency_cycle_can_be_worked_broken_by_assisted_building():
class Interface:
pass
class A:
@inject
def __init__(self, i: Interface):
self.i = i
class B:
@inject
def __init__(self, a_builder: AssistedBuilder[A]):
self.a = a_builder.build(i=self)
def configure(binder):
binder.bind(Interface, to=B)
binder.bind(A)
injector = Injector(configure)
# Previously it'd detect a circular dependency here:
# 1. Constructing A requires Interface (bound to B)
# 2. Constructing B requires assisted build of A
# 3. Constructing A triggers circular dependency check
assert isinstance(injector.get(A), A)
def test_bind_interface_of_list_of_types():
def configure(binder):
binder.multibind([int], to=[1, 2, 3])
binder.multibind([int], to=[4, 5, 6])
injector = Injector(configure)
assert injector.get([int]) == [1, 2, 3, 4, 5, 6]
def parse(self,response):
if self.crawling=="Streaming":
sys.path.insert(0,"/media/shrinivaasanka/0fc4d8a2-1c74-42b8-8099-9ef78d8c8ea2/home/kashrinivaasan/KrishnaiResearch_OpenSource/GitHub/asfer-github-code/python-src/backend")
import Abstract_DBBackend
import MySQL_DBBackend
import MySQL_Configuration
import MongoDB_DBBackend
import MongoDB_Configuration
from pymongo.collection import Collection
mysqldbobj=MySQL_DBBackend.MySQL_DBBackend()
mysqlconfigobj=MySQL_Configuration.MySQL_Configuration()
injector=Injector([mysqldbobj,mysqlconfigobj])
handler=injector.get(Abstract_DBBackend.Abstract_DBBackend)
#handler.execute_query("CREATE TABLE asfer_webspider(Description varchar(100))")
select = Selector(response)
links_list = select.xpath('//h3/a/@href').extract()
links_list2 = [re.search('q=(.*)&sa',n).group(1) for n in links_list]
desc_list=select.xpath('//h3/a/text()').extract()
items=[]
for desc in desc_list:
item=WebSpiderItem()
item['desc'] = desc
items.append(item)
self.output.write(desc)
self.output.write("\n")
handler.execute_query("INSERT INTO asfer_webspider(Description) VALUES(\""+desc+"\")","MySQL")
handler.execute_query("SELECT * FROM asfer_webspider","MySQL")
return items
if self.crawling=="HTML":
bsoup=BeautifulSoup(response.body)
for script in bsoup(["script","style"]):
script.extract()
self.output.write(bsoup.get_text().encode("utf-8"))
def db(request):
self = request.instance
injector = Injector([DatabaseModule, TestingModule()])
engine = injector.get(DatabaseEngine)
session = injector.get(DatabaseSession)
self.session = session
@request.addfinalizer
def finalize_session():
session.remove()
Model.metadata.drop_all(bind=engine)
engine.dispose()
return session
def main():
app = Flask(__name__)
app.config.update(
DB_CONNECTION_STRING=':memory:',
CACHE_TYPE='simple',
SQLALCHEMY_DATABASE_URI='sqlite://',
)
app.debug = True
injector = Injector([AppModule(app)])
configure_views(app=app, cached=injector.get(Cache).cached)
FlaskInjector(app=app, injector=injector)
client = app.test_client()
response = client.get('/')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.post('/', data={'key': 'foo', 'value': 'bar'})
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.delete('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.delete('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
def test_annotation_based_injection_works_in_provider_methods():
class MyModule(Module):
def configure(self, binder):
binder.bind(int, to=42)
@provider
def provide_str(self, i: int) -> str:
return str(i)
@singleton
@provider
def provide_object(self) -> object:
return object()
injector = Injector(MyModule)
assert injector.get(str) == '42'
assert injector.get(object) is injector.get(object)
def test_providerof_is_safe_to_use_with_multiple_injectors():
def configure1(binder):
binder.bind(int, to=1)
def configure2(binder):
binder.bind(int, to=2)
injector1 = Injector(configure1)
injector2 = Injector(configure2)
provider_of = ProviderOf[int]
provider1 = injector1.get(provider_of)
provider2 = injector2.get(provider_of)
assert provider1.get() == 1
assert provider2.get() == 2
def test_newtype_integration_works():
UserID = NewType('UserID', int)
def configure(binder):
binder.bind(UserID, to=123)
injector = Injector([configure])
assert injector.get(UserID) == 123
def test_assisted_builder_works_when_injected():
class X(object):
@inject(builder=AssistedBuilder(NeedsAssistance))
def __init__(self, builder):
self.obj = builder.build(b=234)
injector = Injector()
x = injector.get(X)
assert ((x.obj.a, x.obj.b) == (str(), 234))
return BussinessLogic(api=api)
@singleton
@provider
def provide_api(self) -> Api:
return Api()
class TestApi(Api):
def fetch_remote_data(self):
print('demo api called')
return 24
class TestAppModule(Module):
@singleton
@provider
def provide_app(self) -> Api:
return TestApi()
if __name__ == '__main__':
real_injector = Injector(AppModule())
test_injector = Injector([AppModule(), TestAppModule()])
real_logic = real_injector.get(BussinessLogic)
real_logic.do_stuff()
test_logic = test_injector.get(BussinessLogic)
test_logic.do_stuff()
def setUp(self):
injector = Injector([DefaultModule])
self.asset_service = injector.get(AssetService)
self.service = injector.get(EstimatesService)
def test_assisted_builder_works_when_got_directly_from_injector():
injector = Injector()
builder = injector.get(AssistedBuilder[NeedsAssistance])
obj = builder.build(b=123)
assert (obj.a, obj.b) == (str(), 123)
def setUpClass(cls):
inj = Injector([
DefaultCollaborativeTrainerModule,
LoggingModule,
PerceptronModule,
StakeableImModule,
])
cls.balances = inj.get(Balances)
cls.decai = inj.get(CollaborativeTrainer)
cls.time_method = inj.get(TimeMock)
cls.good_address = 'sender'
initial_balance = 1E6
cls.balances.initialize(cls.good_address, initial_balance)
msg = Msg(cls.good_address, cls.balances[cls.good_address])
X = np.array([
# Initialization Data
[0, 0, 0],
[1, 1, 1],
# Data to Add
[0, 0, 1],
[0, 1, 0],
[0, 1, 1],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0],
])
y = np.array([_ground_truth(x) for x in X])
cls.decai.model.init_model(np.array([X[0, :], X[1, :]]),
np.array([y[0], y[1]]))
score = cls.decai.model.evaluate(X, y)
assert score != 1, "Model shouldn't fit the data yet."
# Add all data.
first_added_time = None
for i in range(X.shape[0]):
x = X[i]
cls.time_method.set_time(cls.time_method() + 1)
if first_added_time is None:
first_added_time = cls.time_method()
cls.decai.add_data(msg, x, y[i])
for _ in range(1000):
score = cls.decai.model.evaluate(X, y)
if score >= 1:
break
i = random.randint(0, X.shape[0] - 1)
x = X[i]
cls.time_method.set_time(cls.time_method() + 1)
cls.decai.add_data(msg, x, y[i])
assert score == 1, "Model didn't fit the data."
bal = cls.balances[msg.sender]
assert bal < initial_balance, "Adding data should have a cost."
# Make sure sender has some good data refunded so that they can report data later.
cls.time_method.set_time(cls.time_method() +
cls.decai.im.refund_time_s + 1)
cls.decai.refund(msg, X[0], y[0], first_added_time)
assert cls.balances[msg.sender] > bal, "Refunding should return value."
async def test_version_upgrades(time: Time, injector: Injector,
config: Config) -> None:
# Simluate upgrading from an un-tracked version
assert not os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
cache = injector.get(DataCache)
upgrade_time = time.now()
assert cache.previousVersion == Version.default()
assert cache.currentVersion == Version.parse(VERSION)
assert cache.checkFlag(UpgradeFlags.DONT_IGNORE_LEGACY_SNAPSHOTS)
assert os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
with open(config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
data = json.load(f)
assert data["upgrades"] == [{
"prev_version": str(Version.default()),
"new_version": VERSION,
"date": upgrade_time.isoformat()
}]
# Reload the data cache, verify there is no upgrade.
time.advance(days=1)
cache = DataCache(config, time)
assert cache.previousVersion == Version.parse(VERSION)
assert cache.currentVersion == Version.parse(VERSION)
assert not cache.checkFlag(UpgradeFlags.DONT_IGNORE_LEGACY_SNAPSHOTS)
assert os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
with open(config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
data = json.load(f)
assert data["upgrades"] == [{
"prev_version": str(Version.default()),
"new_version": VERSION,
"date": upgrade_time.isoformat()
}]
# simulate upgrading to a new version, verify an upgrade gets identified.
upgrade_version = Version.parse("200")
class UpgradeCache(DataCache):
def __init__(self):
super().__init__(config, time)
@property
def currentVersion(self):
return upgrade_version
cache = UpgradeCache()
assert cache.previousVersion == Version.parse(VERSION)
assert cache.currentVersion == upgrade_version
assert os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
with open(config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
data = json.load(f)
assert data["upgrades"] == [{
"prev_version": str(Version.default()),
"new_version": VERSION,
"date": upgrade_time.isoformat()
}, {
"prev_version": VERSION,
"new_version": str(upgrade_version),
"date": time.now().isoformat()
}]
next_upgrade_time = time.now()
time.advance(days=1)
# Verify version upgrade time queries work as expected
assert cache.getUpgradeTime(Version.parse(VERSION)) == upgrade_time
assert cache.getUpgradeTime(Version.default()) == upgrade_time
assert cache.getUpgradeTime(upgrade_version) == next_upgrade_time
# degenerate case, should never happen but a sensible value needs to be returned
assert cache.getUpgradeTime(Version.parse("201")) == time.now()
def test_custom_scope() -> None:
@dataclass
class Project:
name: str
special: bool
class ProjectScope(Scope):
def __init__(self, *args, **kwargs):
super(ProjectScope, self).__init__(*args, **kwargs)
self.context = None
@contextmanager
def __call__(self, project: Project):
if self.context is not None:
raise Exception('context is not None')
self.context = {}
binder = self.injector.get(Binder)
binder.bind(Project, to=project, scope=ProjectScope)
yield
self.context = None
def get(self, key, provider):
if self.context is None:
raise UnsatisfiedRequirement(None, key)
try:
return self.context[key]
except KeyError:
provider = InstanceProvider(provider.get(self.injector))
self.context[key] = provider
return provider
class Handler(ABC):
pass
class OrdinaryHandler(Handler):
def __init__(self, project: Project):
self.project = project
class SpecialHandler(Handler):
def __init__(self, project: Project):
self.project = project
class SomeSingletonService:
pass
project_scope = ScopeDecorator(ProjectScope)
class ProjectScopedHandlerModule(Module):
@project_scope
@provider
def handler(self, project: Project) -> Handler:
if project.special:
return SpecialHandler(project)
else:
return OrdinaryHandler(project)
@singleton
@provider
def some_singleton_service(self,
handler: Handler) -> SomeSingletonService:
return SomeSingletonService()
injector = Injector([ProjectScopedHandlerModule()], auto_bind=False)
scope = injector.get(ProjectScope)
with scope(Project(name='proj1', special=False)):
handler = injector.get(Handler)
assert isinstance(handler, OrdinaryHandler)
assert handler.project.name == 'proj1'
with scope(Project(name='proj2', special=True)):
handler = injector.get(Handler)
assert isinstance(handler, SpecialHandler)
assert handler.project.name == 'proj2'
with scope(Project(name='proj3', special=True)):
@inject
def f(handler: Handler) -> str:
return handler.project.name
assert injector.call_with_injection(f) == 'proj3'
with pytest.raises(UnsatisfiedRequirement):
injector.get(SomeSingletonService)
with scope(Project(name='proj4', special=True)):
some_singleton_service = injector.get(SomeSingletonService)
assert injector.get(SomeSingletonService) == some_singleton_service # !!!
def test_dummy() -> None:
injector = Injector(
[AppModule(greeting_prefix='Hi, ', greeting_suffix='!!!')])
message_generator: MessageGenerator = injector.get(MessageGenerator)
assert message_generator.make_message(
'Andrey') == 'Hi, Andrey!!! How are you?'
def provide_valid_tasks(self, injector: Injector) -> TasksValid:
return [ # type: ignore
injector.get(self._get_valid_class(t)) for t in self.config.task.valid # type: ignore
]
def provide_train_tasks(self, injector: Injector) -> TasksTrain:
return [
WeightedTask(injector.get(self._get_train_class(t)), w) # type: ignore
for t, w in zip(self.config.task.train, self.config.task.weights)
]
async def test_bootstarp_requirements():
# This just verifies we're able to satisfy starter's injector requirements.
injector = Injector([BaseModule(Config()), MainModule()])
injector.get(Starter)
def test_auto_bind():
class A:
pass
injector = Injector()
assert isinstance(injector.get(A), A)
def __init__(self, ctx: Injector):
self.store = ctx.get(ContactStore)
