Contentstack 2.1.0__tar.gz → 2.2.0__tar.gz

{contentstack-2.1.0 → contentstack-2.2.0}/Contentstack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Contentstack
-Version: 2.1.0
+Version: 2.2.0
 Summary: Contentstack is a headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-python
 Author: Contentstack

{contentstack-2.1.0 → contentstack-2.2.0}/Contentstack.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ contentstack/image_transform.py
 contentstack/query.py
 contentstack/stack.py
 contentstack/utility.py
+contentstack/variants.py
 tests/test_assets.py
 tests/test_early_fetch.py
 tests/test_early_find.py

{contentstack-2.1.0 → contentstack-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Contentstack
-Version: 2.1.0
+Version: 2.2.0
 Summary: Contentstack is a headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-python
 Author: Contentstack

{contentstack-2.1.0 → contentstack-2.2.0}/contentstack/__init__.py

@@ -22,7 +22,7 @@ __all__ = (
 __title__ = 'contentstack-delivery-python'
 __author__ = 'contentstack'
 __status__ = 'debug'
-__version__ = 'v2.1.0'
+__version__ = 'v2.2.0'
 __endpoint__ = 'cdn.contentstack.io'
 __email__ = 'support@contentstack.com'
 __developer_email__ = 'mobile@contentstack.com'

{contentstack-2.1.0 → contentstack-2.2.0}/contentstack/contenttype.py

@@ -13,6 +13,7 @@ from urllib import parse
 
 from contentstack.entry import Entry
 from contentstack.query import Query
+from contentstack.variants import Variants
 
 class ContentType:
     """
@@ -118,3 +119,18 @@ class ContentType:
         url = f'{endpoint}/content_types?{encoded_params}'
         result = self.http_instance.get(url)
         return result
+    
+    def variants(self, variant_uid: str | list[str], params: dict = None):
+        """
+        Fetches the variants of the content type
+        :param variant_uid: {str} -- variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        return Variants(
+            http_instance=self.http_instance,
+            content_type_uid=self.__content_type_uid,
+            entry_uid=None,
+            variant_uid=variant_uid,
+            params=params,
+            logger=None
+        )

{contentstack-2.1.0 → contentstack-2.2.0}/contentstack/entry.py

@@ -8,6 +8,7 @@ from urllib import parse
 
 from contentstack.deep_merge_lp import DeepMergeMixin
 from contentstack.entryqueryable import EntryQueryable
+from contentstack.variants import Variants
 
 class Entry(EntryQueryable):
     """
@@ -222,6 +223,22 @@ class Entry(EntryQueryable):
             merged_response = DeepMergeMixin(entry_response, lp_entry).to_dict()  # Convert to dictionary
             return merged_response  # Now correctly returns a dictionary
         raise ValueError("Missing required keys in live_preview data")
+    
+    def variants(self, variant_uid: str | list[str], params: dict = None):
+        """
+        Fetches the variants of the entry
+        :param variant_uid: {str} -- variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        return Variants(
+            http_instance=self.http_instance,
+            content_type_uid=self.content_type_id,
+            entry_uid=self.entry_uid,
+            variant_uid=variant_uid,
+            params=params,
+            logger=self.logger
+        )
+
 
 
 

contentstack-2.2.0/contentstack/variants.py

@@ -0,0 +1,93 @@
+import logging
+from urllib import parse
+
+from contentstack.entryqueryable import EntryQueryable
+
+class Variants(EntryQueryable):
+    """
+    An entry is the actual piece of content that you want to publish.
+    Entries can be created for one of the available content types.
+
+    Entry works with
+    version={version_number}
+    environment={environment_name}
+    locale={locale_code}
+    """
+
+    def __init__(self,
+        http_instance=None,
+        content_type_uid=None,
+        entry_uid=None,
+        variant_uid=None,
+        params=None,
+        logger=None):
+        
+        super().__init__()
+        EntryQueryable.__init__(self)
+        self.entry_param = {}
+        self.http_instance = http_instance
+        self.content_type_id = content_type_uid
+        self.entry_uid = entry_uid
+        self.variant_uid = variant_uid
+        self.logger = logger or logging.getLogger(__name__)
+        self.entry_param = params or {}
+
+    def find(self, params=None):
+        """
+        find the variants of the entry of a particular content type
+        :param self.variant_uid: {str} -- self.variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        headers = self.http_instance.headers.copy()  # Create a local copy of headers
+        if isinstance(self.variant_uid, str):
+            headers['x-cs-variant-uid'] = self.variant_uid
+        elif isinstance(self.variant_uid, list):
+            headers['x-cs-variant-uid'] = ','.join(self.variant_uid)
+        
+        if params is not None:
+            self.entry_param.update(params)
+        encoded_params = parse.urlencode(self.entry_param)
+        endpoint = self.http_instance.endpoint
+        url = f'{endpoint}/content_types/{self.content_type_id}/entries?{encoded_params}'
+        self.http_instance.headers.update(headers)
+        result = self.http_instance.get(url)
+        self.http_instance.headers.pop('x-cs-variant-uid', None)
+        return result
+    
+    def fetch(self, params=None):
+        """
+        This method is useful to fetch variant entries of a particular content type and entries of the of the stack.
+        :return:dict -- contentType response
+        ------------------------------
+        Example:
+
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> some_dict = {'abc':'something'}
+            >>> response = content_type.fetch(some_dict)
+        ------------------------------
+        """
+        """
+        Fetches the variants of the entry
+        :param self.variant_uid: {str} -- self.variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        if self.entry_uid is None:
+            raise ValueError("entry_uid is required")
+        else:
+            headers = self.http_instance.headers.copy()  # Create a local copy of headers
+            if isinstance(self.variant_uid, str):
+                headers['x-cs-variant-uid'] = self.variant_uid
+            elif isinstance(self.variant_uid, list):
+                headers['x-cs-variant-uid'] = ','.join(self.variant_uid)
+            
+            if params is not None:
+                self.entry_param.update(params)
+            encoded_params = parse.urlencode(self.entry_param)
+            endpoint = self.http_instance.endpoint
+            url = f'{endpoint}/content_types/{self.content_type_id}/entries/{self.entry_uid}?{encoded_params}'
+            self.http_instance.headers.update(headers)
+            result = self.http_instance.get(url)
+            self.http_instance.headers.pop('x-cs-variant-uid', None)
+            return result

{contentstack-2.1.0 → contentstack-2.2.0}/tests/test_entry.py

@@ -3,12 +3,12 @@ import unittest
 import config
 import contentstack
 
-_UID = 'blt53ca1231625bdde4'
 API_KEY = config.APIKEY
 DELIVERY_TOKEN = config.DELIVERYTOKEN
 ENVIRONMENT = config.ENVIRONMENT
 HOST = config.HOST
-
+FAQ_UID = config.FAQ_UID  # Add this in your config.py
+VARIANT_UID = config.VARIANT_UID
 
 class TestEntry(unittest.TestCase):
 
@@ -19,69 +19,54 @@ class TestEntry(unittest.TestCase):
         query = self.stack.content_type('faq').query()
         result = query.find()
         if result is not None:
-            self._UID = result['entries'][0]['uid']
-            print(f'the uid is: {_UID}')
+            self.faq_uid = result['entries'][0]['uid']
+            print(f'the uid is: {self.faq_uid}')
 
     def test_entry_by_UID(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID)
+        entry = self.stack.content_type('faq').entry(FAQ_UID)
         result = entry.fetch()
         if result is not None:
-            _UID = result['entry']['uid']
-            self.assertEqual(_UID, result['entry']['uid'])
+            self.assertEqual(FAQ_UID, result['entry']['uid'])
 
     def test_03_entry_environment(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).environment('test')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).environment('test')
         self.assertEqual("test", entry.http_instance.headers['environment'])
 
     def test_04_entry_locale(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID).locale('en-ei')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).locale('en-ei')
         entry.fetch()
         self.assertEqual('en-ei', entry.entry_param['locale'])
 
     def test_05_entry_version(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID).version(3)
