def __call__(self, event: OnAppBooted): """Bootstrap the Database after the Application is Booted""" # Gather all connections, models, tables # No need to gather seeder classes, I get those in the ./uvicore db seed command connections = Dict() models = []; tables = [] last_default = None; app_default = None for package in uvicore.app.packages.values(): if not 'database' in package: continue # Get last defined default connection if package.database.connection_default: last_default = package.database.connection_default # Get running app default connection if package.main and package.database.connection_default: app_default = package.database.connection_default # Append connections connections.merge(package.database.connections) # Append models models.extend(package.database.models or []) # Append tables tables.extend(package.database.tables or []) # Initialize Database with all connections at once uvicore.db.init(app_default or last_default, connections) # Dynamically Import models, tables and seeders for model in models: load(model) for table in tables: load(table)
def subscribe(self, listener: Union[str, Callable]) -> None: """Add a subscription class which handles both registration and listener callbacks""" try: if type(listener) == str: module.load(listener).object().subscribe(uvicore.events) else: listener.subscribe(uvicore.events) except ModuleNotFoundError: pass
def add_middleware(self, web_server: FastAPI, api_server: FastAPI) -> None: """Add global web and api middleware to their respective servers""" # Add global web middleware if web_server: for name, middleware in uvicore.config.app.web.middleware.items(): cls = module.load(middleware.module).object web_server.add_middleware(cls, **middleware.options) # Add global api middleware if api_server: for name, middleware in uvicore.config.app.api.middleware.items(): cls = module.load(middleware.module).object api_server.add_middleware(cls, **middleware.options)
def _get_dispatcher(self, event: Union[str, Callable], payload: Dict = {}, is_async: bool = False) -> Tuple: """Get dispatcher method for this event""" # This function determines the proper dispatching method for this event. # If event is a string, we use self._dispatch # If event is a class we call that classes .dispatch method method = None params = [event, payload] if type(event) == str: if '-' in event or '{' in event: # String event (we know because classes can't have dashes or {. # This is how we name dynamic string based events like per model or table... method = self._dispatch_async if is_async else self.dispatch else: # See if string event has a matching class. If so, import and dispatch it try: event = module.load(event).object(**payload) params = [] method = event.dispatch_async if is_async else event.dispatch except: # No class found for this string. This is OK because events can # be strings without matching classes. Dispatch it anyway method = self._dispatch_async if is_async else self._dispatch else: # Event is an event class INSTANCE. Call the actual classes dispatch method # in case the user overrode it, we still execute it params = [] method = event.dispatch_async if is_async else event.dispatch # Return tuple of dispatcher method and params return (method, params)
async def retrieve_user(self, username: str, password: str, provider: Dict, request: HTTPConnection, **kwargs) -> Optional[UserInfo]: """Retrieve user from User Provider backend""" # Import user provider defined in auth config user_provider: UserProvider = module.load(provider.module).object() # Get user from user provider and validate password. User will be Anonymous # if user not found, disabled or validation failed user = await user_provider.retrieve_by_credentials( # Require parameters username=username, password=password, request=request, # Pass in options from auth config **provider.options, # Pass in options from the calling authenticator **kwargs, ) # Do not throw error if no user or not validated here. We let the middleware handle that return user
def add_exception_handlers(self, web_server: FastAPI, api_server: FastAPI) -> None: """Add global web and api exception handlers to their respective servers""" from starlette.exceptions import HTTPException # Add global web exception handlers if web_server and uvicore.config.app.web.exception.handler: cls = module.load(uvicore.config.app.web.exception.handler).object web_server.add_exception_handler(HTTPException, cls) # for name, handler in uvicore.config.app.web.exceptions.items(): # if str(name).lower() == 'main': # cls = module.load(handler).object # web_server.add_exception_handler(HTTPException, cls) # Add global api exception handlers if api_server and uvicore.config.app.api.exception.handler: cls = module.load(uvicore.config.app.api.exception.handler).object api_server.add_exception_handler(HTTPException, cls)
async def sync_user(self, provider: Dict, request: HTTPConnection, **kwargs): # Import user provider defined in auth config user_provider: UserProvider = module.load(provider.module).object() # Create user from user provider # Returned user is actual backend user, NOT Auth User object user = await user_provider.sync_user(request, **kwargs) return user
def _get_package_config(self, package: str, options: Dict) -> Dict: config_module = package + '.config.package.config' # Default if not defined if 'config' in options: config_module = options['config'] config = Dict() try: config = Dict(load(config_module).object) except: # Often we won't have any config for a package, if so return empty Dict pass return config
def configs(self, options: List[Dict]) -> None: for config in options: # Load module to get actual config value value = load(config['module']).object # Merge config value with complete config #uvicore.config.merge(config['key'], value) new = Dict() new.dotset(config['key'], value) uvicore.config.merge(new)
def __call__(self, event: OnAppBooted): """Bootstrap the Console after the Application is Booted""" #from uvicore.console.console import cli cli = uvicore.ioc.make('uvicore.console.console.cli') # Deep merge all command groups, this allows simple command extension! groups = Dict() for package in uvicore.app.packages.values(): if not 'console' in package: continue # Only register commands if package registration is allowed # AND if running from the console...OR if the command group is # 'http'. We always want the http group regardless of cli or # http entrypoints. register = package.registers.commands is_console = uvicore.app.is_console for key, group in package.console['groups'].items(): if (register and is_console) or key == 'http': groups.merge({key: group}) # Register each group and each groups commands click_groups = {} for key, group in groups.items(): # Split key to find parent/child groups parts = key.split(':') parent = ':'.join(parts[0:-1]) name = parts[-1] # Create a new click group if not exists @cli_group(help=group['help']) def click_group(): pass click_groups[key] = click_group # Get click group based on key (this is how we handle sub groups) #click_group = click_groups[key] # Add all commands into this click_group for command_name, command_module in group.commands.items(): # Dynamically import the commands module module = load(command_module).object click_group.add_command(module, command_name) # Add group to console if len(parts) == 1: # Root level group cli.add_command(click_group, name) else: # Sub group click_groups[parent].add_command(click_group, name)
async def retrieve_user(self, username: str, password: str, provider: Dict) -> Optional[User]: """Retrieve user from User Provider backend""" # Import our user provider defined in auth config user_provider: UserProvider = module.load(provider.module).object() # Get user from user provider and validate password # If returned user is None, validation has failed, user is disabled or user not found user = await user_provider.retrieve_by_credentials( username, password, **provider.options) # Do not throw error if no user or not validated here. We let the middleware handle that return user
def connect(self, store: str = None) -> CacheInterface: """Connect to a cache backend store""" store_name = store or self.default store = self.stores.get(store_name) if not store: raise Exception('Cache store {} not found'.format(store_name)) if store_name not in self.backends: # Instantiate, connect and save store in local backends cache driver = module.load(store.driver).object(self, store) self._backends[store_name] = driver return self.backends[store_name]
def test_load_file(): # Import actual module (file) but not a method inside it # Module( # object=<module 'uvicore.foundation.config.package' from '/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/foundation/config/package.py'>, # name='package', # path='uvicore.foundation.config', # fullpath='uvicore.foundation.config.package', # package='uvicore.foundation.config', # file='/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/foundation/config/package.py') x = module.load('uvicore.foundation.config.package') assert "<module 'uvicore.foundation.config.package' from " in str(x.object) assert x.name == 'package' assert x.path == 'uvicore.foundation.config' assert x.fullpath == 'uvicore.foundation.config.package' assert x.package == 'uvicore.foundation.config' assert 'uvicore/foundation/config/package.py' in x.file
def test_load_namespace(): # Import namespace package (no __init__.py) # Module( # object=<module 'uvicore.foundation' (namespace)>, # name='foundation', # path='uvicore', # fullpath='uvicore.foundation', # package='uvicore.foundation', # file='/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/foundation') x = module.load('uvicore.foundation') assert str(x.object) == "<module 'uvicore.foundation' (namespace)>" assert x.name == 'foundation' assert x.path == 'uvicore' assert x.fullpath == 'uvicore.foundation' assert x.package == 'uvicore.foundation' assert 'uvicore/foundation' in x.file
def test_load_package(): # Import non root level package (has __init__.py) # Module( # object=<module 'uvicore.container' from '/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/container/__init__.py'>, # name='container', # path='uvicore', # fullpath='uvicore.container', # package='uvicore.container', # file='/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/container/__init__.py') x = module.load('uvicore.configuration') assert "<module 'uvicore.configuration' from " in str(x.object) assert x.name == 'configuration' assert x.path == 'uvicore' assert x.fullpath == 'uvicore.configuration' assert x.package == 'uvicore.configuration' assert 'uvicore/configuration/__init__.py' in x.file
def test_load_root(): # Import root level package (has __init__.py) # Module( # object=<module 'uvicore' from '/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/__init__.py'>, # name='uvicore', # path='uvicore', # fullpath='uvicore', # package='uvicore', # file='/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/__init__.py') x = module.load('uvicore') assert "<module 'uvicore' from " in str(x.object) assert x.name == 'uvicore' assert x.path == 'uvicore' assert x.fullpath == 'uvicore' assert x.package == 'uvicore' assert 'uvicore/__init__.py' in x.file
def import_package_web_routes(self, package: Package) -> Dict: """Import one package web routes and return routes Dict""" # If no routes_modules defined, nothing todo if not package.web.routes_module: return # Allow only if running as HTTP or from certain CLI commands like package list/show... if package.registers.web_routes and ( uvicore.app.is_http #or #command_is('http') or #command_is('package') or #command_is('ioc') ) == False: return routes_module = package.web.routes_module prefix = package.web.prefix name_prefix = package.web.name_prefix # Import main web routes module routes: Routes = module.load(routes_module).object(package) # Get name prefix from package name plus custom name prefix if name_prefix: if name_prefix[0] == '.': name_prefix = name_prefix[1:] name_prefix = package.short_name + '.' + name_prefix else: name_prefix = package.short_name # Import the web router and create a new instance from uvicore.http.routing.web_router import WebRouter # isort:skip router = WebRouter(package, prefix, name_prefix) # Get returned router with all defined routes router = routes.register(router) # Merge routes level middleware into each route routes_middleware = routes._middleware() if routes_middleware: for route in router.routes.values(): (route.middleware, route.endpoint) = router._merge_route_middleware( routes_middleware, route.middleware, route.endpoint) # Return routes return router.routes
def _get_handlers(self, event: Union[str, Callable], payload: Dict = {}) -> Tuple: """Get all listener/handlers and fix up payload""" # Get event by string name or class inspection #event_meta = self.event(event) if type(event) == str: # String based event, merge payload with default event event = Dict(payload).merge({ 'name': event, 'description': 'String based dynamic event.' }) # Payload default is a SuperDict #payload = Dict(payload) # If event is a class, payload is the class instance #if type(event) != str: payload = event # Get listener methods (dynamic import if string) listeners = self.event_listeners(event.name) handlers = [] for handler in listeners: if type(handler) == str: # handler is a string to a listener class with handle() method try: #cls = module.load(listener).object(uvicore.app) cls = module.load(handler).object() handlers.append(cls) #handlers.append(cls.handle) except ModuleNotFoundError: # Bad handler, handler will never fire continue else: # handler is a Class if inspect.isclass(handler): handler = handler() # Listener is a Callable (if was a class, NOW its callable) handlers.append(handler) # Return tuple of event and handlers #return (event_meta, payload, handlers) return (event, handlers)
async def retrieve_anonymous_user(self, request: HTTPConnection): """Retrieve anonymous user from User Provider backend""" # Import user provider defined in auth config # Anonymous user provider is always the 'default_provider' user_provider: UserProvider = module.load(self.config.default_provider.module).object() # Get additional provider kwargs from options and anonymous_options config kwargs = self.config.default_provider.options.clone() kwargs.merge(self.config.default_provider.anonymous_options) # Anonymous wins in merge # Alter provider method called based on existence of username, id, or uuid parameters provider_method = user_provider.retrieve_by_username if 'id' in kwargs: provider_method = user_provider.retrieve_by_id if 'uuid' in kwargs: provider_method = user_provider.retrieve_by_uuid # Call user provider method passing in defined kwargs return await provider_method(request=request, **kwargs)
def test_load_object(): # Import class from inside a file # uvicore.support.module.Module( # object=uvicore.container.ioc._Ioc, # class # name='_Ioc', # path='uvicore.container.ioc', # fullpath='uvicore.container.ioc._Ioc', # package='uvicore.container', # file='/home/mreschke/Code/mreschke/python/uvicore/uvicore/uvicore/' # 'container/ioc.py' # ) x = module.load('uvicore.container.ioc._Ioc') assert "<class 'uvicore.container.ioc._Ioc'>" in str(x.object) assert x.name == '_Ioc' assert x.path == 'uvicore.container.ioc' assert x.fullpath == 'uvicore.container.ioc._Ioc' assert x.package == 'uvicore.container' assert 'uvicore/container/ioc.py' in x.file
def _register_providers(self, app_config: Dict) -> None: """Register all providers by calling each ServiceProviders register() method""" for package_name, service in self.providers.items(): # Example: # package_name = uvicore.configuration # service = {'provider': 'uvicore.configuration.services.Configuration'} # Start a new package definition #x = OrderedDict() #x.dotset(package_name, package.Definition({ self._packages[package_name] = Package({ 'name': package_name, 'short_name': package_name.split('.')[-1] if '.' in package_name else package_name, 'vendor': package_name.split('.')[0], # Works fine even if no . 'main': True if package_name == self.main else False, 'path': location(package_name), }) #self._packages.merge(x) #self._packages[package_name] = package.Definition({ #dd(self.packages) # Instantiate the provider and call the register() method provider = load(service['provider']).object( app=self, name=package_name, package=None, # Not available in register() app_config=app_config, package_config=self._get_package_config(package_name, service), ) provider.register() # Complete registration self._registered = True #uvicore.events.dispatch('uvicore.foundation.events.app.Registered') #uvicore.events.dispatch(uvicore.foundation.events.app.Registered()) #uvicore.events.dispatch('uvicore.foundation.events.app.Registered', {'test': 'test1'}) events.Registered().dispatch()
def _boot_providers(self, app_config: Dict) -> None: for package_name, service in self.providers.items(): # Example: # package_name = uvicore.configuration # service = {'provider': 'uvicore.configuration.services.Configuration'} # Import the provider and call boot() provider = load(service['provider']).object( app=self, name=package_name, package=self.package(package_name), app_config=app_config, package_config=self._get_package_config(package_name, service), ) provider.boot() # Complete booting self._booted = True #uvicore.events.dispatch('uvicore.foundation.events.app.Booted') #uvicore.events.dispatch(uvicore.foundation.events.app.Booted()) #uvicore.events.dispatch('uvicore.foundation.events.app.Booted') events.Booted().dispatch()
def make(self, name: str, default: Callable[[], T] = None, **kwargs) -> T: if default is not None and self.binding(name) is None: # Default was provided and no binding currently exists # Bind the default provided but look for bindings override in app_config #object = default #bindings = self._app_config.get('bindings') or {} #object = bindings.get(name) or default object = self.overrides.get(name) or default self.bind(name, object, **kwargs) binding = self.binding(name) if not binding: # No binding set yet. If we simply try to import the file only, it may have a # decorator that will bind itself. If no binding found even after import, treat as not found if '.' in name: module.load(name) # Check binding again binding = self.binding(name) if not binding: raise ModuleNotFoundError("Could not find IoC name '{}' in mapping.".format(name)) # If object is not defined, dynamically import it on first make (deferred) if not binding.object: # If object is None, dynamically import object from path binding.object = module.load(binding.path).object # Determine type is_class = inspect.isclass(binding.object) is_singleton = is_class and binding.singleton kwargs = binding.kwargs or {} # Odd case if not is_class and binding.singleton and hasattr(binding.object, '__class__') and '.' in str(getattr(binding.object, '__class__')): # If you override a singlton with another singleton (in the case of overriding a table for example) # You get an odd case where the binding object is the singleton itself. So here we detect if the object # should be a singleton, and is NOT a class (because its already a singleton instance) and the object # is an instance (meaning it has a __class__ attribute) then we need to swap the instance with the object # and set the objects name to the instances __class__ # By checking if __class__ has a . in it we skip over if someone accidentally added a singleton to a function or method # In case you are wondering, the singleton of the original IS the same singleton as the override! binding.instance = binding.object binding.object = binding.instance.__class__ is_singleton = True # Instantiate a singleton only once made = None if is_singleton: if not binding.instance: if binding.factory: factory = module.load(binding.factory).object binding.instance = factory().make(binding.object, **kwargs) else: binding.instance = binding.object(**kwargs) made = binding.instance # Instantiate a non-singleton every time # Unless there is no factory and no kwargs, simply return the object class elif is_class: if binding.factory: if type(binding.factory) == str: # String factory, dynamically import it factory = module.load(binding.factory).object else: # Direct class factory factory = binding.factory made = factory().make(binding.object, **kwargs) elif binding.kwargs: made = binding.object(**kwargs) else: made = binding.object # Bind is not a class. Must be a method or module, return it else: made = binding.object # Return made object return made
def test_load_invalid(): # Import invalid module with pytest.raises(ModuleNotFoundError): module.load('uvicorex')
def test_load_invalid_attribute(): # Import invalid attribute with pytest.raises(Exception): module.load('uvicore.nothing')
def test_load_wildcard(): # Import wildcard module.load('uvicore.foundation.config.*')
def controller(self, module: Union[str, Callable], *, prefix: str = '', name: str = '', tags: Optional[List[str]] = None, options: Dict = {}) -> List: """Include a Route Controller""" if prefix: if prefix[-1] == '/': prefix = prefix[0:-1] # Remove trailing / if prefix[0] != '/': prefix = '/' + prefix # Add beginning / # Get name if not name: name = prefix # Clean name if name: name = name.replace('/', '.') if name[-1] == '.': name = name[0:-1] # Remove trailing . if name[0] == '.': name = name[1:] # Remove beginning . # Import controller module from string cls = module if type(module) == str: if self.controllers: if '.' not in module: # We are defining just 'home', so we add .Home class module = self.controllers + '.' + module + '.' + string.studly( module) elif module[0] == '.': # We are appending the path to self.controllers # Must have class too, ex: .folder.stuff.Stuff module = self.controllers + module # elif module.count('.') == 1: # NO, we'll just add a . before, like .home.Home and it does the same thing # # We are defining the file and the class (home.Home) # # Only works with ONE dot. If you want to append use .folder.stuff.Stuff # module = self.controllers + '.' + module else: # We are defining the FULL module path even though we have defined a self.controller path # Must have class too, ex: acme.appstub.http.api.stuff.Stuff pass # Dynamically import the calculated module cls = load(module).object if str(type(cls)) == "<class 'module'>": # Trying to load a module, but we want the class inside the module, auto add module = module + '.' + string.studly(module.split('.')[-1]) cls = load(module).object # Instantiate controller file controller: Routes = cls(self.package, **options) # New self (Web or Api) router instance router = self.__class__(self.package, self.prefix + prefix, self.name + '.' + name, self.controllers) # Register controllers routes and return new updated router router = controller.register(router) # Add contoller class level attributes as middleware to each route on this controller controller_middlewares = controller._middleware() if controller_middlewares: for route in router.routes.values(): (route.middleware, route.endpoint) = self._merge_route_middleware( controller_middlewares, route.middleware, route.endpoint) # Merge controllers routes into this main (parent of recursion) router #dump(router.routes) self.routes.merge(router.routes) # Return just this controllers routes as a list routes = [] for route in router.routes.keys(): # Append .controller(tags=[xyz]) if exists if tags: if router.routes[route].tags is None: router.routes[route].tags = [] router.routes[route].tags.extend(tags) routes.append(router.routes[route]) return routes
def controller(self, module: Union[str, Callable], *, prefix: str = '', name: str = '', tags: Optional[List[str]] = None, options: Dict = {}) -> List: if prefix: if prefix[-1] == '/': prefix = prefix[0:-1] # Remove trailing / if prefix[0] != '/': prefix = '/' + prefix # Add beginning / # Get name if not name: name = prefix # Clean name if name: name = name.replace('/', '.') if name[-1] == '.': name = name[0:-1] # Remove trailing . if name[0] == '.': name = name[1:] # Remove beginning . # Import controller module from string if type(module) == str: if self.controllers: if '.' not in module: # We are defining just 'home', so we add .Home class module = self.controllers + '.' + module + '.' + string.studly( module) elif module.count('.') == 1: # We are defining the file and the class (home.Home) module = self.controllers + '.' + module else: # We are defining the FULL module path even though we have defined a self.controller path pass module = load(module).object # Instantiate controller file controller: Routes = module(self.package, **options) # New self (Web or Api) router instance router = self.__class__(self.package, self.prefix + prefix, self.name + '.' + name, self.controllers) # Register controllers routes and return new updated router router = controller.register(router) # Add contoller class level attributes as middleware to each route on this controller controller_middlewares = controller._middleware() if controller_middlewares: for route in router.routes.values(): (route.middleware, route.endpoint) = self._merge_route_middleware( controller_middlewares, route.middleware, route.endpoint) # Merge controllers routes into this main (parent of recursion) router #dump(router.routes) self.routes.merge(router.routes) # Return just this controllers routes as a list routes = [] for route in router.routes.keys(): routes.append(router.routes[route]) return routes
async def __call__(self, scopes: SecurityScopes, request: Request): #dump(self.guard) # Dict({ # 'authenticators': Dict({ # 'jwt': Dict({ # 'module': 'uvicore.auth.middleware.Jwt', # 'verify_signature': True, # 'algorithms': ['RS256'], # 'secret': # '-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnc84SDViVX8JNye2GVQZ\n' # 'ixAwG2PWXoOhkj++wGASoAXs2LN0Ue48conxf/0bgEtq6kcbLPR23SieqBZA77vc\n' # 'yulimMbzfwNczyP3FRo8wSCqRgJipTse87WItd8ga2MUCzSS8q19V4swUT4T23Su\n' # 'DiG/Ry5f1sYbvxP2kJAJMUCzVbS7STxh33h65Bj+P6JdzrCJi+yrLqg928RHjLIF\n' # 'gDy4MyFBLTI8w5u6IJi1TLm6h9lj3YqSa/qDkkIardnnZa7Xj0IJCEB9c+RD4Q7C\n' # '+jco6g2Vr9oLP8Mg3c5lZPNVzcXC67UMVk9lK+zrlfPDI/m2+9kyTc/58S9ZUTFJ\nQwIDAQAB\n-----END PUBLIC KEY-----' # }), # 'basic': Dict({ # 'module': 'uvicore.auth.middleware.Basic', # 'provider': 'users', # 'realm': 'App1' # }) # }), # 'name': 'api' # }) for authenticator in self.guard.authenticators.values(): # Get authenticator options by deep merging defaults and proper providers options = authenticator.clone() if 'options' in options: # Deep merge default options option_key = options.options if option_key not in self.options: # This is an application error, not an HTTPException raise Exception( 'Default options key {} not found in app config'. format(option_key)) options.defaults( self.options[option_key]) # Merge seems to do a clone too! # Merge provider into options if 'provider' in options: if options.provider not in self.providers: # This is an application error, not an HTTPException raise Exception( 'Provider {} not found in app config'.format( options.provider)) options.provider = self.providers[options.provider].clone() options.guard = self.guard.name #dump(options) # Dict({ # 'default_options': 'jwt', # 'module': 'uvicore.auth.middleware.Jwt', # 'provider': Dict({ # 'module': 'uvicore.auth.models.user.User', # 'method': 'userinfo', # 'model': 'uvicore.auth.models.user.User', # 'includes': ['roles', 'roles.permissions', 'groups', 'groups.roles', 'groups.roles.permissions'] # }), # 'sync': Dict({'auto_create_user': True}), # 'verify_signature': True, # 'audience': '222b06eb-85ce-472b-af30-ec09244e3bf0', # 'algorithms': ['RS256'], # 'secret': # '-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnc84SDViVX8JNye2GVQZ\n' # 'ixAwG2PWXoOhkj++wGASoAXs2LN0Ue48conxf/0bgEtq6kcbLPR23SieqBZA77vc\n' # 'yulimMbzfwNczyP3FRo8wSCqRgJipTse87WItd8ga2MUCzSS8q19V4swUT4T23Su\n' # 'DiG/Ry5f1sYbvxP2kJAJMUCzVbS7STxh33h65Bj+P6JdzrCJi+yrLqg928RHjLIF\n' # 'gDy4MyFBLTI8w5u6IJi1TLm6h9lj3YqSa/qDkkIardnnZa7Xj0IJCEB9c+RD4Q7C\n' # '+jco6g2Vr9oLP8Mg3c5lZPNVzcXC67UMVk9lK+zrlfPDI/m2+9kyTc/58S9ZUTFJ\nQwIDAQAB\n-----END PUBLIC KEY-----' # }) # Import the auth middleware module middleware = module.load(options.module).object(options) # Fire the middleware __call__ callable and get the returned value value = await middleware(scopes, request) # If value is returned, auth was successful with this authenticator. Return value, stop the middleware stack. # If value is None means auth headers not found. Continue to next middleware in auth stack if value is not None: return value # If we are here, no auth middleware returned a value, meaning NOT logged in # If no value is ever returned we are not logged in. # Maybe here is the place to add an anonymous user to the request? with user.authenticated = False ??????? # NO, think about this. If a route is NOT guarded, this code will never run therefore request.user will # never exist. Would have to do global auth middleware to accomplish an always present anonymous user. # I could have a built-in hidden global middleware that adds request.user as an anonymous model? raise NotAuthenticated('MASTER STACKER')
def _load_entity(self): # Fill actual entity class if uvicore.ioc.binding(self.model): self.entity = uvicore.ioc.make(self.model) else: self.entity = module.load(self.model).object