datatypes.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.
 
from inspect import isclass
from enum import Enum
 
from robot.utils import getdoc, Sortable, typeddict_types, type_name
from robot.running import TypeConverter
 
from .standardtypes import STANDARD_TYPE_DOCS
 
 
EnumType = type(Enum)
 
 
class TypeDoc(Sortable):
    ENUM = 'Enum'
    TYPED_DICT = 'TypedDict'
    CUSTOM = 'Custom'
    STANDARD = 'Standard'
 
    def __init__(self, type, name, doc, accepts=(), usages=None,
                 members=None, items=None):
        self.typetype = type
        self.namename = name
        self.docdoc = doc or ''    # doc parsed from XML can be None.
        self.acceptsaccepts = [type_name(t) if not isinstance(t, str) else t for t in accepts]
        self.usagesusages = usages or []
        # Enum members and TypedDict items are used only with appropriate types.
        self.membersmembers = members
        self.itemsitems = items
 
    @property
    _sort_key = property
    
    def _sort_key(self):
        return self.namename.lower()
 
    @classmethod
    def for_type(cls, type_hint, converters):
        if isinstance(type_hint, EnumType):
            return cls.for_enumfor_enum(type_hint)
        if isinstance(type_hint, typeddict_types):
            return cls.for_typed_dictfor_typed_dict(type_hint)
        converter = TypeConverter.converter_for(type_hint, converters)
        if not converter:
            return None
        elif not converter.type:
            return cls(cls.CUSTOMCUSTOM, converter.type_name, converter.doc,
                       converter.value_types)
        else:
            # Get `type_name` from class, not from instance, to get the original
            # name with generics like `list[int]` that override it in instance.
            return cls(cls.STANDARDSTANDARD, type(converter).type_name,
                       STANDARD_TYPE_DOCS[converter.type], converter.value_types)
 
    @classmethod
    def for_enum(cls, enum):
        accepts = (str, int) if issubclass(enum, int) else (str,)
        return cls(cls.ENUMENUM, enum.__name__, getdoc(enum), accepts,
                   members=[EnumMember(name, str(member.value))
                            for name, member in enum.__members__.items()])
 
    @classmethod
    def for_typed_dict(cls, typed_dict):
        items = []
        required_keys = list(getattr(typed_dict, '__required_keys__', []))
        optional_keys = list(getattr(typed_dict, '__optional_keys__', []))
        for key, value in typed_dict.__annotations__.items():
            typ = value.__name__ if isclass(value) else str(value)
            required = key in required_keys if required_keys or optional_keys else None
            items.append(TypedDictItem(key, typ, required))
        return cls(cls.TYPED_DICTTYPED_DICT, typed_dict.__name__, getdoc(typed_dict),
                   accepts=(str,), items=items)
 
    def to_dictionary(self, legacy=False):
        data = {
            'type': self.typetype,
            'name': self.namename,
            'doc': self.docdoc,
        }
        if not legacy:
            data['usages'] = self.usagesusages
            data['accepts'] = self.acceptsaccepts
        if self.membersmembers is not None:
            data['members'] = [m.to_dictionary() for m in self.membersmembers]
        if self.itemsitems is not None:
            data['items'] = [i.to_dictionary() for i in self.itemsitems]
        return data
 
 
class TypedDictItem:
 
    def __init__(self, key, type, required=None):
        self.keykey = key
        self.typetype = type
        self.requiredrequired = required
 
    def to_dictionary(self):
        return {'key': self.keykey, 'type': self.typetype, 'required': self.requiredrequired}
 
 
class EnumMember:
 
    def __init__(self, name, value):
        self.namename = name
        self.valuevalue = value
 
    def to_dictionary(self):
        return {'name': self.namename, 'value': self.valuevalue}