+        entry = self.stack.content_type('faq').entry(FAQ_UID).version(3)
         entry.fetch()
         self.assertEqual(3, entry.entry_param['version'])
 
     def test_06_entry_params(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).param('param_key', 'param_value')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).param('param_key', 'param_value')
         entry.fetch()
         self.assertEqual('param_value', entry.entry_param['param_key'])
 
     def test_07_entry_base_only(self):
-        global _UID
-        entry = self.stack.content_type(
-            'faq').entry(_UID).only('field_UID')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).only('field_UID')
         entry.fetch()
         self.assertEqual({'environment': 'development',
                           'only[BASE][]': 'field_UID'}, entry.entry_param)
 
     def test_08_entry_base_excepts(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).excepts('field_UID')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).excepts('field_UID')
         entry.fetch()
         self.assertEqual({'environment': 'development',
                           'except[BASE][]': 'field_UID'}, entry.entry_param)
 
     def test_10_entry_base_include_reference_only(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID).only('field1')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).only('field1')
         entry.fetch()
         self.assertEqual({'environment': 'development', 'only[BASE][]': 'field1'},
                          entry.entry_param)
 
     def test_11_entry_base_include_reference_excepts(self):
-        global _UID
-        entry = self.stack.content_type(
-            'faq').entry(_UID).excepts('field1')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).excepts('field1')
         entry.fetch()
         self.assertEqual({'environment': 'development', 'except[BASE][]': 'field1'},
                          entry.entry_param)
@@ -95,15 +80,13 @@ class TestEntry(unittest.TestCase):
         response = _entry.fetch()
 
     def test_13_entry_support_include_fallback_unit_test(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).include_fallback()
+        entry = self.stack.content_type('faq').entry(FAQ_UID).include_fallback()
         self.assertEqual(
             True, entry.entry_param.__contains__('include_fallback'))
 
     def test_14_entry_queryable_only(self):
         try:
