def sample_interactions(registry: ServiceRegistry) -> List[str]: """ Pretend to do a couple of customer interactions """ greetings = [] bootstrap_container: ServiceContainer = registry.create_container() datastore: Datastore = bootstrap_container.get(Datastore) for customer in datastore.customers: # Do a sample "interaction" (aka transaction, aka request) for # each customer. This is like handling a view for a request. interaction_container = registry.create_container() greeting = customer_interaction(interaction_container, customer) greetings.append(greeting) return greetings
def setup(registry: ServiceRegistry, settings: Settings): # The French greeter, using context of FrenchCustomer punctuation = settings.punctuation def french_greeter_factory(container) -> Greeter: return FrenchGreeter(punctuation=punctuation) # Register it as a factory using its class for the "key", but # this time register with a "context" registry.register_factory( french_greeter_factory, Greeter, context=FrenchCustomer ) # *** OVERRIDE !!! This add-on replaces the core, built-in Greeter # with a different implementation. def override_greeter_factory(container) -> Greeter: return OverrideGreeter(punctuation=punctuation) # Register it as a factory using its class for the "key", but # this time register with a "context" registry.register_factory( override_greeter_factory, Greeter, context=Customer ) # Grab the Datastore and add a FrenchCustomer container: ServiceContainer = registry.create_container() datastore: Datastore = container.get(Datastore) customer1 = FrenchCustomer(name='Henri') datastore.customers.append(customer1)
def test(): assert isinstance(Foo.impl00, AutowireField) assert isinstance(Foo.impl01, AutowireField) assert isinstance(Foo.impl02, AutowireField) assert isinstance(Foo.impl03, AutowireField) registry = ServiceRegistry() enable_autowire(registry) impl00 = object() impl01 = object() impl02 = object() impl03 = object() registry.register_singleton(impl00, Iface00) registry.register_singleton(impl01, name="impl01") registry.register_singleton(impl02, name="r_impl02") registry.register_singleton(impl03, context=Ctxt) registry.register_autowire( Foo, IFoo, namespace=dict(n_impl02="r_impl02", n_impl03=Ctxt()), lazy=False, ) container = registry.create_container() foo = container.get(IFoo) assert foo.impl00 is impl00 assert foo.impl01 is impl01 assert foo.impl02 is impl02 assert foo.impl03 is impl03
def render_view( registry: ServiceRegistry, view: Optional[View] = None, # Might be in the registry already context: Optional[Any] = None, resource: Optional[Resource] = None, singletons: Singletons = tuple(), ) -> str: """ Find/render view with optional context/resource Any needed components must be registered before passing in registry. """ if view is not None: if context is not None: register_view(registry, view, context=context.__class__) else: register_view(registry, view) container = registry.create_container(context=context) for service, iface in singletons: container.register_singleton(service, iface) if resource is not None: container.register_singleton(resource, Resource) vdom = container.get(View) result = render(vdom, container=container) return result
def test_component_register_component( registry: ServiceRegistry, simple_root, ): from wired_components.component import IComponent, register_component # Register a component @implementer(IComponent) @dataclass class SomeComponent: flag: int register_component(registry, SomeComponent) # Make a container with an IResource in it container = registry.create_container(context=simple_root) # Now get the component *class* component_class = container.get(IComponent, name='SomeComponent') # Try to make a component *instance* with pytest.raises(TypeError): # Requires a prop to be passed in component_class() # Now construct the component instance the correct way, with a prop component_instance: SomeComponent = component_class(flag=44) assert component_instance.flag == 44
def app_bootstrap(settings: Settings) -> ServiceRegistry: # Make the registry registry = ServiceRegistry() # Store the settings in the registry so things later can # get to them. registry.register_singleton(settings, Settings) # Scan for registrations scanner = venusian.Scanner(registry=registry, settings=settings) from . import models scanner.scan(models) # Grab the datastore singleton to pass into setup container: ServiceContainer = registry.create_container() datastore: Datastore = container.get(Datastore) # Do setup for the core application features setup(registry, datastore) # Import the add-on and initialize it from . import custom scanner.scan(custom) custom.setup(registry, datastore) return registry
def test_setup_target_module(): registry = ServiceRegistry() dummy_scanner = DummyScanner() scanner = cast(Scanner, dummy_scanner) from themester.testing import utils_plugin1 result = _setup_target(registry, scanner, utils_plugin1) container = registry.create_container() result1 = container.get(utils_plugin1.Heading1) assert utils_plugin1.Heading1 is result1
def app(): # Do this once at startup registry = ServiceRegistry() scanner = Scanner(registry=registry) # Point the scanner at a package/module and scan scanner.scan(decorators.decorator_args) # First request, for a regular Customer customer1 = Customer() container1 = registry.create_container(context=customer1) greeting1: Greeting = container1.get(Greeting) assert 'Hello from Susan to Jill' == greeting1.greet() # Second request, for a FrenchCustomer customer2 = FrenchCustomer() container2 = registry.create_container(context=customer2) greeting2: Greeting = container2.get(Greeting) assert 'Hello from Marie to Juliette' == greeting2.greet()
def app(): # Do this once at startup registry = ServiceRegistry() registry.register_factory(greeter_factory, Greeter) registry.register_factory(Greeting, Greeting) # Do this for every "request" or operation container = registry.create_container() greeting: Greeting = container.get(Greeting) assert 'Hello from Marie' == greeting.greet()
def view_container( registry: ServiceRegistry, root_setup, simple_root, request_setup, configuration_setup, ) -> ServiceContainer: # Make a container and return it container: ServiceContainer = registry.create_container( context=simple_root['d1']) return container
def render_path(registry: ServiceRegistry, resource_path: str) -> str: """ Render a resource at a path, to a string """ # Get the root, then the context at the path container1: ServiceContainer = registry.create_container() root: Root = container1.get(IRoot) context: Resource = find_resource(root, resource_path) # Now make a container to process this context container2: ServiceContainer = registry.create_container(context=context) view: View = container2.get(IView) renderer: JinjaRenderer = container2.get(IJinjaRenderer) context_dict = as_dict(view) template_name = view.template markup: Markup = renderer.render(context_dict, template_name=template_name, container=container2) return str(markup)
def greet_a_customer(registry: ServiceRegistry) -> str: # A customer comes in, handle the steps in the greeting # as a container. container = registry.create_container() # First step in the interaction: get the greeter the_greeter: Greeter = container.get(Greeter) # Now do the steps in the interaction greeting = the_greeter() return greeting
def app(): # Do this once at startup registry = ServiceRegistry() scanner = Scanner(registry=registry) # Point the scanner at a package/module and scan scanner.scan(decorators.decorator_with_wired_factory) # Do this for every "request" or operation container = registry.create_container() greeting: Greeting = container.get(Greeting) assert 'Hello from Marie' == greeting.greet()
def greet_customer(registry: ServiceRegistry, customer: Customer) -> str: # A customer comes in, handle the steps in the greeting # as a container. container = registry.create_container() # Get a Greeter using the customer as context. Use the Customer when # generating the greeting. greeter: Greeter = container.get(Greeter, context=customer) greeting = greeter(customer) return greeting
def test(): registry = ServiceRegistry() registry.register_factory(view_factory, View) # Per "request" container = registry.create_container() view: View = container.get(View) result = view.name expected = 'View' return expected, result
def test(): # The app registry = ServiceRegistry() scanner = Scanner(registry=registry) scanner.scan(factories) # Per "request" container = registry.create_container() view: View = container.get(View) result = view.name expected = 'View - My Site' return expected, result
def wired_setup(registry: ServiceRegistry): # Wire up the normal parts of wired_components global_setup(registry) # Wire up configuration and root configuration_setup(registry) root_setup(registry) # Get the scanner and look for things container = registry.create_container() scanner: WiredScanner = container.get(IScanner) scanner.scan(components) scanner.scan(views)
class App: def __init__(self): self.registry = ServiceRegistry() scanner = venusian.Scanner(registry=self.registry) scanner.scan(models) def __enter__(self): self.container = self.registry.create_container() return self.container def __exit__(self, exc_type, exc_val, exc_tb): if self.container: del self.container
class _RegistrarBase: """Represents the base class for classes able to register and manage services and function as an IoC object. This is an internal class and not meant for directy use in code. It was provided as a base class to aid unit testing. """ def __init__(self): self._registry = ServiceRegistry() @property def services(self): key = '_container' if not hasattr(self, key): container = self._registry.create_container() setattr(self, key, container) return getattr(self, key) def register_service(self, service, iface=Interface, context=None, name=''): service_factory = SingletonServiceWrapper(service) self.register_service_factory(service_factory, iface, context=context, name=name) def register_service_factory(self, service_factory, iface=Interface, context=None, name=''): self._registry.register_factory(ProxyFactory(service_factory), iface, context=context, name=name) def find_service_factory(self, iface, context=None, name=''): factory = self._registry.find_factory(iface, context=context, name=name) if not factory: raise LookupError('could not find registered service') if isinstance(factory, ProxyFactory): return factory.factory return factory def find_service(self, iface, context=None, name=''): return self.services.get(iface, context=context, name=name)
def app(): # Do this once at startup registry = ServiceRegistry() scanner = Scanner(registry=registry) # Point the scanner at a package/module and scan scanner.scan(decorators.basic_class) registry.register_factory(greeter_factory, Greeter) # No longer need this line # registry.register_factory(Greeting, Greeting) # Do this for every "request" or operation container = registry.create_container() greeting: Greeting = container.get(Greeting) assert 'Hello from Marie' == greeting.greet()
def process_request(registry: ServiceRegistry, url: str) -> str: """ Given URL (customer name), make a Request to handle interaction """ # Make the container that this request gets processed in container = registry.create_container() # Put the url into the container container.register_singleton(url, Url) # Create a View to generate the greeting view = container.get(View) # Generate a response response = view() return response
def render_vdom( registry: ServiceRegistry, vdom: VDOM, context: Optional[Any] = None, resource: Optional[Resource] = None, singletons: Singletons = tuple(), ) -> str: """ Render a VDOM to string with optional context/resource """ container = registry.create_container(context=context) for service, iface in singletons: container.register_singleton(service, iface) if resource is not None: container.register_singleton(resource, Resource) result = render(vdom, container=container) return result
def assert_lazy(cls_args, cls_kwargs): assert isinstance(Foo.impl00, AutowireField) assert isinstance(Foo.impl01, AutowireField) assert isinstance(Foo.impl02, AutowireField) assert isinstance(Foo.impl03, AutowireField) assert isinstance(Foo.impl04, AutowireField) assert isinstance(Foo.impl05, AutowireField) assert isinstance(Foo.impl06, AutowireField) registry = ServiceRegistry() enable_autowire(registry) impl00 = object() impl01 = object() impl02 = object() impl03 = object() impl04 = object() impl05 = object() impl06 = object() registry.register_singleton(impl00, Iface00) registry.register_singleton(impl01, name="impl01") registry.register_singleton(impl02, name="r_impl02") registry.register_singleton(impl03, context=Ctxt) registry.register_singleton(impl04, name="pv_impl04") registry.register_singleton(impl05, context=Ctxt2) registry.register_singleton(impl06, context=IFoo) registry.register_autowire( Foo, IFoo, namespace=dict(n_impl02="r_impl02", n_impl03=Ctxt()), cls_args=cls_args, cls_kwargs=cls_kwargs, lazy=True, ) container = registry.create_container() foo = container.get(IFoo) assert foo.impl00 is impl00 assert foo.impl01 is impl01 assert foo.impl02 is impl02 assert foo.impl03 is impl03 assert foo.impl04 is impl04 assert foo.impl05 is impl05 assert foo.impl06 is impl06
def setup(registry: ServiceRegistry, settings: Settings): # The French greeter, using context of FrenchCustomer punctuation = settings.punctuation def french_greeter_factory(container) -> Greeter: return FrenchGreeter(punctuation=punctuation) # Register it as a factory using its class for the "key", but # this time register with a "context" registry.register_factory(french_greeter_factory, Greeter, context=FrenchCustomer) # Grab the Datastore and add a FrenchCustomer container: ServiceContainer = registry.create_container() datastore: Datastore = container.get(Datastore) henri = FrenchCustomer(name='henri', title='Henri') datastore.customers['henri'] = henri
def render_component( registry: ServiceRegistry, component: Component, context: Optional[Any] = None, resource: Optional[Resource] = None, singletons: Singletons = tuple(), ) -> str: """ Render a component to string with optional context/resource """ register_component(registry, component) container = registry.create_container(context=context) for service, iface in singletons: container.register_singleton(service, iface) if resource is not None: container.register_singleton(resource, Resource) vdom = html('<{component} />') result = render(vdom, container=container) return result
def process_request(registry: ServiceRegistry, url_value: str) -> str: """ Given URL (customer name), make a Request to handle interaction """ from .models import Resource, View, Url # Make the container that this request gets processed in container = registry.create_container() # Put the url into the container url = Url(value=url_value) container.register_singleton(url, Url) # Get the context context = container.get(Resource) # Create a View to generate the greeting view = container.get(View, context=context) # Generate a response response = view() return response
def render_template( registry: ServiceRegistry, template: VDOM, context: Optional[Any] = None, resource: Optional[Resource] = None, singletons: Singletons = tuple(), ) -> str: """ Find/render template string with optional context/resource Any needed components must be registered before passing in registry. """ container = registry.create_container(context=context) for service, iface in singletons: container.register_singleton(service, iface) if resource is not None: container.register_singleton(resource, Resource) result = render(template, container=container) return result
def test_component_register_component2( registry: ServiceRegistry, simple_root, ): from wired_components.component import IComponent from wired_components.component.register_component import register_component2 # Register a component @implementer(IComponent) @dataclass class SomeComponent: flag: int register_component2(registry, SomeComponent) # Make a container with an IResource in it container = registry.create_container(context=simple_root) # Now get the component *class* component_class = container.get(IComponent, name='SomeComponent') # Now construct the component instance the correct way, with a prop component_instance: SomeComponent = component_class(flag=44) assert component_instance.flag == 44
def container(): registry = ServiceRegistry() container = registry.create_container() return container