contentstack-utils 1.3.3__tar.gz → 1.5.0__tar.gz

{contentstack_utils-1.3.3 → contentstack_utils-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentstack_utils
-Version: 1.3.3
+Version: 1.5.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.3 → contentstack_utils-1.5.0}/contentstack_utils/__init__.py

@@ -16,6 +16,7 @@ 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
+from contentstack_utils.entry_editable import addEditableTags, addTags, getTag
 
 __all__ = (
 "Utils",
@@ -25,12 +26,15 @@ __all__ = (
 "Automate",
 "StyleType",
 "ItemType",
-"NodeToHtml"
+"NodeToHtml",
+"addEditableTags",
+"addTags",
+"getTag",
 )
 
 __title__ = 'contentstack_utils'
 __author__ = 'contentstack'
 __status__ = 'debug'
-__version__ = '1.3.2'
+__version__ = '1.4.0'
 __endpoint__ = 'cdn.contentstack.io'
 __contact__ = 'support@contentstack.com'

contentstack_utils-1.5.0/contentstack_utils/entry_editable.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union, cast
+
+
+AppliedVariants = Optional[Dict[str, Any]]
+TagValue = Union[str, Dict[str, str]]
+
+
+def _get_parent_variantised_path(applied_variants: Dict[str, Any], meta_key: str) -> str:
+    """
+    Port of JS getParentVariantisedPath().
+    Finds the longest variantised field path that is a prefix of meta_key.
+    """
+    try:
+        if not meta_key:
+            return ""
+        variantised_field_paths = sorted(applied_variants.keys(), key=len, reverse=True)
+        child_fragments = meta_key.split(".")
+        if not child_fragments or not variantised_field_paths:
+            return ""
+        for path in variantised_field_paths:
+            parent_fragments = str(path).split(".")
+            if len(parent_fragments) > len(child_fragments):
+                continue
+            if all(child_fragments[i] == parent_fragments[i] for i in range(len(parent_fragments))):
+                return str(path)
+        return ""
+    except Exception:
+        return ""
+
+
+def _apply_variant_to_data_value(data_value: str, applied_variants: AppliedVariants, meta_key: str, should_apply_variant: bool) -> str:
+    """
+    Port of JS applyVariantToDataValue().
+
+    If the current field (or its parent field path) is variantised, prefixes with
+    'v2:' and appends `_{variant}` to the entry uid segment of the dot-path.
+    """
+    if not should_apply_variant or not applied_variants or not meta_key or not isinstance(applied_variants, dict):
+        return data_value
+
+    variant: Optional[str] = None
+    if meta_key in applied_variants:
+        variant = str(applied_variants[meta_key])
+    else:
+        parent_path = _get_parent_variantised_path(applied_variants, meta_key)
+        if parent_path:
+            variant = str(applied_variants.get(parent_path))
+
+    if not variant:
+        return data_value
+
+    parts = ("v2:" + data_value).split(".")
+    if len(parts) >= 2:
+        parts[1] = parts[1] + "_" + variant
+    return ".".join(parts)
+
+
+def _tags_value(data_value: str, tags_as_object: bool, applied_variants: AppliedVariants, meta_key: str, should_apply_variant: bool) -> TagValue:
+    resolved = _apply_variant_to_data_value(data_value, applied_variants, meta_key, should_apply_variant)
+    if tags_as_object:
+        return {"data-cslp": resolved}
+    return f"data-cslp={resolved}"
+
+
+def _parent_tags_value(data_value: str, tags_as_object: bool) -> TagValue:
+    if tags_as_object:
+        return {"data-cslp-parent-field": data_value}
+    return f"data-cslp-parent-field={data_value}"
+
+
+def getTag(  # pylint: disable=invalid-name
+    content: Any,
+    prefix: str,
+    tags_as_object: bool,
+    locale: str,
+    applied_variants: AppliedVariants,
+    should_apply_variant: bool,
+    meta_key: str = "",
+) -> Dict[str, Any]:
+    """
+    Port of JS getTag() from `src/entry-editable.ts`.
+
+    Returns a dict mapping field keys to CSLP tag values, and mutates nested objects/refs
+    by attaching their own `$` tag maps.
+    """
+    if content is None or not isinstance(content, dict):
+        return {}
+
+    tags: Dict[str, Any] = {}
+    for key, value in content.items():
+        if key == "$":
+            continue
+
+        meta_uid = ""
+        if isinstance(value, dict):
+            meta = value.get("_metadata")
+            if isinstance(meta, dict) and meta.get("uid"):
+                meta_uid = str(meta.get("uid"))
+
+        meta_key_prefix = (meta_key + ".") if meta_key else ""
+        updated_meta_key = f"{meta_key_prefix}{key}" if should_apply_variant else ""
+        if meta_uid and updated_meta_key:
+            updated_meta_key = updated_meta_key + "." + meta_uid
+
+        if isinstance(value, list):
+            for index, obj in enumerate(value):
+                if obj is None:
+                    continue
+
+                child_key = f"{key}__{index}"
+                parent_key = f"{key}__parent"
+
+                obj_meta_uid = ""
+                if isinstance(obj, dict):
+                    meta = obj.get("_metadata")
+                    if isinstance(meta, dict) and meta.get("uid"):
+                        obj_meta_uid = str(meta.get("uid"))
+
+                array_meta_key = f"{meta_key_prefix}{key}" if should_apply_variant else ""
+                if obj_meta_uid and array_meta_key:
+                    array_meta_key = array_meta_key + "." + obj_meta_uid
+
+                tags[child_key] = _tags_value(
+                    f"{prefix}.{key}.{index}",
+                    tags_as_object,
+                    applied_variants,
+                    array_meta_key,
+                    should_apply_variant,
+                )
+                tags[parent_key] = _parent_tags_value(f"{prefix}.{key}", tags_as_object)
+
+                # Reference entries in array
+                if isinstance(obj, dict) and obj.get("_content_type_uid") is not None and obj.get("uid") is not None:
+                    new_applied_variants = obj.get("_applied_variants")
+                    if new_applied_variants is None and isinstance(obj.get("system"), dict):
+                        new_applied_variants = cast(dict, obj["system"]).get("applied_variants")
+                    new_should_apply_variant = bool(new_applied_variants)
+
+                    obj_locale = obj.get("locale") or locale
+                    obj["$"] = getTag(
+                        obj,
+                        f"{obj.get('_content_type_uid')}.{obj.get('uid')}.{obj_locale}",
+                        tags_as_object,
+                        locale,
+                        cast(AppliedVariants, new_applied_variants),
+                        new_should_apply_variant,
+                        meta_key="",
+                    )
+                    continue
+
+                if isinstance(obj, dict):
+                    obj["$"] = getTag(
+                        obj,
+                        f"{prefix}.{key}.{index}",
+                        tags_as_object,
+                        locale,
+                        applied_variants,
+                        should_apply_variant,
+                        meta_key=array_meta_key,
+                    )
+
+            tags[key] = _tags_value(
+                f"{prefix}.{key}",
+                tags_as_object,
+                applied_variants,
+                updated_meta_key,
+                should_apply_variant,
+            )
+            continue
+
+        if isinstance(value, dict):
+            value["$"] = getTag(
+                value,
+                f"{prefix}.{key}",
+                tags_as_object,
+                locale,
+                applied_variants,
+                should_apply_variant,
+                meta_key=updated_meta_key,
+            )
+            tags[key] = _tags_value(
+                f"{prefix}.{key}",
+                tags_as_object,
+                applied_variants,
+                updated_meta_key,
+                should_apply_variant,
+            )
+            continue
+
+        tags[key] = _tags_value(
+            f"{prefix}.{key}",
+            tags_as_object,
+            applied_variants,
+            updated_meta_key,
+            should_apply_variant,
+        )
+
+    return tags
+
+
+def addTags(  # pylint: disable=invalid-name
+    entry: Optional[dict],
+    contentTypeUid: str,
+    tagsAsObject: bool,
+    locale: str = "en-us",
+    options: Optional[dict] = None,
+) -> None:
+    """
+    Port of JS addTags() from `src/entry-editable.ts`.
+    Mutates `entry` by attaching a `$` dict of CSLP tags.
+    """
+    if not entry:
+        return
+
+    use_lower_case_locale = True
+    if isinstance(options, dict) and "useLowerCaseLocale" in options:
+        use_lower_case_locale = bool(options.get("useLowerCaseLocale"))
+
+    content_type_uid = (contentTypeUid or "").lower()
+    resolved_locale = (locale or "en-us")
+    if use_lower_case_locale:
+        resolved_locale = resolved_locale.lower()
+
+    applied_variants = entry.get("_applied_variants")
+    if applied_variants is None and isinstance(entry.get("system"), dict):
+        applied_variants = cast(dict, entry["system"]).get("applied_variants")
+    should_apply_variant = bool(applied_variants)
+
+    entry["$"] = getTag(
+        entry,
+        f"{content_type_uid}.{entry.get('uid')}.{resolved_locale}",
+        tagsAsObject,
+        resolved_locale,
+        cast(AppliedVariants, applied_variants),
+        should_apply_variant,
+        meta_key="",
+    )
+
+
+# JS parity export name
+addEditableTags = addTags  # pylint: disable=invalid-name
+
+# Pythonic aliases
+add_tags = addTags
+get_tags = getTag
+

contentstack_utils-1.5.0/contentstack_utils/utils.py

@@ -0,0 +1,238 @@
+# pylint: disable=missing-function-docstring
+
+import json
+from typing import Any, Dict, List, Optional, Union
+
+from lxml import etree
+
+from contentstack_utils.automate import Automate
+from contentstack_utils.entry_editable import addEditableTags as _addEditableTags
+from contentstack_utils.entry_editable import addTags as _addTags
+from contentstack_utils.entry_editable import getTag as _getTag
+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):
+    # JS parity helpers (moved to `contentstack_utils/entry_editable.py`)
+    @staticmethod
+    def addTags(  # pylint: disable=invalid-name
+        entry: dict,
+        contentTypeUid: str,
+        tagsAsObject: Optional[bool] = None,
+        locale: str = "en-us",
+        options: Optional[dict] = None,
+        **kwargs,
+    ) -> None:
+        # Support pythonic kwarg name too (backward compatibility with earlier port).
+        if tagsAsObject is None and "tags_as_object" in kwargs:
+            tagsAsObject = bool(kwargs["tags_as_object"])
+        if tagsAsObject is None:
+            tagsAsObject = False
+        return _addTags(entry, contentTypeUid, tagsAsObject, locale, options)
+
+    @staticmethod
+    def addEditableTags(  # pylint: disable=invalid-name
+        entry: dict,
+        contentTypeUid: str,
+        tagsAsObject: Optional[bool] = None,
+        locale: str = "en-us",
+        options: Optional[dict] = None,
+        **kwargs,
+    ) -> None:
+        if tagsAsObject is None and "tags_as_object" in kwargs:
+            tagsAsObject = bool(kwargs["tags_as_object"])
+        if tagsAsObject is None:
+            tagsAsObject = False
+        return _addEditableTags(entry, contentTypeUid, tagsAsObject, locale, options)
+
+    @staticmethod
+    def getTag(  # pylint: disable=invalid-name
+        content: Any,
+        prefix: str,
+        tagsAsObject: bool,
+        locale: str,
+        appliedVariants: Optional[dict],
+        shouldApplyVariant: bool,
+        metaKey: str = "",
+    ) -> Dict[str, Any]:
+        # Keep JS argument names for parity.
+        return _getTag(content, prefix, tagsAsObject, locale, appliedVariants, shouldApplyVariant, metaKey)
+
+    # Pythonic aliases
+    add_tags = addTags
+    get_tags = getTag
+    get_tag = getTag
+
+    @staticmethod
+    def _variants_map_from_entry(entry: dict) -> dict:
+        publish_details = entry.get("publish_details")
+        if not isinstance(publish_details, dict):
+            return {}
+        raw = publish_details.get("variants")
+        return raw if isinstance(raw, dict) else {}
+
+    @staticmethod
+    def _aliases_from_variants_map(variants_map: dict) -> List[str]:
+        aliases: List[str] = []
+        for _variant_uid, value in variants_map.items():
+            if not isinstance(value, dict):
+                continue
+            alias = value.get("alias")
+            if alias is None:
+                continue
+            alias_str = str(alias).strip()
+            if alias_str:
+                aliases.append(alias_str)
+        return aliases
+
+    @staticmethod
+    def _variant_aliases_for_entry(entry: dict, content_type_uid: str = "") -> Dict[str, Any]:
+        if entry is None:
+            raise ValueError("entry cannot be None")
+        if not isinstance(entry, dict):
+            raise TypeError("entry must be a dict")
+        uid = entry.get("uid")
+        if uid is None or (isinstance(uid, str) and uid.strip() == ""):
+            raise ValueError("entry must contain a non-empty uid")
+        entry_uid = str(uid)
+        ct = entry.get("_content_type_uid")
+        if ct is None or ct == "":
+            ct = content_type_uid or ""
+        contenttype_uid = "" if ct is None else str(ct)
+        variants_map = Utils._variants_map_from_entry(entry)
+        aliases = Utils._aliases_from_variants_map(variants_map)
+        return {
+            "entry_uid": entry_uid,
+            "contenttype_uid": contenttype_uid,
+            "variants": aliases,
+        }
+
+    @staticmethod
+    def get_variant_aliases(
+        entry_or_entries: Union[dict, List[dict]],
+        content_type_uid: str = "",
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """
+        Extract variant aliases from a CDA entry (or list of entries).
+
+        The entry must have been fetched with ``x-cs-variant-uid`` set to variant
+        aliases (not UIDs) for ``publish_details.variants`` to be present.
+
+        :param entry_or_entries: A single entry dict, or a list of entry dicts.
+        :param content_type_uid: Used when ``entry._content_type_uid`` is absent;
+            ignored when ``entry_or_entries`` is a list (each entry supplies its own).
+        :raises ValueError: if ``entry_or_entries`` is None, an entry is None, or an
+            entry has no non-empty ``uid``.
+        :raises TypeError: if a single entry is not a dict, or a list is expected but
+            another type was passed for the multi-entry overload.
+        """
+        if entry_or_entries is None:
+            raise ValueError("entry is required and cannot be None")
+        if isinstance(entry_or_entries, list):
+            return [Utils._variant_aliases_for_entry(e, "") for e in entry_or_entries]
+        if isinstance(entry_or_entries, dict):
+            return Utils._variant_aliases_for_entry(entry_or_entries, content_type_uid or "")
+        raise TypeError("entry must be a dict or a list of dicts")
+
+    @staticmethod
+    def get_variant_metadata_tags(entries: List[dict]) -> Dict[str, str]:
+        """
+        Build a ``data-csvariants`` HTML data-attribute payload from entry objects.
+
+        :param entries: List of CDA entry dicts (same shape as for multi-entry
+            :meth:`get_variant_aliases`).
+        :raises ValueError: if ``entries`` is None.
+        :raises TypeError: if ``entries`` is not a list.
+        """
+        if entries is None:
+            raise ValueError("entries is required and cannot be None")
+        if not isinstance(entries, list):
+            raise TypeError("entries must be a list")
+        results = Utils.get_variant_aliases(entries)
+        payload = json.dumps(results, separators=(",", ":"))
+        return {"data-csvariants": payload}
+
+    @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.3.3 → contentstack_utils-1.5.0}/contentstack_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentstack_utils
-Version: 1.3.3
+Version: 1.5.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.3 → contentstack_utils-1.5.0}/contentstack_utils.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 setup.py
 contentstack_utils/__init__.py
 contentstack_utils/automate.py
