contentstack-utils 1.2.3__tar.gz → 1.3.1__tar.gz

{contentstack_utils-1.2.3 → contentstack_utils-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: contentstack_utils
-Version: 1.2.3
+Version: 1.3.1
 Summary: contentstack_utils is a Utility package for Contentstack headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-utils-python
 Author: contentstack

contentstack_utils-1.3.1/contentstack_utils/__init__.py

@@ -0,0 +1,36 @@
+# pip install -r requirements.txt
+# pytest --html=tests/report/test-report.html
+# coverage report -m
+# coverage html -d coveragereport
+"""
+__author__, __status__, __version__, __endpoint__ and __email__
+
+`Your code has been rated at 10.00/10`
+"""
+
+from contentstack_utils.embedded.item_type import ItemType
+from contentstack_utils.embedded.styletype import StyleType
+from contentstack_utils.helper.metadata import Metadata
+from contentstack_utils.helper.node_to_html import NodeToHtml
+from contentstack_utils.render.options import Options
+from contentstack_utils.utils import Utils
+from contentstack_utils.gql import GQL
+from contentstack_utils.automate import Automate
+
+__all__ = (
+"Utils",
+"Options",
+"Metadata",
+"GQL",
+"Automate",
+"StyleType",
+"ItemType",
+"NodeToHtml"
+)
+
+__title__ = 'contentstack_utils'
+__author__ = 'contentstack'
+__status__ = 'debug'
+__version__ = '1.3.1'
+__endpoint__ = 'cdn.contentstack.io'
+__contact__ = 'support@contentstack.com'

contentstack_utils-1.3.1/contentstack_utils/automate.py

@@ -0,0 +1,176 @@
+import json
+from contentstack_utils.helper.converter import convert_style
+from contentstack_utils.helper.metadata import Metadata
+from contentstack_utils.helper.node_to_html import NodeToHtml
+from contentstack_utils.render.options import Options
+
+
+class Automate:
+
+    @staticmethod
+    def _str_from_embed_items(metadata, entry, option):
+        if isinstance(entry, list):
+            for node in entry:
+                uid = node['node']['uid']
+                if uid == metadata.get_item_uid:
+                    return option.render_options(node['node'], metadata)
+        elif isinstance(entry, dict) and '_embedded_items' in entry:
+            items = entry['_embedded_items'].keys()
+            for item in items:
+                items_array = entry['_embedded_items'][item]
+                content = Automate._find_embedded_entry(items_array, metadata)
+                if content is not None:
+                    return option.render_options(content, metadata)
+        else:
+            node_style = entry['type']
+            def call(children):
+                    return Automate._raw_processing(children, entry, option)
+            
+            return option.render_node(node_style, entry, callback=call)
+        return ''
+
+    @staticmethod
+    def _get_embedded_keys(entry, key_path, option: Options, render_callback):
+        if '_embedded_items' in entry:
+            if key_path is not None:
+                for path in key_path:
+                    Automate._find_embed_keys(entry, path, option, render_callback)
+            else:
+                _embedded_items = entry['_embedded_items']
+                available_keys: list = _embedded_items.keys()
+                for path in available_keys:
+                    Automate._find_embed_keys(entry, path, option, render_callback)
+
+    @staticmethod
+    def _find_embed_keys(entry, path, option: Options, render_callback):
+        keys = path.split('.')
+        Automate._get_content(keys, entry, option, render_callback)
+
+    @staticmethod
+    def _get_content(keys_array, entry, option: Options, render_callback):
+        if keys_array is not None and len(keys_array) > 0:
+            key = keys_array[0]
+            if len(keys_array) == 1 and keys_array[0] in entry:
+                var_content = entry[key]
+                if isinstance(var_content, (list, str, dict)):
+                    entry[key] = render_callback(var_content, entry, option)
+            else:
+                keys_array.remove(key)
+                if key in entry and isinstance(entry[key], dict):
+                    Automate._get_content(keys_array, entry[key], option, render_callback)
+                elif key in entry and isinstance(entry[key], list):
+                    list_json = entry[key]
+                    for node in list_json:
+                        Automate._get_content(keys_array, node, option, render_callback)
+
+    @staticmethod
+    def is_json(self: object) -> bool:
+        try:
+            json.dumps(self)
+            return True
+        except ValueError:
+            return False
+
+    @staticmethod
+    def find_embed_keys(entry, paths, option: Options, render_callback):
+        Automate.get_content(paths, entry, option, render_callback)
+
+    @staticmethod
+    def get_content(keys_array, entry, option: Options, render_callback):
+        if keys_array is not None and len(keys_array) > 0:
+            key = keys_array[0]
+            if len(keys_array) == 1 and keys_array[0] in entry:
+                var_content = entry[key]
+                if isinstance(var_content, (list, str, dict)):
+                    entry[key] = render_callback(var_content, entry, option)
+                else:
+                    keys_array.remove(key)
+                    if key in entry and isinstance(entry[key], dict):
+                        Automate.get_content(keys_array, entry[key], option, render_callback)
+                    elif key in entry and isinstance(entry[key], list):
+                        list_json = entry[key]
+                        for node in list_json:
+                            Automate.get_content(keys_array, node, option, render_callback)
+
+    @staticmethod
+    def _enumerate_content(content, entry, option):
+        if len(content) > 0:
+            if isinstance(content, list):
+                array_content = []
+                for item in content:
+                    result = Automate._enumerate_content(item, entry, option)
+                    array_content.append(result)
+                return array_content
+            if isinstance(content, dict):
+                content_entry = content[entry]
+                if isinstance(content_entry, dict):
+                    if 'type' and 'children' in content_entry:
+                        if content_entry['type']:
+                            return Automate._raw_processing(content_entry['children'], entry, option)
+                elif isinstance(content_entry, list):
+                    for entry_item in content_entry:
+                        if 'type' and 'children' in entry_item:
+                            if entry_item['type']:
+                                return Automate._raw_processing(entry_item['children'], entry, option)
+
+        return ''
+
+    @staticmethod
+    def _raw_processing(children, entry, option):
+        array_container = []
+        for item in children:
+            if isinstance(item, dict):
+                array_container.append(Automate._extract_keys(item, entry, option))
+        temp = ''.join(array_container)
+        return temp
+
+    @staticmethod
+    def _extract_keys(item, entry, option: Options):
+        if 'type' not in item.keys() and 'text' in item.keys():
+            return NodeToHtml.text_node_to_html(item, option)
+
+        elif 'type' in item.keys():
+            node_style = item['type']
+            if node_style == 'reference':
+                metadata = Automate._return_metadata(item, node_style)
+                return Automate._str_from_embed_items(metadata=metadata, entry=item, option=option)
+            else:
+                def call(children):
+                    return Automate._raw_processing(children, entry, option)
+
+                return option.render_node(node_style, item, callback=call)
+        return ''
+
+    @staticmethod
+    def _find_embedded_entry(list_json: list, metadata: Metadata):
+        for obj in list_json:
+            if obj['uid'] == metadata.get_item_uid:
+                return obj
+        return None
+
+    @staticmethod
+    def _return_metadata(item, node_style):
+        attr = item['attrs']
+        text = Automate._get_child_text(item)
+        style = convert_style(attr['display-type'])
+        if attr['type'] == 'asset':
+            return Metadata(text, node_style,
+                            attr['asset-uid'],
+                            'sys-asset',
+                            style, '', '')
+        else:
+            return Metadata(text, node_style,
+                            attr['entry-uid'],
+                            attr['content-type-uid'],
+                            style, '', '')
+
+    @staticmethod
+    def _get_child_text(item):
+        text = ''
+        if 'children' in item.keys() and len(item['children']) > 0:
+            children = item['children']
+            for child in children:
+                if text in child.keys():
+                    text = child['text']
+                    break
+        return text

contentstack_utils-1.3.1/contentstack_utils/embedded/__init__.py

@@ -0,0 +1 @@
+import contentstack_utils

contentstack_utils-1.3.1/contentstack_utils/embedded/item_type.py

@@ -0,0 +1,15 @@
+"""
+ItemType is Enumeration class that conatains two options for ItemType:
+
+ASSET
+
+ENTRY
+"""
+
+import enum
+
+
+class ItemType(enum.Enum):
+    """Contains Two option for ItemsType => ENTRY and ASSET """
+    ENTRY = 'entry'
+    ASSET = 'asset'

contentstack_utils-1.3.1/contentstack_utils/embedded/styletype.py

@@ -0,0 +1,20 @@
+""""
+There are two types StyleType ENTRY and ASSETS
+For `Entry`: StyleType.BLOCK, StyleType.INLINE, StyleType.LINKED,
+For `Assets`: StyleType.DISPLAY, StyleType.DOWNLOADABLE
+ """
+import enum
+
+
+class StyleType(enum.Enum):
+
+    """
+    This StyleType contains four options like below.
+    BLOCK ,INLINE ,LINK,DISPLAY,DOWNLOAD
+    """
+
+    BLOCK = 'block'
+    INLINE = 'inline'
+    LINK = 'link'
+    DISPLAY = 'display'
+    DOWNLOAD = 'download'

contentstack_utils-1.3.1/contentstack_utils/gql.py

@@ -0,0 +1,37 @@
+from contentstack_utils import Utils
+from contentstack_utils.automate import Automate
+from contentstack_utils.render.options import Options
+
+
+class GQL(Automate):
+
+    @staticmethod
+    def json_to_html(gql_entry: dict, paths: list, option: Options):
+        if not Automate.is_json(gql_entry):
+            raise FileNotFoundError("Can't process invalid object")
+        if len(paths) > 0:
+            for path in paths:
+                Automate.find_embed_keys(gql_entry, path, option, render_callback=GQL._json_matcher)
+                return Automate._enumerate_content(gql_entry, path, option)
+
+    @staticmethod
+    def __filter_content(content_dict):
+        embedded_items = None
+        if content_dict is not None and 'embedded_itemsConnection' in content_dict:
+            embedded_connection = content_dict['embedded_itemsConnection']
+            if 'edges' in embedded_connection:
+                embedded_items = embedded_connection['edges']
+        return embedded_items
+
+    @staticmethod
+    def _json_matcher(content_dict, entry, option):
+        embedded_items = GQL.__filter_content(content_dict)
+        if 'json' in content_dict:
+            json = content_dict['json']
+            if isinstance(json, dict):
+                return Automate._enumerate_content(json, entry=embedded_items, option=option)
+            elif isinstance(json, list):
+                json_container = []
+                for item in json:
+                    json_container.append(Automate._enumerate_content(item, entry=embedded_items, option=option))
+                return json_container

contentstack_utils-1.3.1/contentstack_utils/helper/__init__.py

@@ -0,0 +1 @@
+import contentstack_utils

contentstack_utils-1.3.1/contentstack_utils/helper/converter.py

@@ -0,0 +1,14 @@
+from contentstack_utils.embedded.styletype import StyleType
+
+
+def convert_style(style) -> StyleType:
+    if style == 'block':
+        return StyleType.BLOCK
+    if style == 'inline':
+        return StyleType.INLINE
+    if style == 'link':
+        return StyleType.LINK
+    if style == 'display':
+        return StyleType.DISPLAY
+    if style == 'download':
+        return StyleType.DOWNLOAD

contentstack_utils-1.3.1/contentstack_utils/helper/metadata.py

@@ -0,0 +1,65 @@
+"""
+    Metadata is the model class for embedded objects
+
+    Returns:
+        str: text, item_type, item_uid, type_uid, style_type, outer_html and attributes
+"""
+
+from contentstack_utils.embedded.styletype import StyleType
+
+
+class Metadata:
+    """
+    model helper class to set and get value
+    """
+
+    def __init__(self, text: str, item_type: str, item_uid: str,
+                 content_type_uid: str, style_type: StyleType,
+                 outer_html: str, attributes: str):
+        """
+        Used to set the value to the variables
+
+        Args:
+            text (str): text for embedded objects
+            item_type (str): item_type for embedded objects
+            item_uid (str): item_uid for embedded objects
+            content_type_uid (str): content_type_uid for embedded objects
+            style_type (StyleType): style_type for embedded objects
+            outer_html (str): outer_html for embedded objects
+            attributes (str): attributes for embedded objects
+        """
+        self.text = text
+        self.item_type = item_type
+        self.item_uid = item_uid
+        self.content_type_uid = content_type_uid
+        self.style_type = style_type
+        self.outer_html = outer_html
+        self.attributes = attributes
+
+    @property
+    def get_text(self):
+        return self.text
+
+    @property
+    def get_item_type(self):
+        return self.item_type
+
+    @property
+    def get_item_uid(self):
+        return self.item_uid
+
+    @property
+    def get_content_type_uid(self):
+        return self.content_type_uid
+
+    @property
+    def get_style_type(self) -> StyleType:
+        return self.style_type
+
+    @property
+    def get_outer_html(self):
+        return self.outer_html
+
+    @property
+    def get_attributes(self):
+        return self.attributes

contentstack_utils-1.3.1/contentstack_utils/helper/node_to_html.py

@@ -0,0 +1,28 @@
+from contentstack_utils.render.options import Options
+
+
+class NodeToHtml:
+
+    @staticmethod
+    def text_node_to_html(node, option: Options):
+        """
+        accepts node type,
+        on the basis of the node type, generates string
+        :rtype: str
+        """
+        node_text = node['text']
+        if 'superscript' in node:
+            node_text = option.render_mark('superscript', node_text)
+        if 'subscript' in node:
+            node_text = option.render_mark('subscript', node_text)
+        if 'inlineCode' in node:
+            node_text = option.render_mark('inlineCode', node_text)
+        if 'strikethrough' in node:
+            node_text = option.render_mark('strikethrough', node_text)
+        if 'underline' in node:
+            node_text = option.render_mark('underline', node_text)
+        if 'italic' in node:
+            node_text = option.render_mark('italic', node_text)
+        if 'bold' in node:
+            node_text = option.render_mark('bold', node_text)
+        return node_text

contentstack_utils-1.3.1/contentstack_utils/render/__init__.py

@@ -0,0 +1 @@
+import contentstack_utils

contentstack_utils-1.3.1/contentstack_utils/render/options.py

@@ -0,0 +1,126 @@
+from contentstack_utils.helper.metadata import Metadata
+
+
+def _title_or_uid(_obj: dict) -> str:
+    _title = ""
+    if _obj is not None:
+        if 'title' in _obj and len(_obj['title']) != 0:
+            _title = _obj['title']
+        elif 'uid' in _obj:
+            _title = _obj['uid']
+    return _title
+
+
+def _asset_title_or_uid(_obj: dict) -> str:
+    _title = ""
+    if _obj is not None:
+        if 'title' in _obj and len(_obj['title']) != 0:
+            _title = _obj['title']
+        elif 'filename' in _obj:
+            _title = _obj['filename']
+        elif 'uid' in _obj:
+            _title = _obj['uid']
+    return _title
+
+
+class Options:
+
+    @staticmethod
+    def render_options(_obj: dict, metadata: Metadata):
+        if metadata.style_type.value == 'block':
+            _content_type_uid = ''
+            if '_content_type_uid' in _obj:
+                _content_type_uid = _obj['_content_type_uid']
+            return '<div><p>' + _title_or_uid(_obj) \
+                   + '</p><div><p>Content type: <span>' + _content_type_uid \
+                   + '</span></p></div>'
+        if metadata.style_type.value == 'inline':
+            return '<span>' + _title_or_uid(_obj) + '</span>'
+        if metadata.style_type.value == 'link':
+            return '<a href=' + _obj['url'] + '>' + _title_or_uid(_obj) + '</a>'
+        if metadata.style_type.value == 'display':
+            return '<img src=' + _obj['url'] + ' alt=' \
+                   + _asset_title_or_uid(_obj) + '/>'
+        if metadata.style_type.value == 'download':
+            return '<a href=' + _obj['url'] + '>' + _asset_title_or_uid(_obj) + '</a>'
+
+    @staticmethod
+    def render_mark(mark_type: str, render_text: str):
+        if mark_type == 'superscript':
+            return "<sup>" + render_text + "</sup>"
+        if mark_type == 'subscript':
+            return "<sub>" + render_text + "</sub>"
+        if mark_type == 'inlineCode':
+            return "<span>" + render_text + "</span>"
+        if mark_type == 'strikethrough':
+            return "<strike>" + render_text + "</strike>"
+        if mark_type == 'underline':
+            return "<u>" + render_text + "</u>"
+        if mark_type == 'italic':
+            return "<em>" + render_text + "</em>"
+        if mark_type == 'bold':
+            return "<strong>" + render_text + "</strong>"
+        else:
+            return render_text
+        pass
+
+    @staticmethod
+    def render_node(node_type, node_obj: dict, callback):
+        inner_html = callback(node_obj['children'])
+        if node_type == 'p':
+            return "<p>" + inner_html + "</p>"
+        if node_type == 'a':
+            return "<a href=\"{}\">{}</a>".format(node_obj["attrs"]["url"], inner_html)
+        if node_type == 'img':
+            return "<img src=\"{}\" />{}".format(node_obj["attrs"]["src"], inner_html)
+        if node_type == 'embed':
+            return "<iframe src={}>{}</iframe>".format(node_obj["attrs"]["src"], inner_html)
+        if node_type == 'h1':
+            return "<h1>" + inner_html + "</h1>"
+        if node_type == 'h2':
+            return "<h2>" + inner_html + "</h2>"
+        if node_type == 'h3':
+            return "<h3>" + inner_html + "</h3>"
+        if node_type == 'h4':
+            return "<h4>" + inner_html + "</h4>"
+        if node_type == 'h5':
+            return "<h5>" + inner_html + "</h5>"
+        if node_type == 'h6':
+            return "<h6>" + inner_html + "</h6>"
+        if node_type == 'ol':
+            return "<ol>" + inner_html + "</ol>"
+        if node_type == 'ul':
+            return "<ul>" + inner_html + "</ul>"
+        if node_type == 'li':
+            return "<li>" + inner_html + "</li>"
+        if node_type == 'hr':
+            return "<hr />"
+        if node_type == 'table':
+            return "<table>" + inner_html + "</table>"
+        if node_type == 'thead':
+            return "<thead>" + inner_html + "</thead>"
+        if node_type == 'tbody':
+            return "<tbody>" + inner_html + "</tbody>"
+        if node_type == 'tfoot':
+            return "<tfoot>" + inner_html + "</tfoot>"
+        if node_type == 'tr':
+            return "<tr>" + inner_html + "</tr>"
+        if node_type == 'th':
+            return "<th>" + inner_html + "</th>"
+        if node_type == 'td':
+            return "<td>" + inner_html + "</td>"
+        if node_type == 'blockquote':
+            return "<blockquote>" + inner_html + "</blockquote>"
+        if node_type == 'code':
+            return "<code>" + inner_html + "</code>"
+        if node_type == 'fragment':
+            return "<fragment>" + inner_html + "</fragment>"
+        if node_type == 'reference':
+            if node_obj['attrs']['type'] == 'asset':
+                return "<img src=\"{}\" alt=\"{}\" class=\"{}\"  />{}".format(node_obj["attrs"]["asset-link"], node_obj["attrs"]["alt"], node_obj["attrs"]["class-name"], inner_html)
+            else:
+                return inner_html
+        if node_type == 'doc':
+            return inner_html
+        else:
+            return inner_html

contentstack_utils-1.3.1/contentstack_utils/utils.py

@@ -0,0 +1,94 @@
+# pylint: disable=missing-function-docstring
+
+from lxml import etree
+
+from contentstack_utils.automate import Automate
+from contentstack_utils.helper.converter import convert_style
+from contentstack_utils.helper.metadata import Metadata
+from contentstack_utils.render.options import Options
+
+
+class Utils(Automate):
+
+    @staticmethod
+    def render(entry_obj, key_path: list, option: Options):
+        valid = Automate.is_json(entry_obj)
+        if not valid:
+            raise FileNotFoundError('Invalid file found')
+
+        if isinstance(entry_obj, list):
+            for entry in entry_obj:
+                Utils.render(entry, key_path, option)
+
+        if isinstance(entry_obj, dict):
+            Automate._get_embedded_keys(entry_obj, key_path, option, render_callback=Utils.render_content)
+
+    @staticmethod
+    def render_content(rte_content, embed_obj: dict, option: Options) -> object:
+        if isinstance(rte_content, str):
+            return Utils.__get_embedded_objects(rte_content, embed_obj, option)
+        elif isinstance(rte_content, list):
+            render_callback = []
+            for rte in rte_content:
+                render_callback.append(Utils.render_content(rte, embed_obj, option))
+            return render_callback
+        return rte_content
+
+    @staticmethod
+    def __get_embedded_objects(html_doc, entry, option):
+        import re
+        document = f"<items>{html_doc}</items>"
+        tag = etree.fromstring(document)
+        html_doc = etree.tostring(tag).decode('utf-8')
+        html_doc = re.sub('(?ms)<%s[^>]*>(.*)</%s>' % (tag.tag, tag.tag), '\\1', html_doc)
+        elements = tag.xpath("//*[contains(@class, 'embedded-asset') or contains(@class, 'embedded-entry')]")
+        metadata = Utils.__get_metadata(elements)
+        string_content = Utils._str_from_embed_items(metadata=metadata, entry=entry, option=option)
+        html_doc = html_doc.replace(metadata.outer_html, string_content)
+        return html_doc
+
+    @staticmethod
+    def _str_from_embed_items(metadata, entry, option):
+        if '_embedded_items' in entry:
+            items = entry['_embedded_items'].keys()
+            for item in items:
+                items_array = entry['_embedded_items'][item]
+                content = Automate._find_embedded_entry(items_array, metadata)
+                if content is not None:
+                    return option.render_options(content, metadata)
+        return ''
+
+    @staticmethod
+    def __get_metadata(elements):
+        for element in elements:
+            content_type = None
+            typeof = element.attrib['type']
+            if typeof == 'asset':
+                uid = element.attrib['data-sys-asset-uid']
+            else:
+                uid = element.attrib['data-sys-entry-uid']
+                content_type = element.attrib['data-sys-content-type-uid']
+            style = element.attrib['sys-style-type']
+            outer_html = etree.tostring(element).decode('utf-8')
+            attributes = element.attrib
+            style = convert_style(style)
+            metadata = Metadata(element.text, typeof, uid, content_type, style, outer_html, attributes)
+            return metadata
+
+    ####################################################
+    #                   SUPERCHARGED                   #
+    ####################################################
+
+    @staticmethod
+    def json_to_html(entry_obj, key_path: list, option: Options):
+        if not Automate.is_json(entry_obj):
+            raise FileNotFoundError('Could not process invalid content')
+        if isinstance(entry_obj, list):
+            for entry in entry_obj:
+                return Utils.json_to_html(entry, key_path, option)
+        if isinstance(entry_obj, dict):
+            if key_path is not None:
+                for path in key_path:
+                    render_callback = Automate._enumerate_content(entry_obj, path, option)
+                    # Automate._find_embed_keys(entry_obj, path, option, render_callback) This method used in GQL class.
+            return render_callback

{contentstack_utils-1.2.3 → contentstack_utils-1.3.1}/contentstack_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: contentstack_utils
-Version: 1.2.3
+Version: 1.3.1
 Summary: contentstack_utils is a Utility package for Contentstack headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-utils-python
 Author: contentstack

contentstack_utils-1.3.1/contentstack_utils.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+LICENSE
+README.md
+setup.py
+contentstack_utils/__init__.py
+contentstack_utils/automate.py
+contentstack_utils/gql.py
+contentstack_utils/utils.py
+contentstack_utils.egg-info/PKG-INFO
+contentstack_utils.egg-info/SOURCES.txt
+contentstack_utils.egg-info/dependency_links.txt
+contentstack_utils.egg-info/top_level.txt
+contentstack_utils/embedded/__init__.py
+contentstack_utils/embedded/item_type.py
+contentstack_utils/embedded/styletype.py
+contentstack_utils/helper/__init__.py
+contentstack_utils/helper/converter.py
+contentstack_utils/helper/metadata.py
+contentstack_utils/helper/node_to_html.py
+contentstack_utils/render/__init__.py
+contentstack_utils/render/options.py
+tests/__init__.py
+tests/convert_style.py
+tests/test_default_opt_others.py
+tests/test_gql_to_html_func.py
+tests/test_helper_node_to_html.py
+tests/test_item_types.py
+tests/test_metadata.py
+tests/test_option_render_mark.py
+tests/test_render_default_options.py
+tests/test_render_options.py
+tests/test_style_type.py
+tests/test_util_srte.py
+tests/test_utils.py

contentstack_utils-1.3.1/contentstack_utils.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+contentstack_utils
+tests

{contentstack_utils-1.2.3 → contentstack_utils-1.3.1}/setup.py

@@ -1,6 +1,6 @@
 import os
 
-from setuptools import find_packages
+from setuptools import setup, find_packages
 from distutils.core import setup
 
 with open(os.path.join(os.path.dirname(__file__), 'README.md')) as readme:
@@ -8,14 +8,14 @@ with open(os.path.join(os.path.dirname(__file__), 'README.md')) as readme:
 
 setup(
     name='contentstack_utils',
-    packages=find_packages(include=['contentstack']),
+    packages=find_packages(),
     description="contentstack_utils is a Utility package for Contentstack headless CMS with an API-first approach.",
     author='contentstack',
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/contentstack/contentstack-utils-python",
     license='MIT',
-    version='1.2.3',
+    version='1.3.1',
     install_requires=[
         
     ],

contentstack_utils-1.3.1/tests/__init__.py

@@ -0,0 +1,52 @@
+# pytest --html=tests/report/test-report.html 
+# above command runs tests and test reports generates in tests/report location.
+# nosetests --with-coverage --cover-html
+# clean all the .pyc files
+# find . -name \*.pyc -delete
+# nosetests --with-coverage --cover-html
+# pytest --cov=contentstack_utils
+# pytest -v --cov=contentstack_utils --cov-report=html
+# pytest --html=tests/report/test-report.html
+from unittest import TestLoader, TestSuite
+
+from .convert_style import TestConvertStyle
+from .test_default_opt_others import TestDefaultOptOther
+from .test_helper_node_to_html import TestHelperNodeToHtml
+from .test_item_types import TestItemType
+from .test_metadata import TestMetadata
+from .test_option_render_mark import TestOptionRenderMark
+from .test_render_default_options import TestRenderDefaultOption
+from .test_render_options import TestRenderOption
+from .test_style_type import TestStyleType
+from .test_util_srte import TestSuperchargedUtils
+from .test_utils import TestUtility
+
+
+def all_tests():
+    test_module_itemtype = TestLoader().loadTestsFromTestCase(TestItemType)
+    test_module_metadata = TestLoader().loadTestsFromTestCase(TestMetadata)
+    test_module_style_type = TestLoader().loadTestsFromTestCase(TestStyleType)
+    test_module_utility = TestLoader().loadTestsFromTestCase(TestUtility)
+
+    test_module_default_option = TestLoader().loadTestsFromTestCase(TestDefaultOptOther)
+    test_module_node_to_html = TestLoader().loadTestsFromTestCase(TestHelperNodeToHtml)
+    test_module_render_mark = TestLoader().loadTestsFromTestCase(TestOptionRenderMark)
+    test_module_render_default_option = TestLoader().loadTestsFromTestCase(TestRenderDefaultOption)
+    test_module_render_option = TestLoader().loadTestsFromTestCase(TestRenderOption)
+    test_module_utils_srte = TestLoader().loadTestsFromTestCase(TestSuperchargedUtils)
+    test_module_convert_style = TestLoader().loadTestsFromTestCase(TestConvertStyle)
+
+    suite = TestSuite([
+        test_module_itemtype,
+        test_module_metadata,
+        test_module_style_type,
+        test_module_utility,
+        test_module_default_option,
+        test_module_node_to_html,
+        test_module_render_mark,
+        test_module_render_default_option,
+        test_module_render_option,
+        test_module_utils_srte,
+        test_module_convert_style
+
+    ])

contentstack_utils-1.3.1/tests/convert_style.py

@@ -0,0 +1,29 @@
+from contentstack_utils.helper import converter
+from contentstack_utils.embedded.styletype import StyleType
+import unittest
+
+
+class TestConvertStyle(unittest.TestCase):
+
+    def setUp(self):
+        print("logger for ConvertStyle")
+
+    def test_converter_style_block(self):
+        _returns = converter.convert_style('block')
+        self.assertEquals(StyleType.BLOCK, _returns)
+
+    def test_converter_style_inline(self):
+        _returns = converter.convert_style('inline')
+        self.assertEqual(StyleType.INLINE, _returns)
+
+    def test_converter_style_link(self):
+        _returns = converter.convert_style('link')
+        self.assertEqual(StyleType.LINK, _returns)
+
+    def test_converter_style_display(self):
+        _returns = converter.convert_style('display')
+        self.assertEqual(StyleType.DISPLAY, _returns)
+
+    def test_converter_style_download(self):
+        _returns = converter.convert_style('download')
+        self.assertEqual(StyleType.DOWNLOAD, _returns)

{contentstack_utils-1.2.3 → contentstack_utils-1.3.1}/tests/test_gql_to_html_func.py

@@ -26,12 +26,12 @@ class TestGQLToHtml(unittest.TestCase):
 
     def test_read_entry_uid(self):
         entry = mock_entry()
-        self.assertEqual('sameple_uid', entry['srte']['json'][0]['uid'])
+        self.assertEqual('sameple_uid', entry['srte']['json']['uid'])
 
     def test_gql_to_html(self):
         entry = mock_entry()
         option = Options()
-        path_keys = ['srte']
-        GQL.json_to_html(entry, path_keys, option)
-        self.assertEqual(entry['srte'][0],
-                         '<p></p><div><p>Abcd Three</p><div><p>Content type: <span></span></p></div>')
+        path_keys = ['json']
+        response = GQL.json_to_html(entry['srte'], path_keys, option)
+        self.assertEqual(response,
+                         '<p>sample text</p><img src="https://images.contentstack.com/v3/assets/51807f919e0e4/11.jpg" alt="11.jpg" class="embedded-asset"  />')

{contentstack_utils-1.2.3 → contentstack_utils-1.3.1}/tests/test_util_srte.py

@@ -30,88 +30,98 @@ class TestSuperchargedUtils(unittest.TestCase):
 
     def test_plaintext_in_supercharged_dict_to_html(self):
         array_str = ['plaintext']
-        Utils.json_to_html(self._json_data, array_str, Options())
-        self.assertEqual(Results.plainTextHtml, self._json_data['plaintext'])
+        response = Utils.json_to_html(self._json_data, array_str, Options())
+        self.assertEqual(Results.plainTextHtml, response)
 
     def test_plaintext_in_supercharged_list_to_html(self):
         array_str = ['plaintext_array']
-        Utils.json_to_html(self._json_data, array_str, Options())
-        self.assertEqual(Results.plainTextHtml, self._json_data['plaintext_array'][0])
+        response = Utils.json_to_html(self._json_data, array_str, Options())
+        self.assertEqual(Results.plainTextHtml, response)
 
     def test_paragraph_in_supercharged_dict_to_html(self):
         array_str = ['paragraph']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.paragraphHtml, self._json_data['paragraph'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.paragraphHtml, response)
 
     def test_h1_in_supercharged_dict_to_html(self):
         array_str = ['h_one']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.h1Html, self._json_data['h_one'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h1Html, response)
 
     def test_h2_in_supercharged_dict_to_html(self):
         array_str = ['h_two']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.h2Html, self._json_data['h_two'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h2Html, response)
 
     def test_h3_in_supercharged_dict_to_html(self):
         array_str = ['h_three']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.h3Html, self._json_data['h_three'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h3Html, response)
 
     def test_h4_in_supercharged_dict_to_html(self):
         array_str = ['h_four']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.h4Html, self._json_data['h_four'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h4Html, response)
 
     def test_h5_in_supercharged_dict_to_html(self):
         array_str = ['h_five']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.h5Html, self._json_data['h_five'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h5Html, response)
 
     def test_h6_in_supercharged_dict_to_html(self):
         array_str = ['h_six']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.h6Html, self._json_data['h_six'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h6Html, response)
 
     def test_order_list_in_supercharged_dict_to_html(self):
         array_str = ['order_list']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.orderListHtml, self._json_data['order_list'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.orderListHtml, response)
 
     def test_un_order_list_in_supercharged_dict_to_html(self):
         array_str = ['un_order_list']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.unorderListHtml, self._json_data['un_order_list'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.unorderListHtml, response)
 
     def test_image_list_in_supercharged_dict_to_html(self):
         array_str = ['img']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.imgHtml, self._json_data['img'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.imgHtml, response)
 
     def test_table_list_in_supercharged_dict_to_html(self):
         array_str = ['table']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.tableHtml, self._json_data['table'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.tableHtml, response)
 
     def test_blockquote_list_in_supercharged_dict_to_html(self):
         array_str = ['blockquote']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.blockquoteHtml, self._json_data['blockquote'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.blockquoteHtml, response)
 
     def test_code_list_in_supercharged_dict_to_html(self):
         array_str = ['code']
-        Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.codeHtml, self._json_data['code'])
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.codeHtml, response)
 
     def test_linkin_list_in_supercharged_dict_to_html(self):
         array_str = ['link']
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.linkInPHtml, response)
+
+    def test_reference_list_in_supercharged_dict_to_html(self):
+        array_str = ['reference']
+        response = Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.refImgHtml, response)
+    
+    def test_nested_order_list_in_supercharged_dict_to_html(self):
+        array_str = ['nested_order_list_with_fragment']
         Utils.json_to_html([self._json_data], array_str, Options())
