crank 0.9.0__py3-none-any.whl

crank/dispatcher.py

@@ -0,0 +1,38 @@
+"""
+This is the main dispatcher module.
+
+Dispatch works as follows:
+Start at the RootController, the root controller must
+have a _dispatch function, which defines how we move
+from object to object in the system.
+Continue following the dispatch mechanism for a given
+controller until you reach another controller with a
+_dispatch method defined.  Use the new _dispatch
+method until anther controller with _dispatch defined
+or until the url has been traversed to entirety.
+
+"""
+
+class Dispatcher(object):
+    """
+       Extend this class to define your own mechanism for dispatch.
+    """
+
+    def _dispatch(self, state, remainder=None):
+        """override this to define how your controller should dispatch.
+        returns: dispatcher, controller_path, remainder
+        """
+        raise NotImplementedError
+
+    def _setup_wsgiorg_routing_args(self, path, remainder, params):
+        """
+        This is expected to be overridden by any subclass that wants to set
+        the routing_args.
+        """
+
+    def _setup_wsgi_script_name(self, path, remainder, params):
+        """
+        This is expected to be overridden by any subclass that wants to set
+        the script name.
+        """
+

crank/dispatchstate.py

@@ -0,0 +1,221 @@
+"""
+This module implements the :class:`DispatchState` class
+"""
+import warnings
+
+from crank.util import default_path_translator, noop_translation
+
+string_type = str
+
+
+class DispatchState(object):
+    """
+    This class keeps around all the pertainent info for the state
+    of the dispatch as it traverses through the tree.  This allows
+    us to attach things like routing args and to keep track of the
+    path the controller takes along the system.
+    
+    Arguments:
+        request 
+              object, must have a path_info attribute if path_info is not provided
+        dispatcher
+              dispatcher object to get the ball rolling
+        params
+              parameters to pass into the dispatch state will use request.params
+        path_info
+              pre-split list of path elements, will use request.pathinfo if not used
+        strip_extension
+              Whenever crank should strip the url extension or not resolving the path
+        path_translator
+              Function used to perform path escaping when looking for controller methods,
+              can be None to perform no escaping or True to use default escaping function.
+    """
+
+    def __init__(self, request, dispatcher, params=None, path_info=None,
+                 ignore_parameters=None, strip_extension=True, path_translator=None):
+        self._request = request
+
+        if path_translator is None:
+            path_translator = noop_translation
+        elif path_translator is True:
+            path_translator = default_path_translator
+        self._path_translator = path_translator
+
+        self._strip_extension = strip_extension
+        self.set_path(path_info)
+
+        self._ignored_parameters = ignore_parameters
+        if params is None:
+            params = request.params
+        self.set_params(params)
+
+        self._root_dispatcher = dispatcher
+        self._controller = None
+        self._controller_path = []
+        self._routing_args = {}
+        self._action = None
+        self._remainder = None
+        self._notfound_stack = []
+
+        self.add_controller('/', dispatcher)
+
+    @property
+    def root_dispatcher(self):
+        """Root Dispatcher instance that initiated the dispatch flow"""
+        return self._root_dispatcher
+
+    @property
+    def request(self):
+        """The request that originated the dispatch process"""
+        return self._request
+
+    @property
+    def path(self):
+        """The path (URL) that has to be dispatched"""
+        return self._path
+
+    @property
+    def extension(self):
+        """Extension of the URL (only if strip_extension is enabled).
+
+        If the path ends with an extension and strip_extension is enabled
+        the extension is stripped from the url and is available here.
+        """
+        return self._extension
+
+    @property
+    def controller(self):
+        """Controller currently handling the request"""
+        return self._controller
+
+    @property
+    def controller_path(self):
+        """Controllers that got traversed to dispatch the request"""
+        return tuple(self._controller_path)
+
+    @property
+    def action(self):
+        """Method in charge of processing the request"""
+        return self._action
+
+    @property
+    def params(self):
+        """Parameters passed to the action"""
+        return self._params
+
+    @property
+    def remainder(self):
+        """Part of the URL path remaining after lookup of the action.
+
+        Those is usually passed as positional arguments to the method
+        in charge of the action together with params.
+        """
+        return self._remainder
+
+    def add_controller(self, location, controller):
+        """Add a controller object to the stack"""
+        self._controller = controller
+        self._controller_path.append((location, controller))
+
+    def set_action(self, method, remainder):
+        """Add the final method that will be called in the _call method"""
+        self._action = method
+        self._remainder = remainder
+
+    def set_params(self, params):
+        """Set parameters that will be passed to the called action"""
+        self._params = params
+        if self._ignored_parameters:
+            for param in self._ignored_parameters:
+                self._params.pop(param, None)
+
+    def set_path(self, path_info):
+        """Update path that needs to be dispatched.
+
+        In case this is changed during the dispatch process it won't
+        have any effect on the dispatch currently under execution.
+        """
+        path = path_info
+        if path is None:
+            path = self._request.path_info[1:]
+            path = path.split('/')
+        elif isinstance(path, string_type):
+            path = path.split('/')
+
+        try:
+            if not path[0]:
+                path = path[1:]
+        except IndexError:
+            pass
+
+        try:
+            while not path[-1]:
+                path = path[:-1]
+        except IndexError:
+            pass
+
+        # rob the extension
+        self._extension = None
+        if self._strip_extension and len(path) > 0 and '.' in path[-1]:
+            end = path[-1]
+            end, ext = end.rsplit('.', 1)
+            self._extension = ext
+            path[-1] = end
+        self._path = path
+
+    def resolve(self):
+        """Once a DispatchState is created resolving it performs the dispatch.
+
+        Returns the updated DispatchState where ``.controller``, ``.action``,
+        ``.params`` and ``.remainder`` properties all point to the controller
+        and method that should process the request and to the method arguments.
+        """
+        if self._action is not None:
+            raise RuntimeError('Trying to resolve an already resolved DispatchState')
+        return self._root_dispatcher._dispatch(self, self._path)
+
+    def translate_path_piece(self, path_piece):
+        return self._path_translator(path_piece=path_piece)
+
+    def add_routing_args(self, current_path, remainder, fixed_args, var_args):
+        """
+        Add the "intermediate" routing args for a given controller mounted
+        at the current_path. This is mostly used during REST dispatch to keep
+        track of intermediate arguments and make them always available.
+        """
+        i = 0
+        for i, arg in enumerate(fixed_args):
+            if i >= len(remainder):
+                break
+            self._routing_args[arg] = remainder[i]
+        remainder = remainder[i:]
+        if var_args and remainder:
+            self._routing_args[current_path] = remainder
+
+    @property
+    def routing_args(self):
+        """Parameters detected by the routing system.
+
+        This includes Request parameters and parameters extracted in other
+        ways (usually added through :meth:`.add_routing_args`). In case
+        of REST it will include intermediate arguments retrieved during dispatch
+        of parent controllers.
+        """
+        return self._routing_args
+
+    def add_method(self, method, remainder):  # pragma: no cover
+        warnings.warn("add_method is deprecated, please use set_action instead",
+                      DeprecationWarning, stacklevel=2)
+        self.set_action(method, remainder)
+
+    @property
+    def method(self):  # pragma: no cover
+        warnings.warn(".method is deprecated, please use .action instead",
+                      DeprecationWarning, stacklevel=2)
+        return self.action
+
+    @property
+    def dispatcher(self):  # pragma: no cover
+        warnings.warn(".dispatcher is deprecated, please use .root_dispatcher instead",
+                      DeprecationWarning, stacklevel=2)
+        return self.root_dispatcher

