omlish 0.0.0.dev117__py3-none-any.whl → 0.0.0.dev119__py3-none-any.whl

omlish/specs/jmespath/functions.py

@@ -1,55 +1,133 @@
+import dataclasses as dc
 import inspect
 import json
 import math
 import re
+import typing as ta
 
-from . import exceptions
-
-
-# python types -> jmespath types
-TYPES_MAP = {
-    'bool': 'boolean',
-    'list': 'array',
-    'dict': 'object',
-    'NoneType': 'null',
-    'unicode': 'string',
-    'str': 'string',
-    'float': 'number',
-    'int': 'number',
-    'long': 'number',
-    'OrderedDict': 'object',
-    '_Projection': 'array',
-    '_Expression': 'expref',
+from .exceptions import ArityError
+from .exceptions import JmespathError
+from .exceptions import JmespathTypeError
+from .exceptions import JmespathValueError
+from .exceptions import UnknownFunctionError
+from .exceptions import VariadicArityError
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+JmespathType: ta.TypeAlias = ta.Literal[
+    'boolean',
+    'array',
+    'object',
+    'null',
+    'string',
+    'number',
+    'expref',
+]
+
+
+PyType = ta.NewType('PyType', str)
+
+
+def pytype_of(o: ta.Any) -> PyType:
+    return PyType(type(o).__name__)
+
+
+TYPES_MAP: ta.Mapping[PyType, JmespathType] = {
+    PyType('bool'): 'boolean',
+    PyType('list'): 'array',
+    PyType('dict'): 'object',
+    PyType('NoneType'): 'null',
+    PyType('unicode'): 'string',
+    PyType('str'): 'string',
+    PyType('float'): 'number',
+    PyType('int'): 'number',
+    PyType('long'): 'number',
+    PyType('OrderedDict'): 'object',
+    PyType('_Projection'): 'array',
+    PyType('_Expression'): 'expref',
 }
 
 
-# jmespath types -> python types
-REVERSE_TYPES_MAP = {
-    'boolean': ('bool',),
-    'array': ('list', '_Projection'),
-    'object': ('dict', 'OrderedDict'),
-    'null': ('NoneType',),
-    'string': ('unicode', 'str'),
-    'number': ('float', 'int', 'long'),
-    'expref': ('_Expression',),
+REVERSE_TYPES_MAP: ta.Mapping[JmespathType, ta.Sequence[PyType]] = {
+    'boolean': [
+        PyType('bool'),
+    ],
+    'array': [
+        PyType('list'),
+        PyType('_Projection'),
+    ],
+    'object': [
+        PyType('dict'),
+        PyType('OrderedDict'),
+    ],
+    'null': [
+        PyType('NoneType'),
+    ],
+    'string': [
+        PyType('unicode'),
+        PyType('str'),
+    ],
+    'number': [
+        PyType('float'),
+        PyType('int'),
+    ],
+    'expref': [
+        PyType('_Expression'),
+    ],
 }
 
 
-def signature(*arguments):
+ArrayParameterType: ta.TypeAlias = ta.Literal[
+    'array-string',
+    'array-number',
+]
+
+ParameterType: ta.TypeAlias = JmespathType | ArrayParameterType
+
+
+class Parameter(ta.TypedDict):
+    type: ta.NotRequired[ParameterType]
+    types: ta.NotRequired[ta.Sequence[ParameterType]]
+    variadic: ta.NotRequired[bool]
+    optional: ta.NotRequired[bool]
+
+
+Signature: ta.TypeAlias = ta.Sequence[Parameter]
+
+
+@dc.dataclass(frozen=True)
+class Function:
+    function: ta.Callable
+    signature: Signature
+
+
+def signature(*params: Parameter):
     def _record_signature(func):
-        func.signature = arguments
+        func.signature = params
         return func
     return _record_signature
 
 
-class FunctionRegistry(type):
-    def __init__(cls, name, bases, attrs):
-        cls._populate_function_table()
+class Functions(ta.Protocol):
+    def call_function(self, function_name, resolved_args): ...
 
-        super().__init__(name, bases, attrs)
 
-    def _populate_function_table(cls):
-        function_table = {}
+class FunctionsClass:
+    _function_table: ta.ClassVar[ta.Mapping[str, Function]] = {}  # noqa
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        cls._populate_function_table()
+
+    @classmethod
+    def _populate_function_table(cls) -> None:
+        function_table: dict[str, Function] = {}
 
         # Any method with a @signature decorator that also starts with "_func_" is registered as a function.
         # _func_max_by -> max_by function.
@@ -57,147 +135,195 @@ class FunctionRegistry(type):
             if not name.startswith('_func_'):
                 continue
 
-            signature = getattr(method, 'signature', None)
-            if signature is not None:
-                function_table[name[6:]] = {
-                    'function': method,
-                    'signature': signature,
-                }
-
-        cls.FUNCTION_TABLE = function_table
-
+            sig = getattr(method, 'signature', None)
+            if sig is not None:
+                function_table[name[6:]] = Function(
+                    method,
+                    sig,
+                )
 
-class Functions(metaclass=FunctionRegistry):
+        cls._function_table = function_table
 
-    FUNCTION_TABLE: dict = {}  # noqa
+    #
 
-    def call_function(self, function_name, resolved_args):
+    def call_function(self, function_name: str, resolved_args: ta.Sequence[ta.Any]) -> ta.Any:
         try:
-            spec = self.FUNCTION_TABLE[function_name]
+            spec = self._function_table[function_name]
         except KeyError:
-            raise exceptions.UnknownFunctionError(f'Unknown function: {function_name}()')  # noqa
-
-        function = spec['function']
-        signature = spec['signature']
+            raise UnknownFunctionError(f'Unknown function: {function_name}()')  # noqa
 
-        self._validate_arguments(resolved_args, signature, function_name)
+        self._validate_arguments(resolved_args, spec.signature, function_name)
+        return spec.function.__get__(self, self.__class__)(*resolved_args)  # noqa
 
-        return function(self, *resolved_args)
-
-    def _validate_arguments(self, args, signature, function_name):
-        if len(signature) == 0:
-            return self._type_check(args, signature, function_name)
+    def _validate_arguments(self, args: ta.Sequence[ta.Any], sig: Signature, function_name: str) -> None:
+        if len(sig) == 0:
+            self._type_check(args, sig, function_name)
+            return
 
         required_arguments_count = len([
-            param for param in signature if param and (not param.get('optional') or not param['optional'])
+            param for param in sig if param and (not param.get('optional') or not param['optional'])
         ])
         optional_arguments_count = len([
-            param for param in signature if param and param.get('optional') and param['optional']
+            param for param in sig if param and param.get('optional') and param['optional']
         ])
-        has_variadic = signature[-1].get('variadic') if signature is not None else False
+        has_variadic = sig[-1].get('variadic') if sig is not None else False
 
         if has_variadic:
-            if len(args) < len(signature):
-                raise exceptions.VariadicArityError(len(signature), len(args), function_name)
+            if len(args) < len(sig):
+                raise VariadicArityError(len(sig), len(args), function_name)
 
         elif optional_arguments_count > 0:
             if (
                     len(args) < required_arguments_count or
                     len(args) > (required_arguments_count + optional_arguments_count)
             ):
-                raise exceptions.ArityError(len(signature), len(args), function_name)
+                raise ArityError(len(sig), len(args), function_name)
+
         elif len(args) != required_arguments_count:
-            raise exceptions.ArityError(len(signature), len(args), function_name)
+            raise ArityError(len(sig), len(args), function_name)
 
-        return self._type_check(args, signature, function_name)
+        self._type_check(args, sig, function_name)
 
-    def _type_check(self, actual, signature, function_name):
-        for i in range(min(len(signature), len(actual))):
-            allowed_types = self._get_allowed_types_from_signature(signature[i])
+    def _type_check(self, actual: ta.Sequence[ta.Any], sig: Signature, function_name: str) -> None:
+        for i in range(min(len(sig), len(actual))):
+            allowed_types = self._get_allowed_types_from_signature(sig[i])
             if allowed_types:
                 self._type_check_single(actual[i], allowed_types, function_name)
 
-    def _type_check_single(self, current, types, function_name):
+    def _get_allowed_types_from_signature(self, spec: Parameter) -> ta.Sequence[ParameterType]:
+        # signature supports monotype {'type': 'type-name'}## or multiple types {'types': ['type1-name', 'type2-name']}
+        return [
+            *([st] if (st := spec.get('type')) is not None else []),
+            *spec.get('types', []),
+        ]
+
+    def _type_check_single(self, current: ta.Any, types: ta.Sequence[ParameterType], function_name: str) -> None:
         # Type checking involves checking the top level type, and in the case of arrays, potentially checking the types
         # of each element.
-        allowed_types, allowed_subtypes = self._get_allowed_pytypes(types)
+        allowed_types, allowed_element_types = self._get_allowed_pytypes(types)
 
         # We're not using isinstance() on purpose. The type model for jmespath does not map 1-1 with python types
         # (booleans are considered integers in python for example).
-        actual_typename = type(current).__name__
-        if actual_typename not in allowed_types:
-            raise exceptions.JmespathTypeError(
-                function_name, current,
-                self._convert_to_jmespath_type(actual_typename), types)
+        pytype = pytype_of(current)
+        if pytype not in allowed_types:
+            raise JmespathTypeError(
+                function_name,
+                current,
+                self._convert_to_jmespath_type(pytype),
+                types,
+            )
 
         # If we're dealing with a list type, we can have additional restrictions on the type of the list elements (for
         # example a function can require a list of numbers or a list of strings). Arrays are the only types that can
-        # have subtypes.
-        if allowed_subtypes:
-            self._subtype_check(current, allowed_subtypes, types, function_name)
+        # have element types.
+        if allowed_element_types:
+            self._element_type_check(
+                current,
+                allowed_element_types,
+                types,
+                function_name,
+            )
 
-    def _get_allowed_types_from_signature(self, spec):
-        # signature supports monotype {'type': 'type-name'}## or multiple types {'types': ['type1-name', 'type2-name']}
-        if spec.get('type'):
-            spec.update({'types': [spec.get('type')]})
-        return spec.get('types')
+    class _AllowedPytypes(ta.NamedTuple):
+        types: ta.Sequence[PyType]
+        element_types: ta.Sequence[ta.Sequence[PyType]]
 
-    def _get_allowed_pytypes(self, types):
+    def _get_allowed_pytypes(self, types: ta.Iterable[ParameterType]) -> _AllowedPytypes:
         allowed_types: list = []
-        allowed_subtypes: list = []
+        allowed_element_types: list = []
 
+        t: str
         for t in types:
-            type_ = t.split('-', 1)
-            if len(type_) == 2:
-                type_, subtype = type_
-                allowed_subtypes.append(REVERSE_TYPES_MAP[subtype])
-            else:
-                type_ = type_[0]
+            if '-' in t:
+                t, et = t.split('-', 1)
+                allowed_element_types.append(REVERSE_TYPES_MAP[ta.cast(JmespathType, et)])
 
-            allowed_types.extend(REVERSE_TYPES_MAP[type_])
+            allowed_types.extend(REVERSE_TYPES_MAP[ta.cast(JmespathType, t)])
 
-        return allowed_types, allowed_subtypes
+        return FunctionsClass._AllowedPytypes(allowed_types, allowed_element_types)
 
-    def _subtype_check(self, current, allowed_subtypes, types, function_name):
-        if len(allowed_subtypes) == 1:
+    def _element_type_check(
+            self,
+            current: ta.Sequence[ta.Any],
+            allowed_element_types: ta.Sequence[ta.Sequence[PyType]],
+            types: ta.Sequence[ParameterType],
+            function_name: str,
+    ) -> None:
+        if len(allowed_element_types) == 1:
             # The easy case, we know up front what type we need to validate.
-            allowed_subtypes = allowed_subtypes[0]
+            ets = allowed_element_types[0]
             for element in current:
-                actual_typename = type(element).__name__
-                if actual_typename not in allowed_subtypes:
-                    raise exceptions.JmespathTypeError(function_name, element, actual_typename, types)
-
-        elif len(allowed_subtypes) > 1 and current:
-            # Dynamic type validation.  Based on the first type we see, we validate that the remaining types match.
-            first = type(current[0]).__name__
-            for subtypes in allowed_subtypes:
-                if first in subtypes:
-                    allowed = subtypes
+                pytype = pytype_of(element)
+                if pytype not in ets:
+                    raise JmespathTypeError(function_name, element, pytype, types)
+
+        elif len(allowed_element_types) > 1 and current:
+            # Dynamic type validation. Based on the first type we see, we validate that the remaining types match.
+            first = pytype_of(current[0])
+            for element_types in allowed_element_types:
+                if first in element_types:
+                    allowed = element_types
                     break
             else:
-                raise exceptions.JmespathTypeError(function_name, current[0], first, types)
+                raise JmespathTypeError(function_name, current[0], first, types)
 
             for element in current:
-                actual_typename = type(element).__name__
-                if actual_typename not in allowed:
-                    raise exceptions.JmespathTypeError(function_name, element, actual_typename, types)
+                pytype = pytype_of(element)
+                if pytype not in allowed:
+                    raise JmespathTypeError(function_name, element, pytype, types)
 
-    @signature({'types': ['number']})
-    def _func_abs(self, arg):
-        return abs(arg)
+    #
 
-    @signature({'types': ['string']})
-    def _func_lower(self, arg):
-        return arg.lower()
+    def _convert_to_jmespath_type(self, pytype: PyType) -> JmespathType | ta.Literal['unknown']:
+        return TYPES_MAP.get(pytype, 'unknown')
 
-    @signature({'types': ['string']})
-    def _func_upper(self, arg):
-        return arg.upper()
+    def _ensure_integer(
+            self,
+            func_name: str,
+            param_name: str,
+            param_value: ta.Any,
+    ) -> None:
+        if param_value is not None:
+            if int(param_value) != param_value:
+                raise JmespathValueError(
+                    func_name,
+                    param_value,
+                    'integer',
+                )
 
-    @signature({'types': ['array-number']})
-    def _func_avg(self, arg):
-        if arg:
-            return sum(arg) / len(arg)
+    def _ensure_non_negative_integer(
+            self,
+            func_name: str,
+            param_name: str,
+            param_value: ta.Any,
+    ) -> None:
+        if param_value is not None:
+            if int(param_value) != param_value or int(param_value) < 0:
+                raise JmespathValueError(
+                    func_name,
+                    param_name,
+                    'non-negative integer',
+                )
+
+
+##
+
+
+class TypeFunctions(FunctionsClass):
+    @signature({'types': []})
+    def _func_type(self, arg):
+        if isinstance(arg, str):
+            return 'string'
+        elif isinstance(arg, bool):
+            return 'boolean'
+        elif isinstance(arg, list):
+            return 'array'
+        elif isinstance(arg, dict):
+            return 'object'
+        elif isinstance(arg, (float, int)):
+            return 'number'
+        elif arg is None:
+            return 'null'
         else:
             return None
 
@@ -242,22 +368,20 @@ class Functions(metaclass=FunctionRegistry):
                 except ValueError:
                     return None
 
+
+class ContainerFunctions(FunctionsClass):
     @signature({'types': ['array', 'string']}, {'types': [], 'variadic': True})
     def _func_contains(self, subject, *searches):
         return any(search in subject for search in searches)
 
+    @signature({'types': ['array', 'string']}, {'types': [], 'variadic': True})
+    def _func_in(self, subject, *searches):
+        return subject in searches
+
     @signature({'types': ['string', 'array', 'object']})
     def _func_length(self, arg):
         return len(arg)
 
-    @signature({'types': ['string']}, {'types': ['string']})
-    def _func_ends_with(self, search, suffix):
-        return search.endswith(suffix)
-
-    @signature({'types': ['string']}, {'types': ['string']})
-    def _func_starts_with(self, search, suffix):
-        return search.startswith(suffix)
-
     @signature({'types': ['array', 'string']})
     def _func_reverse(self, arg):
         if isinstance(arg, str):
@@ -265,6 +389,41 @@ class Functions(metaclass=FunctionRegistry):
         else:
             return list(reversed(arg))
 
+    @signature({'types': ['expref']}, {'types': ['array']})
+    def _func_map(self, expref, arg):
+        result = []
+        for element in arg:
+            result.append(expref.visit(expref.expression, element))
+        return result
+
+    @signature({'types': ['object'], 'variadic': True})
+    def _func_merge(self, *arguments):
+        merged = {}
+        for arg in arguments:
+            merged.update(arg)
+        return merged
+
+    @signature({'types': ['array-string', 'array-number']})
+    def _func_sort(self, arg):
+        return sorted(arg)
+
+    @signature({'types': ['array'], 'variadic': True})
+    def _func_zip(self, *arguments):
+        return [list(t) for t in zip(*arguments)]
+
+
+class NumberFunctions(FunctionsClass):
+    @signature({'types': ['number']})
+    def _func_abs(self, arg):
+        return abs(arg)
+
+    @signature({'types': ['array-number']})
+    def _func_avg(self, arg):
+        if arg:
+            return sum(arg) / len(arg)
+        else:
+            return None
+
     @signature({'types': ['number']})
     def _func_ceil(self, arg):
         return math.ceil(arg)
@@ -273,17 +432,6 @@ class Functions(metaclass=FunctionRegistry):
     def _func_floor(self, arg):
         return math.floor(arg)
 
-    @signature({'types': ['string']}, {'types': ['array-string']})
-    def _func_join(self, separator, array):
-        return separator.join(array)
-
-    @signature({'types': ['expref']}, {'types': ['array']})
-    def _func_map(self, expref, arg):
-        result = []
-        for element in arg:
-            result.append(expref.visit(expref.expression, element))
-        return result
-
     @signature({'types': ['array-number', 'array-string']})
     def _func_max(self, arg):
         if arg:
@@ -291,13 +439,6 @@ class Functions(metaclass=FunctionRegistry):
         else:
             return None
 
-    @signature({'types': ['object'], 'variadic': True})
-    def _func_merge(self, *arguments):
-        merged = {}
-        for arg in arguments:
-            merged.update(arg)
-        return merged
-
     @signature({'types': ['array-number', 'array-string']})
     def _func_min(self, arg):
         if arg:
@@ -305,30 +446,65 @@ class Functions(metaclass=FunctionRegistry):
         else:
             return None
 
-    @signature({'types': ['array-string', 'array-number']})
-    def _func_sort(self, arg):
-        return sorted(arg)
-
     @signature({'types': ['array-number']})
     def _func_sum(self, arg):
         return sum(arg)
 
-    @signature({'types': ['object']})
-    def _func_items(self, arg):
-        return [list(t) for t in arg.items()]
 
-    @signature({'types': ['array']})
-    def _func_from_items(self, items):
-        return dict(items)
+class StringFunctions(FunctionsClass):
+    @signature({'types': ['string']})
+    def _func_lower(self, arg):
+        return arg.lower()
 
-    @signature({'types': ['object']})
-    def _func_keys(self, arg):
-        # To be consistent with .values() should we also return the indices of a list?
-        return list(arg.keys())
+    @signature({'types': ['string']})
+    def _func_upper(self, arg):
+        return arg.upper()
 
-    @signature({'types': ['object']})
-    def _func_values(self, arg):
-        return list(arg.values())
+    @signature({'types': ['string']}, {'types': ['string']})
+    def _func_ends_with(self, search, suffix):
+        return search.endswith(suffix)
+
+    @signature({'types': ['string']}, {'types': ['string']})
+    def _func_starts_with(self, search, suffix):
+        return search.startswith(suffix)
+
+    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
+    def _func_trim(self, text, chars=None):
+        if chars is None or len(chars) == 0:
+            return text.strip()
+        return text.strip(chars)
+
+    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
+    def _func_trim_left(self, text, chars=None):
+        if chars is None or len(chars) == 0:
+            return text.lstrip()
+        return text.lstrip(chars)
+
+    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
+    def _func_trim_right(self, text, chars=None):
+        if chars is None or len(chars) == 0:
+            return text.rstrip()
+        return text.rstrip(chars)
+
+    @signature({'types': ['string']}, {'types': ['array-string']})
+    def _func_join(self, separator, array):
+        return separator.join(array)
+
+    #
+
+    def _find_impl(self, text, search, func, start, end):
+        if len(search) == 0:
+            return None
+        if end is None:
+            end = len(text)
+
+        pos = func(text[start:end], search)
+        if start < 0:
+            start = start + len(text)
+
+        # restrict resulting range to valid indices
+        start = min(max(start, 0), len(text))
+        return start + pos if pos != -1 else None
 
     @signature(
         {'type': 'string'},
@@ -363,19 +539,15 @@ class Functions(metaclass=FunctionRegistry):
             end,
         )
 
-    def _find_impl(self, text, search, func, start, end):
-        if len(search) == 0:
-            return None
-        if end is None:
-            end = len(text)
-
-        pos = func(text[start:end], search)
-        if start < 0:
-            start = start + len(text)
+    #
 
-        # restrict resulting range to valid indices
-        start = min(max(start, 0), len(text))
-        return start + pos if pos != -1 else None
+    def _pad_impl(self, func, padding):
+        if len(padding) != 1:
+            raise JmespathError(
+                f'syntax-error: pad_right() expects $padding to have a single character, but received '
+                f'`{padding}` instead.',
+            )
+        return func()
 
     @signature(
         {'type': 'string'},
@@ -395,13 +567,7 @@ class Functions(metaclass=FunctionRegistry):
         self._ensure_non_negative_integer('pad_right', 'width', width)
         return self._pad_impl(lambda: text.ljust(width, padding), padding)
 
-    def _pad_impl(self, func, padding):
-        if len(padding) != 1:
-            raise exceptions.JmespathError(
-                f'syntax-error: pad_right() expects $padding to have a single character, but received '
-                f'`{padding}` instead.',
-            )
-        return func()
+    #
 
     @signature(
         {'type': 'string'},
@@ -447,68 +613,45 @@ class Functions(metaclass=FunctionRegistry):
 
         return text.split(search)
 
-    def _ensure_integer(
-            self,
-            func_name,
-            param_name,
-            param_value,
-    ):
-        if param_value is not None:
-            if int(param_value) != param_value:
-                raise exceptions.JmespathValueError(
-                    func_name,
-                    param_value,
-                    'integer',
-                )
+    #
 
-    def _ensure_non_negative_integer(
-            self,
-            func_name,
-            param_name,
-            param_value,
-    ):
-        if param_value is not None:
-            if int(param_value) != param_value or int(param_value) < 0:
-                raise exceptions.JmespathValueError(
-                    func_name,
-                    param_name,
-                    'non-negative integer',
-                )
+    @signature({'types': ['string']}, {'types': ['string']})
+    def _func_match(self, string, pattern):
+        return re.match(pattern, string) is not None
 
-    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
-    def _func_trim(self, text, chars=None):
-        if chars is None or len(chars) == 0:
-            return text.strip()
-        return text.strip(chars)
 
-    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
-    def _func_trim_left(self, text, chars=None):
-        if chars is None or len(chars) == 0:
-            return text.lstrip()
-        return text.lstrip(chars)
+class ObjectFunctions(FunctionsClass):
+    @signature({'types': ['object']})
+    def _func_items(self, arg):
+        return [list(t) for t in arg.items()]
 
-    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
-    def _func_trim_right(self, text, chars=None):
-        if chars is None or len(chars) == 0:
-            return text.rstrip()
-        return text.rstrip(chars)
+    @signature({'types': ['array']})
+    def _func_from_items(self, items):
+        return dict(items)
 
-    @signature({'types': []})
-    def _func_type(self, arg):
-        if isinstance(arg, str):
-            return 'string'
-        elif isinstance(arg, bool):
-            return 'boolean'
-        elif isinstance(arg, list):
-            return 'array'
-        elif isinstance(arg, dict):
-            return 'object'
-        elif isinstance(arg, (float, int)):
-            return 'number'
-        elif arg is None:
-            return 'null'
-        else:
-            return None
+    @signature({'types': ['object']})
+    def _func_keys(self, arg):
+        # To be consistent with .values() should we also return the indices of a list?
+        return list(arg.keys())
+
+    @signature({'types': ['object']})
+    def _func_values(self, arg):
+        return list(arg.values())
+
+
+class KeyedFunctions(FunctionsClass):
+    def _create_key_func(self, expref, allowed_types, function_name):
+        def keyfunc(x):
+            result = expref.visit(expref.expression, x)
+            jmespath_type = self._convert_to_jmespath_type(pytype_of(result))
+            # allowed_types is in terms of jmespath types, not python types.
+            if jmespath_type not in allowed_types:
+                raise JmespathTypeError(
+                    function_name, result, jmespath_type, allowed_types)
+
+            return result
+
+        return keyfunc
 
     @signature({'types': ['array']}, {'types': ['expref']})
     def _func_sort_by(self, array, expref):
@@ -519,9 +662,9 @@ class Functions(metaclass=FunctionRegistry):
         # We evaluate the first array element and verify that it's either a string of a number.  We then create a key
         # function that validates that type, which requires that remaining array elements resolve to the same type as
         # the first element.
-        required_type = self._convert_to_jmespath_type(type(expref.visit(expref.expression, array[0])).__name__)
+        required_type = self._convert_to_jmespath_type(pytype_of(expref.visit(expref.expression, array[0])))
         if required_type not in ['number', 'string']:
-            raise exceptions.JmespathTypeError(
+            raise JmespathTypeError(
                 'sort_by',
                 array[0],
                 required_type,
@@ -557,10 +700,6 @@ class Functions(metaclass=FunctionRegistry):
         else:
             return None
 
-    @signature({'types': ['array'], 'variadic': True})
-    def _func_zip(self, *arguments):
-        return [list(t) for t in zip(*arguments)]
-
     @signature({'types': ['array']}, {'types': ['expref']})
     def _func_group_by(self, array, expref):
         keyfunc = self._create_key_func(expref, ['null', 'string'], 'group_by')
@@ -575,30 +714,14 @@ class Functions(metaclass=FunctionRegistry):
 
         return result
 
-    def _create_key_func(self, expref, allowed_types, function_name):
-        def keyfunc(x):
-            result = expref.visit(expref.expression, x)
-            actual_typename = type(result).__name__
-
-            jmespath_type = self._convert_to_jmespath_type(actual_typename)
-            # allowed_types is in terms of jmespath types, not python types.
-            if jmespath_type not in allowed_types:
-                raise exceptions.JmespathTypeError(
-                    function_name, result, jmespath_type, allowed_types)
-
-            return result
-
-        return keyfunc
 
-    def _convert_to_jmespath_type(self, pyobject):
-        return TYPES_MAP.get(pyobject, 'unknown')
-
-    #
-
-    @signature({'types': ['string']}, {'types': ['string']})
-    def _func_match(self, string, pattern):
-        return re.match(pattern, string) is not None
-
-    @signature({'types': ['array', 'string']}, {'types': [], 'variadic': True})
-    def _func_in(self, subject, *searches):
-        return subject in searches
+class DefaultFunctions(
+    KeyedFunctions,
+    ObjectFunctions,
+    StringFunctions,
+    NumberFunctions,
+    ContainerFunctions,
+    TypeFunctions,
+    FunctionsClass,
+):
+    pass