Update tosca lib to version 0.5

Use tosca-parser and heat-translator to analyze to the basic
nfv-tosca type definitions, and use simple tosca new feature
such as policy, group and trigger, which are now supported by
the latest version of tosca-parser and heat-translator.

JIRA:PARSER-18

Change-Id: I797bcacbb5b32005d0aeb0f3f32851ac96e30f01
Signed--off-by: shangxdy <shang.xiaodong@zte.com.cn>
Signed-off-by: shangxdy <shang.xiaodong@zte.com.cn>

1 files changed, 0 insertions, 266 deletions

diff --git a/tosca2heat/heat-translator-0.3.0/translator/common/utils.py b/tosca2heat/heat-translator-0.3.0/translator/common/utils.py
deleted file mode 100644
index 6d0d9e1..0000000
--- a/tosca2heat/heat-translator-0.3.0/translator/common/utils.py
+++ /dev/null
@@ -1,266 +0,0 @@
-#    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 logging
-import math
-import numbers
-import os
-import re
-from six.moves.urllib.parse import urlparse
-import yaml
-
-from toscaparser.utils.gettextutils import _
-import toscaparser.utils.yamlparser
-
-YAML_ORDER_PARSER = toscaparser.utils.yamlparser.simple_ordered_parse
-log = logging.getLogger('tosca')
-log = logging.getLogger('heat-translator')
-
-
-class MemoryUnit(object):
-
-    UNIT_SIZE_DEFAULT = 'B'
-    UNIT_SIZE_DICT = {'B': 1, 'kB': 1000, 'KiB': 1024, 'MB': 1000000,
-                      'MiB': 1048576, 'GB': 1000000000,
-                      'GiB': 1073741824, 'TB': 1000000000000,
-                      'TiB': 1099511627776}
-
-    @staticmethod
-    def convert_unit_size_to_num(size, unit=None):
-        """Convert given size to a number representing given unit.
-
-        If unit is None, convert to a number representing UNIT_SIZE_DEFAULT
-        :param size: unit size e.g. 1 TB
-        :param unit: unit to be converted to e.g GB
-        :return: converted number e.g. 1000 for 1 TB size and unit GB
-        """
-        if unit:
-            unit = MemoryUnit.validate_unit(unit)
-        else:
-            unit = MemoryUnit.UNIT_SIZE_DEFAULT
-            log.info(_('A memory unit is not provided for size; using the '
-                       'default unit %(default)s') % {'default': 'B'})
-        regex = re.compile('(\d*)\s*(\w*)')
-        result = regex.match(str(size)).groups()
-        if result[1]:
-            unit_size = MemoryUnit.validate_unit(result[1])
-            converted = int(str_to_num(result[0])
-                            * MemoryUnit.UNIT_SIZE_DICT[unit_size]
-                            * math.pow(MemoryUnit.UNIT_SIZE_DICT
-                                       [unit], -1))
-            log.info(_('Given size %(size)s is converted to %(num)s '
-                       '%(unit)s') % {'size': size,
-                     'num': converted, 'unit': unit})
-        else:
-            converted = (str_to_num(result[0]))
-        return converted
-
-    @staticmethod
-    def validate_unit(unit):
-        if unit in MemoryUnit.UNIT_SIZE_DICT.keys():
-            return unit
-        else:
-            for key in MemoryUnit.UNIT_SIZE_DICT.keys():
-                if key.upper() == unit.upper():
-                    return key
-
-            msg = _('Provided unit "{0}" is not valid. The valid units are'
-                    ' {1}').format(unit, MemoryUnit.UNIT_SIZE_DICT.keys())
-            log.warning(msg)
-            raise ValueError(msg)
-
-
-class CompareUtils(object):
-
-    MISMATCH_VALUE1_LABEL = "<Expected>"
-    MISMATCH_VALUE2_LABEL = "<Provided>"
-    ORDERLESS_LIST_KEYS = ['allowed_values', 'depends_on']
-
-    @staticmethod
-    def compare_dicts(dict1, dict2):
-        """Return False if not equal, True if both are equal."""
-
-        if dict1 is None and dict2 is None:
-            return True
-        if dict1 is None or dict2 is None:
-            return False
-
-        both_equal = True
-        for dict1_item, dict2_item in zip(dict1.items(), dict2.items()):
-            if dict1_item != dict2_item:
-                msg = (_("%(label1)s: %(item1)s \n is not equal to \n:"
-                         "%(label2)s: %(item2)s")
-                       % {'label1': CompareUtils.MISMATCH_VALUE2_LABEL,
-                          'item1': dict1_item,
-                          'label2': CompareUtils.MISMATCH_VALUE1_LABEL,
-                          'item2': dict2_item})
-                log.warning(msg)
-                both_equal = False
-                break
-        return both_equal
-
-    @staticmethod
-    def compare_hot_yamls(generated_yaml, expected_yaml):
-        hot_translated_dict = YAML_ORDER_PARSER(generated_yaml)
-        hot_expected_dict = YAML_ORDER_PARSER(expected_yaml)
-        return CompareUtils.compare_dicts(hot_translated_dict,
-                                          hot_expected_dict)
-
-    @staticmethod
-    def reorder(dic):
-        '''Canonicalize list items in the dictionary for ease of comparison.
-
-        For properties whose value is a list in which the order does not
-        matter, some pre-processing is required to bring those lists into a
-        canonical format. We use sorting just to make sure such differences
-        in ordering would not cause to a mismatch.
-        '''
-
-        if type(dic) is not dict:
-            return None
-
-        reordered = {}
-        for key in dic.keys():
-            value = dic[key]
-            if type(value) is dict:
-                reordered[key] = CompareUtils.reorder(value)
-            elif type(value) is list \
-                and key in CompareUtils.ORDERLESS_LIST_KEYS:
-                reordered[key] = sorted(value)
-            else:
-                reordered[key] = value
-        return reordered
-
-    @staticmethod
-    def diff_dicts(dict1, dict2, reorder=True):
-        '''Compares two dictionaries and returns their differences.
-
-        Returns a dictionary of mismatches between the two dictionaries.
-        An empty dictionary is returned if two dictionaries are equivalent.
-        The reorder parameter indicates whether reordering is required
-        before comparison or not.
-        '''
-
-        if reorder:
-            dict1 = CompareUtils.reorder(dict1)
-            dict2 = CompareUtils.reorder(dict2)
-
-        if dict1 is None and dict2 is None:
-            return {}
-        if dict1 is None or dict2 is None:
-            return {CompareUtils.MISMATCH_VALUE1_LABEL: dict1,
-                    CompareUtils.MISMATCH_VALUE2_LABEL: dict2}
-
-        diff = {}
-        keys1 = set(dict1.keys())
-        keys2 = set(dict2.keys())
-        for key in keys1.union(keys2):
-            if key in keys1 and key not in keys2:
-                diff[key] = {CompareUtils.MISMATCH_VALUE1_LABEL: dict1[key],
-                             CompareUtils.MISMATCH_VALUE2_LABEL: None}
-            elif key not in keys1 and key in keys2:
-                diff[key] = {CompareUtils.MISMATCH_VALUE1_LABEL: None,
-                             CompareUtils.MISMATCH_VALUE2_LABEL: dict2[key]}
-            else:
-                val1 = dict1[key]
-                val2 = dict2[key]
-                if val1 != val2:
-                    if type(val1) is dict and type(val2) is dict:
-                        diff[key] = CompareUtils.diff_dicts(val1, val2, False)
-                    else:
-                        diff[key] = {CompareUtils.MISMATCH_VALUE1_LABEL: val1,
-                                     CompareUtils.MISMATCH_VALUE2_LABEL: val2}
-        return diff
-
-
-class YamlUtils(object):
-
-    @staticmethod
-    def get_dict(yaml_file):
-        '''Returns the dictionary representation of the given YAML spec.'''
-        try:
-            return yaml.load(open(yaml_file))
-        except IOError:
-            return None
-
-    @staticmethod
-    def compare_yamls(yaml1_file, yaml2_file):
-        '''Returns true if two dictionaries are equivalent, false otherwise.'''
-        dict1 = YamlUtils.get_dict(yaml1_file)
-        dict2 = YamlUtils.get_dict(yaml2_file)
-        return CompareUtils.compare_dicts(dict1, dict2)
-
-    @staticmethod
-    def compare_yaml_dict(yaml_file, dic):
-        '''Returns true if yaml matches the dictionary, false otherwise.'''
-        return CompareUtils.compare_dicts(YamlUtils.get_dict(yaml_file), dic)
-
-
-class TranslationUtils(object):
-
-    @staticmethod
-    def compare_tosca_translation_with_hot(tosca_file, hot_file, params):
-        '''Verify tosca translation against the given hot specification.
-
-        inputs:
-        tosca_file: relative local path or URL to the tosca input file
-        hot_file: relative path to expected hot output
-        params: dictionary of parameter name value pairs
-
-        Returns as a dictionary the difference between the HOT translation
-        of the given tosca_file and the given hot_file.
-        '''
-
-        from toscaparser.tosca_template import ToscaTemplate
-        from translator.hot.tosca_translator import TOSCATranslator
-
-        tosca_tpl = os.path.normpath(os.path.join(
-            os.path.dirname(os.path.abspath(__file__)), tosca_file))
-        a_file = os.path.isfile(tosca_tpl)
-        if not a_file:
-            tosca_tpl = tosca_file
-
-        expected_hot_tpl = os.path.join(
-            os.path.dirname(os.path.abspath(__file__)), hot_file)
-
-        tosca = ToscaTemplate(tosca_tpl, params, a_file)
-        translate = TOSCATranslator(tosca, params)
-
-        output = translate.translate()
-        output_dict = toscaparser.utils.yamlparser.simple_parse(output)
-        expected_output_dict = YamlUtils.get_dict(expected_hot_tpl)
-        return CompareUtils.diff_dicts(output_dict, expected_output_dict)
-
-
-class UrlUtils(object):
-
-    @staticmethod
-    def validate_url(path):
-        """Validates whether the given path is a URL or not.
-
-        If the given path includes a scheme (http, https, ftp, ...) and a net
-        location (a domain name such as www.github.com) it is validated as a
-        URL.
-        """
-        parsed = urlparse(path)
-        return bool(parsed.scheme) and bool(parsed.netloc)
-
-
-def str_to_num(value):
-    """Convert a string representation of a number into a numeric type."""
-    if isinstance(value, numbers.Number):
-        return value
-    try:
-        return int(value)
-    except ValueError:
-        return float(value)