Exemple #1
0
 def parse_werkzeug_rule(self, rule: str, ctx: dict) -> PathAndParams:
     """
     Convert werkzeug rule to swagger path format and
     extract parameter info.
     """
     params = {}
     with io.StringIO() as buf:
         for converter, arguments, variable in parse_rule(rule):
             if converter:
                 if arguments is not None:
                     args, kwargs = parse_converter_args(arguments)
                 else:
                     args = ()
                     kwargs = {}
                 params[variable] = WerkzeugConverter(
                     converter=converter,
                     args=args,
                     kwargs=kwargs,
                 )
                 buf.write('{')
                 buf.write(variable)
                 buf.write('}')
             else:
                 buf.write(variable)
         return PathAndParams(buf.getvalue(), params)
Exemple #2
0
def parse_url(path: str):
    """
    Parsing Flask route url to get the normal url path and parameter type.

    Based on Werkzeug_ builtin converters.

    .. _werkzeug: https://werkzeug.palletsprojects.com/en/0.15.x/routing/#builtin-converters
    """
    subs = []
    parameters = []

    for converter, arguments, variable in parse_rule(path):
        if converter is None:
            subs.append(variable)
            continue
        subs.append(f'{{{variable}}}')

        args, kwargs = [], {}

        if arguments:
            args, kwargs = parse_converter_args(arguments)

        schema = get_converter(converter, *args, **kwargs)

        parameters.append({
            'name': variable,
            'in': 'path',
            'required': True,
            'schema': schema,
        })

    return ''.join(subs), parameters
    def test_converter_parser(self):
        args, kwargs = r.parse_converter_args(u'test, a=1, b=3.0')

        assert args == ('test', )
        assert kwargs == {'a': 1, 'b': 3.0}

        args, kwargs = r.parse_converter_args('')
        assert not args and not kwargs

        args, kwargs = r.parse_converter_args('a, b, c,')
        assert args == ('a', 'b', 'c')
        assert not kwargs

        args, kwargs = r.parse_converter_args('True, False, None')
        assert args == (True, False, None)

        args, kwargs = r.parse_converter_args('"foo", u"bar"')
        assert args == ('foo', 'bar')
Exemple #4
0
    def test_converter_parser(self):
        args, kwargs = r.parse_converter_args(u'test, a=1, b=3.0')

        assert args == ('test',)
        assert kwargs == {'a': 1, 'b': 3.0 }

        args, kwargs = r.parse_converter_args('')
        assert not args and not kwargs

        args, kwargs = r.parse_converter_args('a, b, c,')
        assert args == ('a', 'b', 'c')
        assert not kwargs

        args, kwargs = r.parse_converter_args('True, False, None')
        assert args == (True, False, None)

        args, kwargs = r.parse_converter_args('"foo", u"bar"')
        assert args == ('foo', 'bar')
Exemple #5
0
def test_converter_parser():
    args, kwargs = r.parse_converter_args("test, a=1, b=3.0")

    assert args == ("test", )
    assert kwargs == {"a": 1, "b": 3.0}

    args, kwargs = r.parse_converter_args("")
    assert not args and not kwargs

    args, kwargs = r.parse_converter_args("a, b, c,")
    assert args == ("a", "b", "c")
    assert not kwargs

    args, kwargs = r.parse_converter_args("True, False, None")
    assert args == (True, False, None)

    args, kwargs = r.parse_converter_args('"foo", "bar"')
    assert args == ("foo", "bar")
Exemple #6
0
    def test_converter_parser(self):
        args, kwargs = r.parse_converter_args(u"test, a=1, b=3.0")

        assert args == ("test",)
        assert kwargs == {"a": 1, "b": 3.0}

        args, kwargs = r.parse_converter_args("")
        assert not args and not kwargs

        args, kwargs = r.parse_converter_args("a, b, c,")
        assert args == ("a", "b", "c")
        assert not kwargs

        args, kwargs = r.parse_converter_args("True, False, None")
        assert args == (True, False, None)

        args, kwargs = r.parse_converter_args('"foo", u"bar"')
        assert args == ("foo", "bar")