crank/objectdispatcher.py

@@ -0,0 +1,193 @@
+"""
+This is the main dispatcher module.
+
+Dispatch works as follows:
+Start at the Originating dispatcher, which must
+have a _dispatch function, which defines how we move
+from dispatch object to dispatch object in the system.
+Continue following the dispatch mechanism for a given
+controller until you reach another controller with a
+_dispatch method defined.  Use the new _dispatch
+method until another controller with _dispatch defined
+or until the url has been traversed to entirety.
+
+This module also contains the standard ObjectDispatch
+class which provides the ordinary TurboGears mechanism.
+
+"""
+
+from crank.util import get_argspec, method_matches_args
+from crank.dispatcher import Dispatcher
+from webob.exc import HTTPNotFound
+from inspect import ismethod
+
+
+class ObjectDispatcher(Dispatcher):
+    """
+    Object dispatch (also "object publishing") means that each portion of the
+    URL becomes a lookup on an object.  The next part of the URL applies to the
+    next object, until you run out of URL.  Processing starts on a "Root"
+    object.
+
+    Thus, /foo/bar/baz become URL portion "foo", "bar", and "baz".  The
+    dispatch looks for the "foo" attribute on the Root URL, which returns
+    another object.  The "bar" attribute is looked for on the new object, which
+    returns another object.  The "baz" attribute is similarly looked for on
+    this object.
+
+    Dispatch does not have to be directly on attribute lookup, objects can also
+    have other methods to explain how to dispatch from them.  The search ends
+    when a decorated controller method is found.
+
+    The rules work as follows:
+
+    1) If the current object under consideration is a decorated controller
+       method, the search is ended.
+
+    2) If the current object under consideration has a "default" method, keep a
+       record of that method.  If we fail in our search, and the most recent
+       method recorded is a "default" method, then the search is ended with
+       that method returned.
+
+    3) If the current object under consideration has a "lookup" method, keep a
+       record of that method.  If we fail in our search, and the most recent
+       method recorded is a "lookup" method, then execute the "lookup" method,
+       and start the search again on the return value of that method.
+
+    4) If the URL portion exists as an attribute on the object in question,
+       start searching again on that attribute.
+
+    5) If we fail our search, try the most recent recorded methods as per 2 and
+       3.
+    """
+
+    #Change to True to allow extra params to pass thru the dispatch
+    _use_lax_params = False
+    _use_index_fallback = True
+
+    def _is_exposed(self, controller, name):
+        """Override this function to define how a controller method is
+        determined to be exposed.
+
+        :Arguments:
+          controller - controller with methods that may or may not be exposed.
+          name - name of the method that is tested.
+
+        :Returns:
+           True or None
+        """
+        return ismethod(getattr(controller, name, False))
+
+    def _perform_security_check(self, controller):
+        #xxx do this better
+        obj = getattr(controller, 'im_self', controller)
+
+        security_check = getattr(obj, '_check_security', None)
+        if security_check is not None:
+            security_check()
+
+    def _dispatch_controller(self, current_path, controller, state, remainder):
+        """
+           Essentially, this method defines what to do when we move to the next
+           layer in the url chain, if a new controller is needed.
+           If the new controller has a _dispatch method, dispatch proceeds to
+           the new controller's mechanism.
+
+           Also, this is the place where the controller is checked for
+           controller-level security.
+        """
+
+        dispatcher = getattr(controller, '_dispatch', None)
+        if dispatcher is not None:
+            state.add_controller(current_path, controller)
+            return dispatcher(state, remainder)
+        state.add_controller(current_path, controller)
+        return self._dispatch(state, remainder)
+
+    def _dispatch_first_found_default_or_lookup(self, state, remainder):
+        """
+        When the dispatch has reached the end of the tree but not found an
+        applicable method, so therefore we head back up the branches of the
+        tree until we found a method which matches with a default or lookup method.
+        """
+
+        if not state._notfound_stack:
+            if self._use_index_fallback:
+                #see if there is an index
+                current_controller = state.controller
+                method = getattr(current_controller, 'index', None)
+                if method:
+                    if method_matches_args(method, state.params, remainder, self._use_lax_params):
+                        state.set_action(current_controller.index, remainder)
+                        return state
+            raise HTTPNotFound
+        else:
+        
+            m_type, meth, m_remainder, warning = state._notfound_stack.pop()
+
+            if m_type == 'lookup':
+                new_controller, new_remainder = meth(*m_remainder)
+                state.add_controller(new_controller.__class__.__name__, new_controller)
+                dispatcher = getattr(new_controller, '_dispatch', self._dispatch)
+                r = dispatcher(state, new_remainder)
+                return r
+            elif m_type == 'default':
+                state.set_action(meth, m_remainder)
+                return state
+#        raise HTTPNotFound
+
+    def _dispatch(self, state, remainder=None):
+        """
+        This method defines how the object dispatch mechanism works, including
+        checking for security along the way.
+        """
+        current_controller = state.controller
+
+        #skip any empty urls
+        if remainder and not(remainder[0]):
+            return self._dispatch(state, remainder[1:])
+
+        self._enter_controller(state, remainder)
+
+        #we are plumb out of path, check for index
+        if not remainder:
+            if self._is_exposed(current_controller, 'index') and \
+               method_matches_args(current_controller.index, state.params, remainder, self._use_lax_params):
+                state.set_action(current_controller.index, remainder)
+                return state
+            #if there is no index, head up the tree
+            #to see if there is a default or lookup method we can use
+            return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+
+        current_path = state.translate_path_piece(remainder[0])
+        current_args = remainder[1:]
+
+        #an exposed method matching the path is found
+        if self._is_exposed(current_controller, current_path):
+            #check to see if the argspec jives
+            controller = getattr(current_controller, current_path)
+            if method_matches_args(controller, state.params, current_args, self._use_lax_params):
+                state.set_action(controller, current_args)
+                return state
+
+        #another controller is found
+        current_controller = getattr(current_controller, current_path, None)
+        if current_controller is not None:
+            return self._dispatch_controller(current_path, current_controller,
+                                             state, current_args)
+
+        #dispatch not found
+        return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+    def _enter_controller(self, state, remainder):
+        '''Checks security and pushes any notfound (lookup or default) handlers
+        onto the stack
+        '''
+        current_controller = state.controller
+        self._perform_security_check(current_controller)
+        if hasattr(current_controller, '_lookup') and self._is_exposed(current_controller, '_lookup'):
+            state._notfound_stack.append(('lookup', current_controller._lookup, remainder, None))
+        if hasattr(current_controller, '_default') and self._is_exposed(current_controller, '_default'):
+            state._notfound_stack.append(('default', current_controller._default, remainder, None))
+            

