argumentspec.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import sys
from enum import Enum
 
from robot.utils import is_union, safe_str, setter, type_repr
 
from .argumentconverter import ArgumentConverter
from .argumentmapper import ArgumentMapper
from .argumentresolver import ArgumentResolver
from .typevalidator import TypeValidator
 
 
class ArgumentSpec:
 
    def __init__(self, name=None, type='Keyword', positional_only=None,
                 positional_or_named=None, var_positional=None, named_only=None,
                 var_named=None, defaults=None, types=None):
        self.namename = name
        self.typetype = type
        self.positional_onlypositional_only = positional_only or []
        self.positional_or_namedpositional_or_named = positional_or_named or []
        self.var_positionalvar_positional = var_positional
        self.named_onlynamed_only = named_only or []
        self.var_namedvar_named = var_named
        self.defaultsdefaults = defaults or {}
        self.typestypestypes = types
 
    @setter
    def types(self, types):
        return TypeValidator(self).validate(types)
 
    @property
    positional = property
    
    def positional(self):
        return self.positional_onlypositional_only + self.positional_or_namedpositional_or_named
 
    @property
    minargs = property
    
    def minargs(self):
        return len([arg for arg in self.positionalpositionalpositional if arg not in self.defaultsdefaults])
 
    @property
    maxargs = property
    
    def maxargs(self):
        return len(self.positionalpositionalpositional) if not self.var_positionalvar_positional else sys.maxsize
 
    @property
    argument_names = property
    
    def argument_names(self):
        return (self.positional_onlypositional_only +
                self.positional_or_namedpositional_or_named +
                ([self.var_positionalvar_positional] if self.var_positionalvar_positional else []) +
                self.named_onlynamed_only +
                ([self.var_namedvar_named] if self.var_namedvar_named else []))
 
    def resolve(self, arguments, variables=None, converters=None,
                resolve_named=True, resolve_variables_until=None,
                dict_to_kwargs=False, languages=None):
        resolver = ArgumentResolver(self, resolve_named,
                                    resolve_variables_until, dict_to_kwargs)
        positional, named = resolver.resolve(arguments, variables)
        return self.convertconvert(positional, named, converters, dry_run=not variables,
                            languages=languages)
 
    def convert(self, positional, named, converters=None, dry_run=False, languages=None):
        if self.typestypestypes or self.defaultsdefaults:
            converter = ArgumentConverter(self, converters, dry_run, languages)
            positional, named = converter.convert(positional, named)
        return positional, named
 
    def map(self, positional, named, replace_defaults=True):
        mapper = ArgumentMapper(self)
        return mapper.map(positional, named, replace_defaults)
 
    def __iter__(self):
        notset = ArgInfo.NOTSET
        get_type = (self.typestypestypes or {}).get
        get_default = self.defaultsdefaults.get
        for arg in self.positional_onlypositional_only:
            yield ArgInfo(ArgInfo.POSITIONAL_ONLY, arg,
                          get_type(arg, notset), get_default(arg, notset))
        if self.positional_onlypositional_only:
            yield ArgInfo(ArgInfo.POSITIONAL_ONLY_MARKER)
        for arg in self.positional_or_namedpositional_or_named:
            yield ArgInfo(ArgInfo.POSITIONAL_OR_NAMED, arg,
                          get_type(arg, notset), get_default(arg, notset))
        if self.var_positionalvar_positional:
            yield ArgInfo(ArgInfo.VAR_POSITIONAL, self.var_positionalvar_positional,
                          get_type(self.var_positionalvar_positional, notset))
        elif self.named_onlynamed_only:
            yield ArgInfo(ArgInfo.NAMED_ONLY_MARKER)
        for arg in self.named_onlynamed_only:
            yield ArgInfo(ArgInfo.NAMED_ONLY, arg,
                          get_type(arg, notset), get_default(arg, notset))
        if self.var_namedvar_named:
            yield ArgInfo(ArgInfo.VAR_NAMED, self.var_namedvar_named,
                          get_type(self.var_namedvar_named, notset))
 
    def __bool__(self):
        return any([self.positional_onlypositional_only, self.positional_or_namedpositional_or_named, self.var_positionalvar_positional,
                    self.named_onlynamed_only, self.var_namedvar_named])
 
    def __str__(self):
        return ', '.join(str(arg) for arg in self)
 
 
class ArgInfo:
    NOTSET = object()
    POSITIONAL_ONLY = 'POSITIONAL_ONLY'
    POSITIONAL_ONLY_MARKER = 'POSITIONAL_ONLY_MARKER'
    POSITIONAL_OR_NAMED = 'POSITIONAL_OR_NAMED'
    VAR_POSITIONAL = 'VAR_POSITIONAL'
    NAMED_ONLY_MARKER = 'NAMED_ONLY_MARKER'
    NAMED_ONLY = 'NAMED_ONLY'
    VAR_NAMED = 'VAR_NAMED'
 
    def __init__(self, kind, name='', types=NOTSET, default=NOTSET):
        self.kindkind = kind
        self.namename = name
        self.typestypestypes = types
        self.defaultdefault = default
 
    @setter
    def types(self, typ):
        if not typ or typ is self.NOTSETNOTSET:
            return tuple()
        if isinstance(typ, tuple):
            return typ
        if is_union(typ):
            return typ.__args__
        return (typ,)
 
    @property
    required = property
    
    def required(self):
        if self.kindkind in (self.POSITIONAL_ONLYPOSITIONAL_ONLY,
                         self.POSITIONAL_OR_NAMEDPOSITIONAL_OR_NAMED,
                         self.NAMED_ONLYNAMED_ONLY):
            return self.defaultdefault is self.NOTSETNOTSET
        return False
 
    @property
    types_reprs = property
    
    def types_reprs(self):
        return [type_repr(t) for t in self.typestypestypes]
 
    @property
    default_repr = property
    
    def default_repr(self):
        if self.defaultdefault is self.NOTSETNOTSET:
            return None
        if isinstance(self.defaultdefault, Enum):
            return self.defaultdefault.name
        return safe_str(self.defaultdefault)
 
    def __str__(self):
        if self.kindkind == self.POSITIONAL_ONLY_MARKERPOSITIONAL_ONLY_MARKER:
            return '/'
        if self.kindkind == self.NAMED_ONLY_MARKERNAMED_ONLY_MARKER:
            return '*'
        ret = self.namename
        if self.kindkind == self.VAR_POSITIONALVAR_POSITIONAL:
            ret = '*' + ret
        elif self.kindkind == self.VAR_NAMEDVAR_NAMED:
            ret = '**' + ret
        if self.typestypestypes:
            ret = '%s: %s' % (ret, ' | '.join(self.types_reprstypes_reprstypes_reprs))
            default_sep = ' = '
        else:
            default_sep = '='
        if self.defaultdefault is not self.NOTSETNOTSET:
            ret = '%s%s%s' % (ret, default_sep, self.default_reprdefault_reprdefault_repr)
        return ret