Exemple #7
0
        def fix_spec(item_spec):
            if isinstance(item_spec, converter_spec):
                cname, args = item_spec
                args, kwargs = ((), {}) if args is None \
                                        else parse_converter_args(args)
                if cname not in app.url_map.converters:
                    return None

                ccls = app.url_map.converters[cname]
                converter = ccls(app.url_map, *args, **kwargs)                   

                compiled_re = re.compile(converter.regex)
                return compiled_re, converter
            elif isinstance(item_spec, list):
                return [fix_spec(item_spec[0])]
            else:
                return item_spec
Exemple #8
0
Fichier : rule.py Projet : denz/ldp
 def _build_regex(rule):
     for converter, arguments, variable in parse_rule(rule):
         if converter is None:
             regex_parts.append(fnmatch.translate(variable)[:-7])
             self._trace.append((False, variable))
             for part in variable.split('/'):
                 if part:
                     self._weights.append((0, -len(part)))
         else:
             if arguments:
                 c_args, c_kwargs = parse_converter_args(arguments)
             else:
                 c_args = ()
                 c_kwargs = {}
             convobj = self.get_converter(variable, converter, c_args,
                                          c_kwargs)
             regex_parts.append('(?P<%s>%s)' %
                                (variable, convobj.regex))
             self._converters[variable] = convobj
             self._trace.append((True, variable))
             self._weights.append((1, convobj.weight))
             self.arguments.add(str(variable))
Exemple #9
0
    def parse_path(self, route):
        from werkzeug.routing import parse_converter_args, parse_rule

        subs = []
        parameters = []

        for converter, arguments, variable in parse_rule(str(route)):
            if converter is None:
                subs.append(variable)
                continue
            subs.append(f"{{{variable}}}")

            args, kwargs = [], {}

            if arguments:
                args, kwargs = parse_converter_args(arguments)

            schema = None
            if converter == "any":
                schema = {
                    "type": "array",
                    "items": {
                        "type": "string",
                        "enum": args,
                    },
                }
            elif converter == "int":
                schema = {
                    "type": "integer",
                    "format": "int32",
                }
                if "max" in kwargs:
                    schema["maximum"] = kwargs["max"]
                if "min" in kwargs:
                    schema["minimum"] = kwargs["min"]
            elif converter == "float":
                schema = {
                    "type": "number",
                    "format": "float",
                }
            elif converter == "uuid":
                schema = {
                    "type": "string",
                    "format": "uuid",
                }
            elif converter == "path":
                schema = {
                    "type": "string",
                    "format": "path",
                }
            elif converter == "string":
                schema = {
                    "type": "string",
                }
                for prop in ["length", "maxLength", "minLength"]:
                    if prop in kwargs:
                        schema[prop] = kwargs[prop]
            elif converter == "default":
                schema = {"type": "string"}

            parameters.append({
                "name": variable,
                "in": "path",
                "required": True,
                "schema": schema,
            })

        return "".join(subs), parameters
Exemple #10
0
    def parse_path(self, route):
        from werkzeug.routing import parse_rule, parse_converter_args

        subs = []
        parameters = []

        for converter, arguments, variable in parse_rule(str(route)):
            if converter is None:
                subs.append(variable)
                continue
            subs.append(f'{{{variable}}}')

            args, kwargs = [], {}

            if arguments:
                args, kwargs = parse_converter_args(arguments)

            schema = None
            if converter == 'any':
                schema = {
                    'type': 'array',
                    'items': {
                        'type': 'string',
                        'enum': args,
                    }
                }
            elif converter == 'int':
                schema = {
                    'type': 'integer',
                    'format': 'int32',
                }
                if 'max' in kwargs:
                    schema['maximum'] = kwargs['max']
                if 'min' in kwargs:
                    schema['minimum'] = kwargs['min']
            elif converter == 'float':
                schema = {
                    'type': 'number',
                    'format': 'float',
                }
            elif converter == 'uuid':
                schema = {
                    'type': 'string',
                    'format': 'uuid',
                }
            elif converter == 'path':
                schema = {
                    'type': 'string',
                    'format': 'path',
                }
            elif converter == 'string':
                schema = {
                    'type': 'string',
                }
                for prop in ['length', 'maxLength', 'minLength']:
                    if prop in kwargs:
                        schema[prop] = kwargs[prop]
            elif converter == 'default':
                schema = {'type': 'string'}

            parameters.append({
                'name': variable,
                'in': 'path',
                'required': True,
                'schema': schema,
            })

        return ''.join(subs), parameters