def _generate_url_iterable(self, url_iterable): parsed_urls = [] for url in url_iterable: method = not_provided if is_list_or_tuple(url): url, method = url if not is_list_or_tuple(method): methods = (method, ) else: methods = method for method in methods: method_pattern = re.compile(method) url_pattern = self.url_pattern(url) parsed_urls.append((url_pattern, method_pattern)) return parsed_urls
def setdefault(self, *args): """Establishes a default return value for get() by optional method (iterable). reg.setdefault(ResourceOne) reg.get('/some/unregistered/path') -> ResourceOne reg.setdefault('method', ResourceTwo) reg.get('/some/registered/methodless/path/', 'method') -> ResourceTwo reg.setdefault(('method_one', 'method_two'), ResourceThree) reg.get('/some/unregistered/path', 'method_two') -> ResourceThree reg.setdefault('supports.*regex', ResourceFour) reg.get('supports123regex') -> ResourceFour """ if not args: raise TypeError('setdefault needs at least a Resource.') if len(args) == 1: # all methods self.default[re.compile('.*')] = args[0] elif len(args) == 2: if is_list_or_tuple(args[0]): methods = args[0] else: methods = (args[0], ) for method in methods: method_pattern = re.compile(method) self.default[method_pattern] = args[1] else: raise TypeError( 'setdefault takes at most 2 arguments ({} given).'.format( len(args)))
def register(self, *args): """Registers a single resource (generic python type or object) to either 1. a single url string (internally coverted via URLRegistry.url_pattern) and optional method or method iterable 2. a list or tuple of url string and optional method or method iterables for retrieval via get(). reg.register('/some/path/', ResourceOne) reg.get('/some/path/') -> ResourceOne reg.register('/some/other/path/', 'method', ResourceTwo) reg.get('/some/other/path/', 'method') -> ResourceTwo reg.register('/some/additional/path/', ('method_one', 'method_two'), ResourceThree) reg.get('/some/additional/path/', 'method_one') -> ResourceThree reg.get('/some/additional/path/', 'method_two') -> ResourceThree reg.register(('/some/new/path/one/', '/some/new/path/two/', ('/some/other/new/path', 'method'), ('/some/other/additional/path/, ('method_one', 'method_two')), ResourceFour)) reg.get('/some/other/new/path/', 'method') -> ResourceFour """ if not args or len(args) == 1: raise TypeError('register needs at least a url and Resource.') elif len(args) not in (2, 3): raise TypeError( 'register takes at most 3 arguments ({} given).'.format( len(args))) if len(args) == 3: # url, method (iterable), and Resource url_iterable = (args[:2], ) resource = args[2] else: urls, resource = args if not is_list_or_tuple(urls): url_iterable = [(urls, not_provided)] else: url_iterable = urls url_iterable = self._generate_url_iterable(url_iterable) for url_pattern, method_pattern in url_iterable: if url_pattern in self.store and method_pattern in self.store[ url_pattern]: if method_pattern.pattern == not_provided: exc_msg = '"{0.pattern}" already has methodless registration.'.format( url_pattern) else: exc_msg = ( '"{0.pattern}" already has registered method "{1.pattern}"' .format(url_pattern, method_pattern)) raise TypeError(exc_msg) self.store[url_pattern][method_pattern] = resource
def register_page(urls, page_cls): if not _page_registry.default: from awxkit.api.pages import Base _page_registry.setdefault(Base) if not is_list_or_tuple(urls): urls = [urls] # Register every methodless page with wildcard method # until more granular page objects exist (options, head, etc.) updated_urls = [] for url_method_pair in urls: if isinstance(url_method_pair, str): url = url_method_pair method = '.*' else: url, method = url_method_pair updated_urls.append((url, method)) page_cls.endpoint = updated_urls[0][0] return _page_registry.register(updated_urls, page_cls)