+contentstack_utils/entry_editable.py
 contentstack_utils/gql.py
 contentstack_utils/utils.py
 contentstack_utils.egg-info/PKG-INFO
@@ -21,6 +22,7 @@ contentstack_utils/render/options.py
 tests/__init__.py
 tests/convert_style.py
 tests/test_default_opt_others.py
+tests/test_editable_tags.py
 tests/test_gql_to_html_func.py
 tests/test_helper_node_to_html.py
 tests/test_item_types.py
@@ -30,4 +32,5 @@ 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
+tests/test_utils.py
+tests/test_variant_aliases.py

{contentstack_utils-1.3.3 → contentstack_utils-1.5.0}/setup.py

@@ -15,7 +15,7 @@ setup(
     long_description_content_type="text/markdown",
     url="https://github.com/contentstack/contentstack-utils-python",
     license='MIT',
-    version='1.3.3',
+    version='1.5.0',
     install_requires=[
         
     ],

{contentstack_utils-1.3.3 → contentstack_utils-1.5.0}/tests/convert_style.py

@@ -10,7 +10,7 @@ class TestConvertStyle(unittest.TestCase):
 
     def test_converter_style_block(self):
         _returns = converter.convert_style('block')
-        self.assertEquals(StyleType.BLOCK, _returns)
+        self.assertEqual(StyleType.BLOCK, _returns)
 
     def test_converter_style_inline(self):
         _returns = converter.convert_style('inline')

contentstack_utils-1.5.0/tests/test_editable_tags.py

@@ -0,0 +1,56 @@
+import unittest
+
+from contentstack_utils.utils import Utils
+
+
+class TestEditableTags(unittest.TestCase):
+    def test_add_tags_mutates_entry_with_dollar_map(self):
+        entry = {"uid": "e1", "title": "Hello", "count": 1}
+        Utils.addTags(entry, "Blog_Post", tags_as_object=True, locale="EN-us")
+        self.assertIn("$", entry)
+        self.assertEqual(entry["$"]["title"], {"data-cslp": "blog_post.e1.en-us.title"})
+        self.assertEqual(entry["$"]["count"], {"data-cslp": "blog_post.e1.en-us.count"})
+
+    def test_add_tags_string_mode(self):
+        entry = {"uid": "e1", "title": "Hello"}
+        Utils.addTags(entry, "blog_post", tags_as_object=False, locale="en-us")
+        self.assertEqual(entry["$"]["title"], "data-cslp=blog_post.e1.en-us.title")
+
+    def test_array_tags_add_index_and_parent_keys(self):
+        entry = {"uid": "e1", "array": ["hello", "world"]}
+        Utils.addTags(entry, "blog", tags_as_object=True, locale="en-us")
+        self.assertEqual(entry["$"]["array"], {"data-cslp": "blog.e1.en-us.array"})
+        self.assertEqual(entry["$"]["array__0"], {"data-cslp": "blog.e1.en-us.array.0"})
+        self.assertEqual(entry["$"]["array__1"], {"data-cslp": "blog.e1.en-us.array.1"})
+        self.assertEqual(entry["$"]["array__parent"], {"data-cslp-parent-field": "blog.e1.en-us.array"})
+
+    def test_reference_entry_inside_array_gets_own_dollar(self):
+        entry = {
+            "uid": "e1",
+            "refs": [
+                {
+                    "uid": "r1",
+                    "_content_type_uid": "ref_ct",
+                    "title": "Ref Title",
+                }
+            ],
+        }
+        Utils.addTags(entry, "blog", tags_as_object=True, locale="en-us")
+        ref = entry["refs"][0]
+        self.assertIn("$", ref)
+        self.assertEqual(ref["$"]["title"], {"data-cslp": "ref_ct.r1.en-us.title"})
+
+    def test_variantised_field_applies_v2_prefix_and_uid_suffix(self):
+        entry = {
+            "uid": "e1",
+            "_applied_variants": {"title": "v123"},
+            "title": {"value": "Hello"},
+        }
+        Utils.addTags(entry, "blog", tags_as_object=True, locale="en-us")
+        # title is an object; ensure we tag the object itself (like JS) and apply variant.
+        self.assertEqual(entry["$"]["title"], {"data-cslp": "v2:blog.e1_v123.en-us.title"})
+
+
+if __name__ == "__main__":
+    unittest.main()
+

contentstack_utils-1.5.0/tests/test_variant_aliases.py

@@ -0,0 +1,164 @@
+import json
+import unittest
+
+from contentstack_utils.utils import Utils
+
+
+class TestVariantAliases(unittest.TestCase):
+
+    def _sample_entry(self):
+        return {
+            "uid": "blt3e91e3812a44ba90",
+            "_content_type_uid": "landing_page",
+            "publish_details": {
+                "variants": {
+                    "cs669f1759b774fe1d": {
+                        "alias": "cs_personalize_0_2",
+                        "environment": "bltb5963e2163c24eb6",
+                        "locale": "en",
+                    },
+                    "csbf165536748bdee2": {
+                        "alias": "cs_personalize_0_1",
+                        "environment": "bltb5963e2163c24eb6",
+                        "locale": "en",
+                    },
+                }
+            },
+        }
+
+    def test_single_entry_extracts_aliases(self):
+        result = Utils.get_variant_aliases(self._sample_entry())
+        self.assertEqual(result["entry_uid"], "blt3e91e3812a44ba90")
+        self.assertEqual(result["contenttype_uid"], "landing_page")
+        self.assertEqual(
+            result["variants"],
+            ["cs_personalize_0_2", "cs_personalize_0_1"],
+        )
+
+    def test_content_type_from_parameter_when_missing_on_entry(self):
+        entry = {
+            "uid": "blt1",
+            "publish_details": {"variants": {}},
+        }
+        result = Utils.get_variant_aliases(entry, "landing_page")
+        self.assertEqual(result["contenttype_uid"], "landing_page")
+
+    def test_empty_contenttype_when_missing(self):
+        entry = {"uid": "blt1", "publish_details": {"variants": {}}}
+        result = Utils.get_variant_aliases(entry)
+        self.assertEqual(result["contenttype_uid"], "")
+
+    def test_missing_publish_details(self):
+        entry = {"uid": "blt1", "_content_type_uid": "page"}
+        result = Utils.get_variant_aliases(entry)
+        self.assertEqual(result["variants"], [])
+
+    def test_missing_variants_key(self):
+        entry = {"uid": "blt1", "publish_details": {}}
+        result = Utils.get_variant_aliases(entry)
+        self.assertEqual(result["variants"], [])
+
+    def test_empty_variants_object(self):
+        entry = {"uid": "blt1", "publish_details": {"variants": {}}}
+        result = Utils.get_variant_aliases(entry)
+        self.assertEqual(result["variants"], [])
+
+    def test_skips_variant_without_alias(self):
+        entry = {
+            "uid": "blt1",
+            "publish_details": {
+                "variants": {
+                    "a": {"alias": "ok"},
+                    "b": {},
+                    "c": {"alias": ""},
+                    "d": {"alias": "   "},
+                }
+            },
+        }
+        result = Utils.get_variant_aliases(entry)
+        self.assertEqual(result["variants"], ["ok"])
+
+    def test_non_dict_variant_value_skipped(self):
+        entry = {
+            "uid": "blt1",
+            "publish_details": {"variants": {"x": "not-a-dict"}},
+        }
+        result = Utils.get_variant_aliases(entry)
+        self.assertEqual(result["variants"], [])
+
+    def test_none_entry_raises(self):
+        with self.assertRaises(ValueError):
+            Utils.get_variant_aliases(None)
+
+    def test_missing_uid_raises(self):
+        with self.assertRaises(ValueError):
+            Utils.get_variant_aliases({"publish_details": {}})
+
+    def test_empty_uid_raises(self):
+        with self.assertRaises(ValueError):
+            Utils.get_variant_aliases({"uid": ""})
+
+    def test_whitespace_uid_raises(self):
+        with self.assertRaises(ValueError):
+            Utils.get_variant_aliases({"uid": "   "})
+
+    def test_non_dict_entry_raises(self):
+        with self.assertRaises(TypeError):
+            Utils.get_variant_aliases("not-a-dict")
+
+    def test_multiple_entries(self):
+        results = Utils.get_variant_aliases(
+            [
+                {
+                    "uid": "blt123",
+                    "_content_type_uid": "page",
+                    "publish_details": {
+                        "variants": {
+                            "v1": {"alias": "cs_personalize_3_1"},
+                            "v2": {"alias": "cs_personalize_4_0"},
+                        }
+                    },
+                },
+                {"uid": "blt456", "_content_type_uid": "page"},
+            ]
+        )
+        self.assertEqual(len(results), 2)
+        self.assertEqual(results[0]["entry_uid"], "blt123")
+        self.assertEqual(
+            results[0]["variants"],
+            ["cs_personalize_3_1", "cs_personalize_4_0"],
+        )
+        self.assertEqual(results[1]["variants"], [])
+
+    def test_list_entry_none_raises(self):
+        with self.assertRaises(ValueError):
+            Utils.get_variant_aliases([None])
+
+    def test_get_variant_metadata_tags(self):
+        entries = [
+            {
+                "uid": "blt123",
+                "_content_type_uid": "page",
+                "publish_details": {
+                    "variants": {"v1": {"alias": "cs_personalize_3_1"}}
+                },
+            }
+        ]
+        tag = Utils.get_variant_metadata_tags(entries)
+        self.assertIn("data-csvariants", tag)
+        parsed = json.loads(tag["data-csvariants"])
+        self.assertEqual(len(parsed), 1)
+        self.assertEqual(parsed[0]["entry_uid"], "blt123")
+        self.assertEqual(parsed[0]["variants"], ["cs_personalize_3_1"])
+
+    def test_get_variant_metadata_tags_none_raises(self):
+        with self.assertRaises(ValueError):
+            Utils.get_variant_metadata_tags(None)
+
+    def test_get_variant_metadata_tags_not_list_raises(self):
+        with self.assertRaises(TypeError):
+            Utils.get_variant_metadata_tags({})
+
+
+if __name__ == "__main__":
+    unittest.main()

contentstack_utils-1.3.3/contentstack_utils/utils.py

@@ -1,94 +0,0 @@
-# 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