crank/restdispatcher.py

@@ -0,0 +1,235 @@
+"""
+This module contains the RestDispatcher implementation
+
+Rest controller provides a RESTful dispatch mechanism, and
+combines controller decoration for TG-Controller behavior.
+"""
+from inspect import ismethod
+from webob.exc import HTTPBadRequest, HTTPMethodNotAllowed
+from crank.util import get_argspec, method_matches_args
+from crank.objectdispatcher import ObjectDispatcher
+
+
+class RestDispatcher(ObjectDispatcher):
+    """Defines a restful interface for a set of HTTP verbs.
+    Please see RestController for a rundown of the controller
+    methods used.
+    """
+
+    def _find_first_exposed(self, controller, methods):
+        for method in methods:
+            if self._is_exposed(controller, method):
+                return getattr(controller, method)
+
+    def _handle_put_or_post(self, http_method, state, remainder):
+        current_controller = state.controller
+        if remainder:
+            current_path = remainder[0]
+            if self._is_exposed(current_controller, current_path):
+                state.set_action(getattr(current_controller, current_path), remainder[1:])
+                return state
+
+            if self._is_controller(current_controller, current_path):
+                current_controller = getattr(current_controller, current_path)
+                return self._dispatch_controller(current_path, current_controller, state, remainder[1:])
+
+        method = self._find_first_exposed(current_controller, [http_method])
+        if method:
+            if method_matches_args(method, state.params, remainder, self._use_lax_params):
+                state.set_action(method, remainder)
+                return state
+            raise HTTPBadRequest
+
+        return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+    def _handle_delete(self, http_method, state, remainder):
+        current_controller = state.controller
+        method = self._find_first_exposed(current_controller, ('post_delete', 'delete'))
+
+        if method and method_matches_args(method, state.params, remainder, self._use_lax_params):
+            state.set_action(method, remainder)
+            return state
+
+        #you may not send a delete request to a non-delete function
+        if remainder and self._is_exposed(current_controller, remainder[0]):
+            raise HTTPMethodNotAllowed
+
+        # there might be a sub-controller with a delete method, let's go see
+        if remainder:
+            sub_controller = getattr(current_controller, remainder[0], None)
+            if sub_controller:
+                remainder = remainder[1:]
+                r = self._dispatch_controller(remainder[0], sub_controller, state, remainder)
+                if r:
+                    return r
+        return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+    def _check_for_sub_controllers(self, state, remainder):
+        current_controller = state.controller
+        method = None
+        for find in ('get_one', 'get'):
+            if hasattr(current_controller, find):
+                method = find
+                break
+
+        if method is None:
+            return
+
+        fixed_args, var_args, kws, kw_args = get_argspec(getattr(current_controller, method))
+        fixed_arg_length = len(fixed_args)
+        if var_args:
+            for i, item in enumerate(remainder):
+                item = state.translate_path_piece(item)
+                if hasattr(current_controller, item) and self._is_controller(current_controller, item):
+                    current_controller = getattr(current_controller, item)
+                    state.add_routing_args(item, remainder[:i], fixed_args, var_args)
+                    return self._dispatch_controller(item, current_controller, state, remainder[i+1:])
+        elif fixed_arg_length< len(remainder) and hasattr(current_controller, remainder[fixed_arg_length]):
+            item = state.translate_path_piece(remainder[fixed_arg_length])
+            if hasattr(current_controller, item):
+                if self._is_controller(current_controller, item):
+                    state.add_routing_args(item, remainder, fixed_args, var_args)
+                    return self._dispatch_controller(item, getattr(current_controller, item),
+                                                     state, remainder[fixed_arg_length+1:])
+
+    def _handle_delete_edit_or_new(self, state, remainder):
+        method_name = remainder[-1]
+        if method_name not in ('new', 'edit', 'delete'):
+            return
+
+        if method_name == 'delete':
+            method_name = 'get_delete'
+
+        current_controller = state.controller
+
+        if self._is_exposed(current_controller, method_name):
+            method = getattr(current_controller, method_name)
+            new_remainder = remainder[:-1]
+            if method and method_matches_args(method, state.params, new_remainder, self._use_lax_params):
+                state.set_action(method, new_remainder)
+                return state
+
+    def _handle_custom_get(self, state, remainder):
+        controller = state.controller
+        method_name = remainder[-1]
+
+        current_controller = state.controller
+
+        get_method = self._find_first_exposed(current_controller, (f'get_{method_name}', method_name))
+        if get_method:
+            new_remainder = remainder[:-1]
+            if method_matches_args(get_method, state.params, new_remainder, self._use_lax_params):
+                state.set_action(get_method, new_remainder)
+                return state
+
+    def _handle_custom_method(self, method, state, remainder):
+        current_controller = state.controller
+        method_name = method
+        http_method = state.request.method
+        method = self._find_first_exposed(current_controller, (f'{http_method}_{method_name}', method_name, f'post_{method_name}'))
+
+        if method and method_matches_args(method, state.params, remainder, self._use_lax_params):
+            state.set_action(method, remainder)
+            return state
+
+        # there might be a sub-controller with a custom method, let's go see
+        if remainder:
+            sub_controller = getattr(current_controller, remainder[0], None)
+            if sub_controller:
+                current = remainder[0]
+                remainder = remainder[1:]
+                r = self._dispatch_controller(current, sub_controller, state, remainder)
+                if r:
+                    return r
+        return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+    def _handle_get(self, method, state, remainder):
+        current_controller = state.controller
+        if not remainder:
+            method = self._find_first_exposed(current_controller, ('get_all', 'get'))
+            if method:
+                state.set_action(method, remainder)
+                return state
+            if self._is_exposed(current_controller, 'get_one'):
+                method = current_controller.get_one
+                if method and method_matches_args(method, state.params, remainder, self._use_lax_params):
+                    state.set_action(method, remainder)
+                    return state
+            return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+        #test for "delete", "edit" or "new"
+        r = self._handle_delete_edit_or_new(state, remainder)
+        if r is not None:
+            return r
+
+        #test for custom REST-like attribute
+        r = self._handle_custom_get(state, remainder)
+        if r is not None:
+            return r
+
+        current_path = state.translate_path_piece(remainder[0])
+        if self._is_exposed(current_controller, current_path):
+            state.set_action(getattr(current_controller, current_path), remainder[1:])
+            return state
+
+        if self._is_controller(current_controller, current_path):
+            current_controller = getattr(current_controller, current_path)
+            return self._dispatch_controller(current_path, current_controller, state, remainder[1:])
+
+        method = self._find_first_exposed(current_controller, ('get_one', 'get'))
+        if method and method_matches_args(method, state.params, remainder, self._use_lax_params):
+            state.set_action(method, remainder)
+            return state
+
+        return self._dispatch_first_found_default_or_lookup(state, remainder)
+
+    _handler_lookup = {
+        'put':_handle_put_or_post,
+        'post':_handle_put_or_post,
+        'patch':_handle_put_or_post,
+        'delete':_handle_delete,
+        'get':_handle_get,
+        }
+
+    def _is_controller(self, controller, name):
+        """
+        Override this function to define how an object is determined to be a
+        controller.
+        """
+        method = getattr(controller, name, None)
+        if method is not None:
+            return not ismethod(method)
+
+    def _dispatch(self, state, remainder=None):
+        """
+        This method defines how the object dispatch mechanism works, including
+        checking for security along the way.
+        """
+        self._enter_controller(state, remainder)
+
+        # log.debug(f'Entering dispatch for remainder: {remainder} in controller {self}')
+        if not hasattr(state, 'http_method'):
+            method = state.request.method.lower()
+            params = state.params
+
+            #conventional hack for handling methods which are not supported by most browsers
+            request_method = params.pop('_method', None)
+            if request_method:
+                request_method = request_method.lower()
+                #make certain that DELETE and PUT requests are not sent with GET
+                if method == 'get' and request_method == 'put':
+                    raise HTTPMethodNotAllowed
+                if method == 'get' and request_method == 'delete':
+                    raise HTTPMethodNotAllowed
+                method = request_method
+            state.http_method = method
+
+        r = self._check_for_sub_controllers(state, remainder)
+        if r is not None:
+            return r
+
+        if state.http_method in self._handler_lookup.keys():
+            r = self._handler_lookup[state.http_method](self, state.http_method, state, remainder)
+        else:
+            r = self._handle_custom_method(state.http_method, state, remainder)
+        return r