-            entry = self.stack.content_type('faq').entry(_UID).only(4)
+            entry = self.stack.content_type('faq').entry(FAQ_UID).only(4)
             result = entry.fetch()
             self.assertEqual(None, result['uid'])
         except KeyError as e:
@@ -112,7 +95,7 @@ class TestEntry(unittest.TestCase):
 
     def test_entry_queryable_excepts(self):
         try:
-            entry = self.stack.content_type('faq').entry(_UID).excepts(4)
+            entry = self.stack.content_type('faq').entry(FAQ_UID).excepts(4)
             result = entry.fetch()
             self.assertEqual(None, result['uid'])
         except KeyError as e:
@@ -120,20 +103,17 @@ class TestEntry(unittest.TestCase):
                 self.assertEqual("Invalid field_UID provided", e.args[0])
 
     def test_16_entry_queryable_include_content_type(self):
-        entry = self.stack.content_type('faq').entry(
-            _UID).include_content_type()
+        entry = self.stack.content_type('faq').entry(FAQ_UID).include_content_type()
         self.assertEqual({'include_content_type': 'true', 'include_global_field_schema': 'true'},
                          entry.entry_queryable_param)
 
     def test_reference_content_type_uid(self):
-        entry = self.stack.content_type('faq').entry(
-            _UID).include_reference_content_type_uid()
+        entry = self.stack.content_type('faq').entry(FAQ_UID).include_reference_content_type_uid()
         self.assertEqual({'include_reference_content_type_uid': 'true'},
                          entry.entry_queryable_param)
 
     def test_19_entry_queryable_add_param(self):
-        entry = self.stack.content_type('faq').entry(
-            _UID).add_param('cms', 'contentstack')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).add_param('cms', 'contentstack')
         self.assertEqual({'cms': 'contentstack'}, entry.entry_queryable_param)
 
     def test_20_entry_include_fallback(self):
@@ -154,6 +134,28 @@ class TestEntry(unittest.TestCase):
         content_type = self.stack.content_type('faq')
         entry = content_type.entry("878783238783").include_metadata()
         self.assertEqual({'include_metadata': 'true'}, entry.entry_queryable_param)
+                
+    def test_23_content_type_variants(self):
+        content_type = self.stack.content_type('faq')
+        entry = content_type.variants(VARIANT_UID).find()
+        self.assertIn('variants', entry['entries'][0]['publish_details'])
+        
+    def test_24_entry_variants(self):
+        content_type = self.stack.content_type('faq')
+        entry = content_type.entry(FAQ_UID).variants(VARIANT_UID).fetch()
+        self.assertIn('variants', entry['entry']['publish_details'])
+        
+    def test_25_content_type_variants_with_has_hash_variant(self):
+        content_type = self.stack.content_type('faq')
+        entry = content_type.variants([VARIANT_UID]).find()
+        self.assertIn('variants', entry['entries'][0]['publish_details'])
+        
+    def test_25_content_type_entry_variants_with_has_hash_variant(self):
+        content_type = self.stack.content_type('faq').entry(FAQ_UID)
+        entry = content_type.variants([VARIANT_UID]).fetch()
+        self.assertIn('variants', entry['entry']['publish_details'])
+        
+        
 
 
 if __name__ == '__main__':

{contentstack-2.1.0 → contentstack-2.2.0}/tests/test_live_preview.py

@@ -4,9 +4,9 @@ import config
 import contentstack
 from contentstack.deep_merge_lp import DeepMergeMixin
 
-management_token = 'cs8743874323343u9'
-entry_uid = 'blt8743874323343u9'
-preview_token = 'abcdefgh1234567890'
+management_token = config.MANAGEMENT_TOKEN
+entry_uid = config.LIVE_PREVIEW_ENTRY_UID
+preview_token = config.PREVIEW_TOKEN
 
 _lp_query = {
     'live_preview': '#0#0#0#0#0#0#0#0#0#',

{contentstack-2.1.0 → contentstack-2.2.0}/tests/test_stack.py

@@ -131,11 +131,14 @@ class TestStack(unittest.TestCase):
             self.assertEqual(
                 'is not valid.', result['errors']['pagination_token'][0])
 
-    @unittest.skip('Work in progress')
-    def test_16_initialise_sync(self):
-        result = self.stack.sync_init()
-        if result is not None:
-            self.assertEqual(16, result['total_count'])
+    # Deprecated: This test was skipped due to deprecation of the sync_init feature or its API. 
+    # If sync_init is permanently removed or unsupported, this test should remain commented or be deleted.
+    # If migration or replacement is planned, update this test accordingly.
+    # @unittest.skip('Work in progress')
+    # def test_16_initialise_sync(self):
+    #     result = self.stack.sync_init()
+    #     if result is not None:
+    #         self.assertEqual(16, result['total_count'])
 
     def test_17_entry_with_sync_token(self):
         result = self.stack.sync_token('sync_token')