def test_child_scope():
TestKey = Key('TestKey')
TestKey2 = Key('TestKey2')
def parent_module(binder):
binder.bind(TestKey, to=object, scope=singleton)
def first_child_module(binder):
binder.bind(TestKey2, to=object, scope=singleton)
def second_child_module(binder):
binder.bind(TestKey2, to='marker', scope=singleton)
injector = Injector(modules=[parent_module])
first_child_injector = injector.create_child_injector(
modules=[first_child_module])
second_child_injector = injector.create_child_injector(
modules=[second_child_module])
assert first_child_injector.get(TestKey) is first_child_injector.get(
TestKey)
assert first_child_injector.get(TestKey) is second_child_injector.get(
TestKey)
assert first_child_injector.get(TestKey2) is not second_child_injector.get(
TestKey2)
def test_inject_using_key():
Name = Key('name')
Description = Key('description')
class MyModule(Module):
@provides(Name)
def provide_name(self):
return 'Bob'
@provides(Description)
@inject(name=Name)
def provide_description(self, name):
return '%s is cool!' % name
assert (Injector(MyModule()).get(Description) == 'Bob is cool!')
def test_bind_using_key():
Name = Key('name')
Age = Key('age')
class MyModule(Module):
@provider
def provider_name(self) -> Name:
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_inject_using_key():
Name = Key('name')
Description = Key('description')
class MyModule(Module):
@provider
def provide_name(self) -> Name:
return 'Bob'
@provider
@inject
def provide_description(self, name: Name) -> Description:
return '%s is cool!' % name
assert Injector(MyModule()).get(Description) == 'Bob is cool!'
def test_callable_provider_injection():
Name = Key("Name")
Message = Key("Message")
@inject
def create_message(name: Name):
return "Hello, " + name
def configure(binder):
binder.bind(Name, to="John")
binder.bind(Message, to=create_message)
injector = Injector([configure])
msg = injector.get(Message)
assert msg == "Hello, John"
def test_multibind() -> None:
class Handler(ABC):
pass
class Handler1(Handler):
pass
class Handler2(Handler):
pass
class Handler3(Handler):
def __init__(self, something: str):
self.something = something
Handlers = SequenceKey('handlers')
Something = Key('something')
def configure(binder: Binder) -> None:
binder.multibind(Handlers, [Handler1()], scope=singleton)
binder.multibind(Handlers, [Handler2()], scope=singleton)
binder.bind(Something, 'hello', scope=singleton)
class OmgModule(Module):
@singleton
@provider
def handler3(self, something: Something) -> Handlers:
return [Handler3(cast(str, something))]
injector = Injector([configure, OmgModule])
handlers = injector.get(Handlers)
assert isinstance(handlers[0], Handler1)
assert isinstance(handlers[1], Handler2)
assert isinstance(handlers[2], Handler3)
assert handlers[2].something == 'hello'
def test_key_cannot_be_instantiated():
Interface = Key('Interface')
with pytest.raises(Exception):
Interface()
with pytest.raises(Exception):
Injector().get(Interface)
def FlagKey(name):
"""An injector binding key for an individual flag.
Use this to inject individual flag values.
"""
try:
return _flag_key_cache[name]
except KeyError:
key = _flag_key_cache[name] = Key(_flag_key_name(name))
return key
def test_multibind():
Names = Key('names')
def configure_one(binder):
binder.multibind(Names, to=['Bob'])
def configure_two(binder):
binder.multibind(Names, to=['Tom'])
assert Injector([configure_one, configure_two]).get(Names) == ['Bob', 'Tom']
def test_assisted_builder_uses_bindings():
Interface = Key('Interface')
def configure(binder):
binder.bind(Interface, to=NeedsAssistance)
injector = Injector(configure)
builder = injector.get(AssistedBuilder[Interface])
x = builder.build(b=333)
assert (type(x), x.b) == (NeedsAssistance, 333)
def test_child_injector_rebinds_arguments_for_parent_scope():
I = Key("interface")
Cls = Key("test_class")
class A:
@inject
def __init__(self, val: I):
self.val = val
def configure_parent(binder):
binder.bind(Cls, to=A)
binder.bind(I, to="Parent")
def configure_child(binder):
binder.bind(I, to="Child")
parent = Injector(configure_parent)
assert parent.get(Cls).val == "Parent"
child = parent.create_child_injector(configure_child)
assert child.get(Cls).val == "Child"
def test_extends_decorator():
Names = Key('names')
class MyModule(Module):
@extends(Names)
def bob(self):
return ['Bob']
@extends(Names)
def tom(self):
return ['Tom']
assert (Injector(MyModule()).get(Names) == ['Bob', 'Tom'])
# -*- coding: utf-8 -*-
__author__ = 'Vincent Tertre'
import logging
from injector import inject, Key
logger = logging.getLogger(__name__)
QueryHandlers = Key('query_handlers')
CommandHandlers = Key('command_handlers')
class ExecutionResult(object):
def __init__(self, response=None, error=None, success=False):
self.response = response
self.error = error
self.success = success
@staticmethod
def success(response):
return ExecutionResult(response=response, success=True)
@staticmethod
def error(error):
return ExecutionResult(error=error)
def is_success(self):
return self.success
def is_error(self):
return not self.success
UUID = NewType("UUID", str)
HTML = NewType("HTML", str)
ContentType = NewType("ContentType", str)
Timestamp = NewType("Timestamp", str)
# HTTPResponse = NewType("HTTPResponse", str)
T = TypeVar('T')
class HTTPResponse(Generic[T]):
pass
Interface = NewType("Interface", object)
Implementation = NewType("Implementation", object)
Model = NewType("Model", object)
from injector import Key, MappingKey, SequenceKey
API = Key("API")
APISpec = Key("APISpec")
App = Key("App")
Apps = MappingKey("Apps")
CommandLine = Key("CommandLine")
Config = Key("Config")
Defaults = Key("Defaults")
Environment = Key("Environment")
FlaskApp = Key("FlaskApp")
OIDC = Key("OIDC")
SQLAlchemy = Key("SQLAlchemy")
SQLAlchemyBase = SequenceKey("SQLAlchemyBase")
# -*- coding: utf-8 -*-
from injector import inject, Key
from api.http_utils import WithExponentialBackoff
GoogleDirectoryApiResource = Key(u'google_directory_api_resource')
class DirectoryApiResource(object):
@inject(api_resource=GoogleDirectoryApiResource)
def __init__(self, api_resource):
self.__api_resource = api_resource
@WithExponentialBackoff
def list_users(self, **kwargs):
return self.__api_resource.users().list(**kwargs).execute()
from injector import Key
Count = Key('Count')
class MessageGenerator:
def __init__(self, message: str) -> None:
self._message = message
def make_message(self) -> str:
return self._message
def get_message(message_generator: MessageGenerator, count: Count):
return {'message': message_generator.make_message(), 'count': count}
# -*- coding: utf-8 -*-
from injector import inject, Key
from api.http_utils import WithExponentialBackoff
GoogleIAMApiResource = Key(u'google_iam_api_resource')
class IAMApiResource(object):
@inject(api_resource=GoogleIAMApiResource)
def __init__(self, api_resource):
self.__api_resource = api_resource
self.__keys_resource = api_resource.projects().serviceAccounts().keys()
@WithExponentialBackoff
def create_key(self, service_account_resource_id, key_data):
return self.__keys_resource.create(name=service_account_resource_id,
body=key_data).execute()
@WithExponentialBackoff
def delete_key(self, key_resource_id, execute=True):
request = self.__keys_resource.delete(name=key_resource_id)
return request.execute() if execute else request
@WithExponentialBackoff
def get_key(self, key_resource_id, public_key_type=None):
return self.__keys_resource.get(
name=key_resource_id, publicKeyType=public_key_type).execute()
@WithExponentialBackoff
def list_keys_of(self, service_account_resource_id, key_types=None):
import logging
from injector import Module, Key, Binder, provides, inject
from logging import Formatter
try:
from colorlog import ColoredFormatter
except ImportError:
ColoredFormatter = None
from waffle.flags import Flag, FlagKey, AppStartup
LogLevel = Key('LogLevel')
LOG_LEVELS = [
'finest', 'finer', 'fine', 'debug', 'info', 'warning', 'error', 'critical'
]
def _configure_logging():
"""Add fine/finer/finest logging."""
logging.FINE = 7
logging.FINER = 5
logging.FINEST = 1
logging.addLevelName(logging.FINE, 'FINE')
logging.addLevelName(logging.FINER, 'FINER')
logging.addLevelName(logging.FINEST, 'FINEST')
logging.Logger.fine = lambda self, *args, **kwargs: self.log(
logging.FINE, *args, **kwargs)
logging.Logger.finer = lambda self, *args, **kwargs: self.log(
#ASFER - Software for Mining Large Datasets #This program is free software: you can redistribute it and/or modify #it under the terms of the GNU General Public License as published by #the Free Software Foundation, either version 3 of the License, or #(at your option) any later version. #This program is distributed in the hope that it will be useful, #but WITHOUT ANY WARRANTY; without even the implied warranty of #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #GNU General Public License for more details. #You should have received a copy of the GNU General Public License #along with this program. If not, see <http://www.gnu.org/licenses/>. #-------------------------------------------------------------------------------------------------------- #Copyright (C): #Srinivasan Kannan (alias) Ka.Shrinivaasan (alias) Shrinivas Kannan #Ph: 9791499106, 9003082186 #Krishna iResearch Open Source Products Profiles: #http://sourceforge.net/users/ka_shrinivaasan, #https://github.com/shrinivaasanka, #https://www.openhub.net/accounts/ka_shrinivaasan #Personal website(research): https://sites.google.com/site/kuja27/ #emails: [email protected], [email protected], #[email protected] #----------------------------------------------------------------------------------------------------------------------------------- from injector import Module, Key, provides, Injector, inject, singleton Configuration=Key('configuration') class MongoDB_Configuration(Module): def configure(self, binder): binder.bind(Configuration, to={'database':'asfer_database','collection':'asfer_collection'}, scope=singleton)
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from injector import Key
Configuration = Key('Configuration')
from injector import Key
App = Key('application')
Configuration = Key('configuration')
import pymysql
import os
from injector import Key, Module, provider, singleton
from collections import namedtuple
database_configurations = Key('db_config')
def get_configurations(binder):
""" Add connection attributes """
Configuration = namedtuple('Configuration', 'host user password database')
configt = Configuration(host = os.getenv('host'), user = os.getenv('user'), password = os.getenv('password'), database=os.getenv('database'))
binder.bind(database_configurations, to=configt, scope=singleton)
class MysqlConnection(Module):
""" connection class """
@provider
@singleton
def connect(self, configuration: database_configurations) -> pymysql.connect:
""" Connect to the db """
connection = pymysql.connect(host=configuration.host,
password = configuration.password,
user = configuration.user,
database = configuration.database,
cursorclass = pymysql.cursors.DictCursor,
charset = 'utf8mb4'
)
return connection
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from imp import load_source
from os import environ, listdir
from os.path import isfile, join
from injector import inject, Key, Module, provides, singleton
from hal import PROJECT_ROOT
PluginDirectories = Key('PluginDirectories')
class PluginModuleCollector(object):
@inject(directories=PluginDirectories)
def collect(self, directories):
modules = []
for directory in directories:
for name in listdir(directory):
full_name = join(directory, name)
if full_name.endswith('.py') and isfile(full_name):
module = load_source(full_name.replace('/', ''), full_name)
if hasattr(module, 'plugin'):
modules.append(module)
return modules
class PluginModule(Module):
from injector import inject, Injector, provider, Module, Key, singleton
import sqlite3
class RequestHandler:
@inject
def __init__(self, db: sqlite3.Connection):
self._db = db
def get(self):
cursor = self._db.cursor()
cursor.execute('SELECT key, value FROM data ORDER by key')
return cursor.fetchall()
Configuration = Key("configuration")
def configuration_for_testing(binder):
configuration = {"db_connection_string": ":memory:"}
binder.bind(Configuration, to=configuration, scope=singleton)
class DatabaseModule(Module):
@singleton
@provider
def provide_sqlite_connection(
self, configuration: Configuration) -> sqlite3.Connection:
conn = sqlite3.connect(configuration["db_connection_string"])
cursor = conn.cursor()
cursor.execute(
from injector import Injector, Module, Scope, ScopeDecorator, InstanceProvider, \
Key, Binder, SequenceKey, MappingKey, provides, inject, singleton
from clastic import Application, Middleware as WebMiddleware, Request, render_basic
from clastic.middleware.session import CookieSessionMiddleware, JSONCookie
from werkzeug.local import Local, LocalManager
from waffle.flags import Flag, Flags
from waffle.util import parse_reltime
Routes = SequenceKey('Routes')
Middlewares = SequenceKey('Middlewares')
Resources = MappingKey('Resources')
ErrorHandlers = MappingKey('ErrorHandlers')
RenderFactory = Key('RenderFactory')
SessionCookie = JSONCookie
_routes = []
class RoutesModule(Module):
"""Bind a set of manually defined routes."""
def __init__(self, routes):
self._routes = routes or []
def configure(self, binder):
binder.multibind(Routes, to=self._routes)
# -*- coding: utf-8 -*-
from abc import ABCMeta, abstractmethod
from injector import Key
ErrorResolvers = Key(u'error_resolvers')
class ErrorResolver(object):
__metaclass__ = ABCMeta
def can_resolve(self, error):
error_type = error.__class__ if error else None
return error is not None and error_type is not None and self.error_type == error_type
@property
@abstractmethod
def error_type(self):
raise NotImplementedError
@property
@abstractmethod
def status(self):
raise NotImplementedError
@abstractmethod
def representation(self, error):
return None
from typing import Optional
from gi.repository import Gtk
from injector import Module, provider, singleton, Injector, Key
from liquidctl.cli import find_all_supported_devices
from liquidctl.driver.kraken_two import KrakenTwoDriver
from peewee import SqliteDatabase
from rx.disposables import CompositeDisposable
from rx.subjects import Subject
from gkraken.conf import APP_PACKAGE_NAME, APP_MAIN_UI_NAME, APP_DB_NAME, APP_EDIT_SPEED_PROFILE_UI_NAME, \
APP_PREFERENCES_UI_NAME
from gkraken.util.path import get_data_path, get_config_path
LOG = logging.getLogger(__name__)
SpeedProfileChangedSubject = Key("SpeedProfileChangedSubject")
SpeedStepChangedSubject = Key("SpeedStepChangedSubject")
MainBuilder = Key(APP_MAIN_UI_NAME)
EditSpeedProfileBuilder = Key(APP_EDIT_SPEED_PROFILE_UI_NAME)
PreferencesBuilder = Key(APP_PREFERENCES_UI_NAME)
# pylint: disable=no-self-use
class ProviderModule(Module):
@singleton
@provider
def provide_main_builder(self) -> MainBuilder:
LOG.debug("provide Gtk.Builder")
builder = Gtk.Builder()
builder.set_translation_domain(APP_PACKAGE_NAME)
builder.add_from_file(get_data_path(APP_MAIN_UI_NAME))
from injector import Key, ClassAssistedBuilder, AssistedBuilder, Injector, inject
DB = Key('DB')
class DBImplementation:
def __init__(self, uri):
pass
def configure(binder):
binder.bind(DB, to=DBImplementation)
if __name__ == '__main__':
# injector = Injector()
# builder = injector.get(ClassAssistedBuilder[UserUpdater])
# user = User('John')
# user_updater = builder.build(user=user)
print("aaa")
injector = Injector(configure)
builder = injector.get(AssistedBuilder[DB])
# print(isinstance(builder.build(uri='x'), DBImplementation))
from injector import Key
AccountRepository = Key('account_repository')
import unittest
from injector import Key
GlyphSolver = Key('GlyphSolver')
class BaseTestCase(unittest.TestCase):
def setUp(self):
import warnings
warnings.filterwarnings("ignore", category=ResourceWarning)
warnings.filterwarnings("ignore", category=DeprecationWarning)
def tearDown(self):
pass
def getInjector(self):
from injector import Injector
from yong8.shape import ConstraintShape
from .injection import DrawingModule
from .injection import FactoryModule
from xrsolver.solver.gekko import Solver
def configure(binder):
binder.bind(GlyphSolver, to=Solver())
return Injector([configure, DrawingModule(), FactoryModule()])
def assertSequenceAlmostEqual(self, seq1, seq2):
def almost_equal(value_1, value_2):
return self.assertAlmostEqual(value_1, value_2)