crank/util.py

@@ -0,0 +1,285 @@
+"""
+Utilities used by crank.
+
+Copyright (c) Chrispther Perkins
+MIT License
+"""
+
+import collections
+import string
+import inspect
+import warnings
+
+__all__ = [
+    'get_argspec', 'get_params_with_argspec', 'remove_argspec_params_from_params',
+    'method_matches_args', 'Path', 'default_path_translator', 'flatten_arguments'
+]
+
+
+class _NotFound:
+    pass
+
+
+def _getargspec(func):
+    sig = inspect.signature(func)
+    args = [
+        p.name for p in sig.parameters.values()
+        if p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+    ]
+    varargs = [
+        p.name for p in sig.parameters.values()
+        if p.kind == inspect.Parameter.VAR_POSITIONAL
+    ]
+    varargs = varargs[0] if varargs else None
+    varkw = [
+        p.name for p in sig.parameters.values()
+        if p.kind == inspect.Parameter.VAR_KEYWORD
+    ]
+    varkw = varkw[0] if varkw else None
+    defaults = tuple((
+        p.default for p in sig.parameters.values()
+        if p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD and p.default is not p.empty
+    )) or None
+    return args, varargs, varkw, defaults
+
+
+_cached_argspecs = {}
+def get_argspec(func):
+    im_func = getattr(func, '__func__', func)
+
+    if hasattr(im_func, '__wrapped__'):
+        # Cope with decorated functions if they properly updated __wrapped__
+        im_func = im_func.__wrapped__
+
+    try:
+        argspec = _cached_argspecs[im_func]
+    except KeyError:
+        spec = _getargspec(im_func)
+        argvals = spec[3]
+
+        # this is a work around for a crappy api choice in getargspec
+        if argvals is None:
+            argvals = []
+
+        argspec = _cached_argspecs[im_func] = (spec[0][1:], spec[1], spec[2], argvals)
+
+    return argspec
+
+
+def get_params_with_argspec(func, params, remainder):
+    argvars, var_args, argkws, argvals = get_argspec(func)
+
+    if argvars and remainder:
+        params = params.copy()
+        remainder_len = len(remainder)
+        for i, var in enumerate(argvars):
+            if i >= remainder_len:
+                break
+            params[var] = remainder[i]
+    return params
+
+
+def remove_argspec_params_from_params(func, params, remainder):
+    """Remove parameters from the argument list that are
+       not named parameters
+       Returns: params, remainder"""
+
+    warnings.warn("remove_argspec_params_from_params is deprecated and will be removed",
+                  DeprecationWarning, stacklevel=2)
+
+    # figure out which of the vars in the argspec are required
+    argvars, var_args, argkws, argvals = get_argspec(func)
+
+    # if there are no required variables, or the remainder is none, we
+    # have nothing to do
+    if not argvars or not remainder:
+        return params, remainder
+
+    required_vars = argvars
+    optional_vars = []
+    if argvals:
+        required_vars = argvars[:-len(argvals)]
+        optional_vars = argvars[-len(argvals):]
+
+    # make a copy of the params so that we don't modify the existing one
+    params = params.copy()
+
+    # replace the existing required variables with the values that come in
+    # from params. these could be the parameters that come off of validation.
+    remainder = list(remainder)
+    remainder_len = len(remainder)
+    for i, var in enumerate(required_vars):
+        val = params.get(var, _NotFound)
+        if val is not _NotFound:
+            if i < remainder_len:
+                remainder[i] = val
+            else:
+                remainder.append(val)
+            del params[var]
+
+    # remove the optional positional variables (remainder) from the named parameters
+    # until we run out of remainder, that is, avoid creating duplicate parameters
+    for i, (original, var) in enumerate(zip(remainder[len(required_vars):],optional_vars)):
+        if var in params:
+            remainder[ len(required_vars)+i ] = params[var]
+            del params[var]
+
+    return params, tuple(remainder)
+
+
+def flatten_arguments(func, params, remainder, keep_unexpected=False):
+    """Returns all the arguments for a function as positional parameters.
+
+    Keyword arguments are returned only if the function supports **kwargs
+    """
+    if remainder is None:
+        remainder = tuple()
+
+    # figure out which of the vars in the argspec are required
+    positional_args, varargs, argkws, default_arg_values = get_argspec(func)
+
+    if not params:
+        if varargs:
+            # If all arguments are already positional and we accept variable arguments
+            # we have nothing to do, params are already flattened and there are no
+            # extra arguments
+            return tuple(remainder), params
+        else:
+            # Otherwise arguments are already positional, but there are extra arguments
+            # so we just throw away the extra arguments
+            return tuple(remainder[:len(positional_args)]), params
+
+    args = []
+    kwargs = params.copy()
+
+    # Gather positional arguments
+    for idx, argname in enumerate(positional_args):
+        val = kwargs.pop(argname, _NotFound)
+        if val is not _NotFound:
+            args.append(val)
+        elif idx < len(remainder):
+            args.append(remainder[idx])
+        else:
+            # if argument is not available look for default value or just stop
+            # as we are actually missing an argument
+            try:
+                default_arg_idx = idx - (len(positional_args) - len(default_arg_values))
+                if default_arg_idx < 0:
+                    raise IndexError()
+                args.append(default_arg_values[default_arg_idx])
+            except IndexError:
+                raise TypeError(f'{func} missing "{argname}" required argument')
+
+    if varargs:
+        args.extend(remainder[len(args):])
+
+    if not argkws:
+        kwargs = {}
+
+    return tuple(args), kwargs
+
+
+def method_matches_args(method, params, remainder, lax_params=False):
+    """
+    This method matches the params from the request along with the remainder to the
+    method's function signiture.  If the two jive, it returns true.
+
+    It is very likely that this method would go into ObjectDispatch in the future.
+    """
+    argvars, ovar_args, argkws, argvals = get_argspec(method)
+
+    required_vars = argvars
+    if argvals:
+        required_vars = argvars[:-len(argvals)]
+
+    params = params.copy()
+
+    #remove the appropriate remainder quotient
+    if len(remainder)<len(required_vars):
+        #pull the first few off with the remainder
+        required_vars = required_vars[len(remainder):]
+    else:
+        #there is more of a remainder than there is non optional vars
+        required_vars = []
+
+    #remove vars found in the params list
+    for var in required_vars[:]:
+        if var in params:
+            required_vars.pop(0)
+            # remove the param from the params so when we see if
+            # there are params that arent in the non-required vars we
+            # can evaluate properly
+            del params[var]
+        else:
+            break
+
+    #remove params that have a default value
+    vars_with_default = argvars[len(argvars)-len(argvals):]
+    for var in vars_with_default:
+        if var in params:
+            del params[var]
+
+    #make sure no params exist if keyword argumnts are missing
+    if not lax_params and argkws is None and params:
+        return False
+
+    #make sure all of the non-optional-vars are there
+    if not required_vars:
+        #there are more args in the remainder than are available in the argspec
+        if len(argvars)<len(remainder) and not ovar_args:
+            return False
+        return True
+
+
+    return False
+
+
+translation_string = str.maketrans(string.punctuation,
+                                       '_' * len(string.punctuation))
+
+
+def default_path_translator(path_piece):
+    return path_piece.translate(translation_string)
+
+
+def noop_translation(path_piece):
+    return path_piece
+
+
+class Path(collections.deque):
+    def __init__(self, value=None, separator='/'):
+        self.separator = separator
+
+        super(Path, self).__init__()
+
+        if value is not None:
+            self._assign(value)
+
+    def _assign(self, value):
+        separator = self.separator
+        self.clear()
+
+        if isinstance(value, str):
+            self.extend(value.split(separator))
+            return
+
+        self.extend(value)
+
+    def __set__(self, obj, value):
+        self._assign(value)
+
+    def __str__(self):
+        return str(self.separator).join(self)
+
+    def __repr__(self):
+        return f"<Path [{', '.join(repr(p) for p in self)}]>"
+
+    def __eq__(self, other):
+        return type(other)(self) == other
+
+    def __getitem__(self, i):
+        try:
+            return super(Path, self).__getitem__(i)
+
+        except TypeError:
+            return Path([self[i] for i in range(*i.indices(len(self)))])