-        self.assertEqual(Results.linkInPHtml, self._json_data['link'])
+        self.assertEqual(Results.nested_order_list_with_fragment, "<ol><li><fragment>List Item 1</fragment><ol><li>List Item 1.1</li><li>List Item 1.2</li><li>List Item 1.3</li></ol></li></ol>")
 
-    # def test_reference_list_in_supercharged_dict_to_html(self):
-    #     array_str = ['reference']
-    #     Utils.json_to_html([self._json_data], array_str, Options())
-    #     self.assertEqual(Results.linkInPHtml, self._json_data['reference'])
+    def test_reference_image_in_supercharged_dict_to_html(self):
+         array_str = ['reference']
+         response = Utils.json_to_html([self._json_data], array_str, Options())
+         self.assertEqual(Results.refImgHtml, response)
     
     def test_nested_order_list_in_supercharged_dict_to_html(self):
         array_str = ['nested_order_list_with_fragment']

contentstack_utils-1.2.3/contentstack_utils.egg-info/SOURCES.txt

@@ -1,18 +0,0 @@
-LICENSE
-README.md
-setup.py
-contentstack_utils.egg-info/PKG-INFO
-contentstack_utils.egg-info/SOURCES.txt
-contentstack_utils.egg-info/dependency_links.txt
-contentstack_utils.egg-info/top_level.txt
-tests/test_default_opt_others.py
-tests/test_gql_to_html_func.py
-tests/test_helper_node_to_html.py
-tests/test_item_types.py
-tests/test_metadata.py
-tests/test_option_render_mark.py
-tests/test_render_default_options.py
-tests/test_render_options.py
-tests/test_style_type.py
-tests/test_util_srte.py
-tests/test_utils.py

contentstack_utils-1.2.3/contentstack_utils.egg-info/top_level.txt

@@ -1 +0,0 @@
-