contentstack-utils 1.2.3__py3-none-any.whl → 1.3.0__py3-none-any.whl

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.0'
+__endpoint__ = 'cdn.contentstack.io'
+__contact__ = 'support@contentstack.com'

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/embedded/__init__.py

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

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/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/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/helper/__init__.py

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

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/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/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/render/__init__.py

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

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"]["href"], 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/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.dist-info → contentstack_utils-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: contentstack_utils
-Version: 1.2.3
+Version: 1.3.0
 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.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+contentstack_utils/__init__.py,sha256=CfbGkFGBS_v7mfYxOo1QU35LLUUhX8muQ650EjzDisU,957
+contentstack_utils/automate.py,sha256=3tm43Y12dWZrJy6DR9tkAl4Dmph9-hNMXK94UWSKYso,7389
+contentstack_utils/gql.py,sha256=_r1K8pBduin_STrIo9IqdD3ftH0_3Ii6RSnTcrqwJlY,1587
+contentstack_utils/utils.py,sha256=4oIy_JBhpLW0CkxyZJ39ubj9u7Lw4sKRhOyg3cCStdM,4045
+contentstack_utils/embedded/__init__.py,sha256=0Ni3R_ia-HuTDFYQvoLURdeRkRD8HiyteiEEJ3O4V14,25
+contentstack_utils/embedded/item_type.py,sha256=yoB3ZTJ0IdwhL5E61zrxLXZSvcLMnnUiI6vi6jhR3Ww,239
+contentstack_utils/embedded/styletype.py,sha256=lwRV-tn1be3DPqeW3YnZPsWCXns9Xd0ml_hC5M87zow,443
+contentstack_utils/helper/__init__.py,sha256=0Ni3R_ia-HuTDFYQvoLURdeRkRD8HiyteiEEJ3O4V14,25
+contentstack_utils/helper/converter.py,sha256=2tZ6paPnWCCW0aoaQiMFGAhAdx4Bh2LsCnlCm3Q7yVw,391
+contentstack_utils/helper/metadata.py,sha256=YrNVhvkv4n_nR0nrJR2x2eqYE3-P1jT7ctVSklvnSgc,1795
+contentstack_utils/helper/node_to_html.py,sha256=himweM9ID4tQb7GNQP49XYTkN0KWWPy_LzBi-f6eS2E,1019
+contentstack_utils/render/__init__.py,sha256=0Ni3R_ia-HuTDFYQvoLURdeRkRD8HiyteiEEJ3O4V14,25
+contentstack_utils/render/options.py,sha256=hbqgPxCksgQlV5hK_6Flb2HEHaXk5JpMNc7z5yMxgCI,5033
+tests/__init__.py,sha256=stlQRdpO_kQoRExPLd-q80RCzHd-F4t1Rs6tZ0ObP2o,2336
+tests/convert_style.py,sha256=gXHQjSnxCZ7kQBG6TjKIYk-tvKhzdpeOBCA88YTcDC8,983
+tests/test_default_opt_others.py,sha256=H-xhmyGMJNET0kkhXGcyepWUTE0Vqd1DpzPCI6hKaro,2138
+tests/test_gql_to_html_func.py,sha256=oh7YpNay9GBBnVXbJhbh5e0r5eMYcrXhrzaiwuAQTOg,1180
+tests/test_helper_node_to_html.py,sha256=S3JSRv5FXyBnBXM23J7v9rtrIvODii0J9AEBMO4gve4,2497
+tests/test_item_types.py,sha256=lHKquAgitHEPquAR9Qyvcl2aWhXYaHJe9F1anCloYh0,350
+tests/test_metadata.py,sha256=B5SY50S7-bdzgSs5UDupcRWThzm3weyTNu4WqUBr3OY,1837
+tests/test_option_render_mark.py,sha256=NU7TOTJgljZyO5cnrphX-XyhJXUYqaZIbTzMJX0HOvY,2582
+tests/test_render_default_options.py,sha256=JNx_gA11Af-hPRoSd5MG59Cy5xjyUrpr8WXpVzqk6FY,3993
+tests/test_render_options.py,sha256=BFuf9nkh1c9BJ-UTFVBkmjBTf31pSeWJ2jTZY7XgVaY,1701
+tests/test_style_type.py,sha256=6Wz_UR5ZQcaUlB-Tfeqp6Dcu85AE7pHbtg6V1Sh7A9k,723
+tests/test_util_srte.py,sha256=vNb2xsrmGmGSonW_EzpItcqoQmnSWUmOlzybIo5fzik,5951
+tests/test_utils.py,sha256=2rvZZcT6m3QJZeyqzyp9ydsTX34w5tAkQOCKqXso3xw,3614
+contentstack_utils-1.3.0.dist-info/LICENSE,sha256=lNqz95ic6VWhDILAlbV_KgjGfl7GM1QQd6LKZq__zx4,1051
+contentstack_utils-1.3.0.dist-info/METADATA,sha256=3J3TPvQlfE0wmBcz1EweJYGRt6wzYdIH5jpWRI3UhgY,4906
+contentstack_utils-1.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+contentstack_utils-1.3.0.dist-info/top_level.txt,sha256=4b5I6taLW2KGOy1931_UZDIcML7HJEfjpzIDpz5MmTU,25
+contentstack_utils-1.3.0.dist-info/RECORD,,