crank-0.9.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: crank
+Version: 0.9.0
+Summary: Generalization of dispatch mechanism for use across frameworks
+Author-email: Christopher Perkins <chris@percious.com>
+License: MIT
+Project-URL: Homepage, https://github.com/TurboGears/crank
+Project-URL: Documentation, https://github.com/TurboGears/crank
+Project-URL: Repository, https://github.com/TurboGears/crank
+Project-URL: Issues, https://github.com/TurboGears/crank/issues
+Keywords: dispatch,web,turbogears
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: webob>=1.8.0
+Provides-Extra: testing
+Requires-Dist: pytest>=7.0; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Dynamic: license-file
+
+Crank
+==============
+
+.. image:: https://travis-ci.org/TurboGears/crank.png
+    :target: https://travis-ci.org/TurboGears/crank
+
+.. image:: https://coveralls.io/repos/TurboGears/crank/badge.png
+    :target: https://coveralls.io/r/TurboGears/crank
+
+Generalized Object based Dispatch mechanism for use across frameworks.
+
+License
+-----------
+
+Crank is licensed under an MIT-style license (see LICENSE.txt).
+Other incorporated projects may be licensed under different licenses.
+All licenses allow for non-commercial and commercial use.
+
+ChangeLog
+--------------
+
+0.9.0
+~~~~~
+
+- Codebase modernized, dropped Python 2 support (now requires Python >= 3.10)
+- Raise Bad Request on missing REST parameters
+
+0.8.1
+~~~~~
+
+- Improved support for decorated functions that provide ``__wrapped__``.
+
+0.8.0
+~~~~~
+
+- New DispatchState api ( See http://turbogears.readthedocs.io/en/tg2.3.8/reference/classes.html#crank.dispatchstate.DispatchState )
+- Support for flattening function arguments through ``crank.utils.flatten_arguments``
+- ``crank.utils.remove_argspec_params_from_params`` deprecated
+
+0.7.3
+~~~~~~~~~~~~~
+
+- Add initial support for Python 3.5
+
+0.7.2
+~~~~~~~~~~~~~
+
+- Fix issue with parameters with ``None`` value when preparing positional arguments for dispatch.
+
+0.7.1
+~~~~~~~~~~~~~
+
+- Fix issue that in some cased caused ``_lookup`` to not be called for ``RestDispatcher``
+- Speedup permission checks, in some conditions they were performed twice
+- Python 3.4 is now officially supported

crank-0.9.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+crank/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+crank/dispatcher.py,sha256=i6xsMB79CA6Gn_YAldhle1n1oQzjzoC7zit40fpGUN4,1196
+crank/dispatchstate.py,sha256=RpLGz-JF4vHk4GnmKJu3WZGOdY3DlO9W-y9HkYCb-4c,7609
+crank/objectdispatcher.py,sha256=L-Z19A9qY5ORvyRp05-niZgzcuOebnSv_IRGPwzIRJA,8164
+crank/restdispatcher.py,sha256=m-JzFM1SYkcDvP-_uqsDNln8627fLtImyvB65QOBAnM,10273
+crank/util.py,sha256=59GHEgkJYYUyT5Jh-34O2mPZbJb1YqOLgIERBlYafdw,8750
+crank-0.9.0.dist-info/licenses/LICENSE.txt,sha256=hYRyzYJZjidfFZnj2kQiExM9B93fPTpCj5UX5bIQdD0,1163
+crank-0.9.0.dist-info/METADATA,sha256=pWqHbWZtgaxq6IHXc_Nh1YEzh2pxPhQydBSDLv2T4v4,2790
+crank-0.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+crank-0.9.0.dist-info/top_level.txt,sha256=4RokySWfreNx6O4vFdnlK5zvZAUWSAkxpA1xodRWg3U,6
+crank-0.9.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+crank-0.9.0.dist-info/RECORD,,

crank-0.9.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

crank-0.9.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,10 @@
+This is the MIT license:
+http://www.opensource.org/licenses/mit-license.php
+
+Copyright (c) 2010-2013 Christopher Perkins and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

crank-0.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+crank

crank-0.9.0.dist-info/zip-safe

@@ -0,0 +1 @@
+