requirements updated

Author: ishaileshmishra

contentstack/stack.py

@@ -9,22 +9,20 @@
 import enum
 import logging
 from urllib import parse
-
-from urllib3 import Retry
-
-import contentstack
+from urllib3.util import Retry
 from contentstack.asset import Asset
 from contentstack.assetquery import AssetQuery
 from contentstack.contenttype import ContentType
 from contentstack.https_connection import HTTPSConnection
 from contentstack.image_transform import ImageTransform
 
+
 __author__ = "ishaileshmishra (ishaileshmishra@gmail.com)"
 __license__ = "MIT"
 __version__ = '1.7.0'
 
 log = logging.getLogger(__name__)
-default_host = 'cdn.contentstack.io'
+DEFAULT_HOST = 'cdn.contentstack.io'
 
 
 class ContentstackRegion(enum.Enum):
@@ -37,17 +35,17 @@ class ContentstackRegion(enum.Enum):
 
 
 class Stack:
-    from urllib3.util import Retry
 
     """
     A stack can be defined as a pool of data or a container that holds all
     the content/assets related to a site. It is a collaboration space where multiple users can work
     together to create, edit, approve, and publish content.
     (API Reference)[https://www.contentstack.com/docs/developers/apis/content-delivery-api/#stack]:
     """
+    #from urllib3.util import Retry
 
     def __init__(self, api_key: str, delivery_token: str, environment: str,
-                 host=default_host,
+                 host=DEFAULT_HOST,
                  version='v3',
                  region=ContentstackRegion.US,
                  timeout=30,
@@ -67,7 +65,8 @@ def __init__(self, api_key: str, delivery_token: str, environment: str,
         :param branch: branch of the stack
         :param version: (optional) apiVersion of the stack default is v3
         :param region: (optional) region support of the stack default is ContentstackRegion.US
-        :param live_preview: (optional) accepts type dictionary that enables live_preview option for request,
+        :param live_preview: (optional) accepts type dictionary that enables
+        live_preview option for request,
         takes input as dictionary object. containing one/multiple key value pair like below.
 
         ```python
@@ -82,7 +81,6 @@ def __init__(self, api_key: str, delivery_token: str, environment: str,
         :param retry_strategy (optional) custom retry_strategy can be set.
         # Method to create retry_strategy: create object of Retry() and provide the
         # required parameters like below
-        
         **Example:**
 
         >>> _strategy = Retry(total=5, backoff_factor=1, status_forcelist=[408, 429])
@@ -123,22 +121,19 @@ def _validate_stack(self):
                 'You are not permitted to the stack without valid Environment')
 
 
-        if self.region.value == 'eu' and self.host == default_host:
+        if self.region.value == 'eu' and self.host == DEFAULT_HOST:
             self.host = 'eu-cdn.contentstack.com'
-        elif self.region.value == 'azure-na' and self.host == default_host:
+        elif self.region.value == 'azure-na' and self.host == DEFAULT_HOST:
             self.host = 'azure-na-cdn.contentstack.com'
         elif self.region.value != 'us':
-            self.host = '{}-{}'.format(self.region.value, default_host)
-
-        self.endpoint = 'https://{}/{}'.format(self.host, self.version)
+            #self.host = '{}-{}'.format(self.region.value, DEFAULT_HOST)
+            self.host = f'{self.region.value}-{DEFAULT_HOST}'
+        self.endpoint = f'https://{self.host}/{self.version}'
 
         self.headers = {
-            'api_key': 
-                self.api_key,
-            'access_token': 
-                self.delivery_token,
-            'environment': 
-                self.environment
+            'api_key': self.api_key,
+            'access_token':self.delivery_token,
+            'environment': self.environment
         }
 
         if self.branch is not None:
@@ -163,7 +158,7 @@ def _validate_live_preview(self):
                 self.headers['authorization'] = self.live_preview_dict['authorization']
                 # remove deliveryToken and environment
                 self.host = self.live_preview_dict['host']
-                self.endpoint = 'https://{}/{}'.format(self.host, self.version)
+                self.endpoint = f'https://{self.host}/{self.version}'
                 self.headers.pop('access_token')
                 self.headers.pop('environment')
 
@@ -252,18 +247,22 @@ def asset_query(self):
         """
         return AssetQuery(self.http_instance)
 
-    def sync_init(self, content_type_uid=None, start_from=None, locale=None, type=None):
+    def sync_init(self, content_type_uid=None, start_from=None, locale=None, publish_type=None):
         """
-        Set init to ‘true’ if you want to sync all the published entries and assets. This is usually used when the
-        app does not have any content and you want to get all the content for the first time.\n
+        Set init to ‘true’ if you want to sync all the published entries and assets.
+        This is usually used when the app does not have any content and you want to
+        get all the content for the first time.\n
 
         :param content_type_uid: (optional) content type UID. e.g., products
                     This retrieves published entries of specified content type
         :param start_from: (optional) The start date. e.g., 2018-08-14T00:00:00.000Z
                     This retrieves published entries starting from a specific date
-        :param locale: (optional) locale code. e.g., en-us, This retrieves published entries of specific locale.
-        :param type: (optional) If you do not specify any value, it will bring all published 
-                    entries and published assets. You can pass multiple types as comma-separated values,
+        :param locale: (optional) locale code. e.g., en-us, This retrieves published
+        entries of specific locale.
+        :param publish_type: (optional) If you do not specify any value,
+                    it will bring all published
+                    entries and published assets. You can pass multiple types
+                    as comma-separated values,
                     for example, entry_published,entry_unpublished,asset_published
         :return: list of sync items
         -------------------------------
@@ -273,7 +272,7 @@ def sync_init(self, content_type_uid=None, start_from=None, locale=None, type=No
             >>> import contentstack
             >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
             >>> result = stack.sync_init(content_type_uid='content_type_uid',
-                         start_from='date', locale='en-us', type='asset_published')
+                         start_from='date', locale='en-us', publish_type='asset_published')
         -------------------------------
         """
         self.sync_param['init'] = 'true'
@@ -283,8 +282,8 @@ def sync_init(self, content_type_uid=None, start_from=None, locale=None, type=No
             self.sync_param['start_from'] = start_from
         if locale is not None and isinstance(locale, str):
             self.sync_param['locale'] = locale
-        if type is not None and isinstance(type, str):
-            self.sync_param['type'] = type
+        if publish_type is not None and isinstance(publish_type, str):
+            self.sync_param['type'] = publish_type
         return self.__sync_request()
 
     def pagination(self, pagination_token: str):
@@ -333,18 +332,18 @@ def __sync_request(self):
         :return: :class:`Response <Response>` object
         :rtype: requests.Response
         """
-        base_url = '{}/stacks/sync'.format(self.http_instance.endpoint)
+        base_url = f'{self.http_instance.endpoint}/stacks/sync'
         self.sync_param['environment'] = self.http_instance.headers['environment']
         encoded_query = parse.urlencode(self.sync_param)
-        url = '{}?{}'.format(base_url, encoded_query)
+        url = f'{base_url}?{encoded_query}'
         result = self.http_instance.get(url)
         return result
 
     def image_transform(self, image_url, **kwargs):
         """
         This document is a detailed reference to Contentstack’s Image Delivery
         API and covers the parameters that you can add to the URL to retrieve,
-        manipulate (or convert) image files and display it to your web or 
+        manipulate (or convert) image files and display it to your web or
         mobile properties.\n
 
         :param image_url: base url on which queries to apply

requirements.txt

@@ -1,22 +1,21 @@
-twython~=3.8.2
-setuptools~=51.1.0
+twython~=3.9.1
+setuptools~=62.1.0
 urllib3~=1.26.2
 contentstack-utils
-python-dateutil==2.8.1
-requests>=2.20.0,<3.0
-coverage==4.3.4
-tox==2.5.0
-virtualenv==15.1.0
-Sphinx==1.6.3
-sphinxcontrib-websupport==1.0.1
+python-dateutil==2.8.2
+requests==2.27.1
+coverage==6.3.2
+tox==3.24.5
+virtualenv==20.14.0
+Sphinx==4.5.0
+sphinxcontrib-websupport==1.2.4
 pip~=22.0.4
-build~=0.6.0.post1
-# build==0.7.0
-wheel~=0.35.1
-py~=1.9.0
-lxml~=4.6.2
+build~=0.7.0
+wheel~=0.37.1
+py~=1.11.0
+lxml~=4.8.0
 utils~=1.0.1
-keyring~=21.5.0
-docutils~=0.16
-pyparsing~=2.4.7
+keyring~=23.5.0
+docutils==0.16
+pyparsing~=3.0.8
 config~=0.5.1

tests/test_entry.py

@@ -1,10 +1,9 @@
-import logging
 import unittest
 
 import config
 import contentstack
 
-entry_uid = None
+ENTRY_UI = None
 
 
 class TestEntry(unittest.TestCase):
@@ -17,82 +16,79 @@ def test_01_run_initial_query(self):
         query = self.stack.content_type('faq').query()
         result = query.find()
         if result is not None:
-            global entry_uid
-            entry_uid = result['entries'][0]['uid']
-            logging.debug(entry_uid)
-            logging.info(' => query result is: {}'.format(result['entries']))
-            self.assertEqual(entry_uid, result['entries'][0]['uid'])
+            global ENTRY_UI
+            ENTRY_UI = result['entries'][0]['uid']
+            self.assertEqual(ENTRY_UI, result['entries'][0]['uid'])
 
     def test_02_entry_by_uid(self):
-        global entry_uid
-        entry = self.stack.content_type('faq').entry(entry_uid)
+        global ENTRY_UI
+        entry = self.stack.content_type('faq').entry(ENTRY_UI)
         result = entry.fetch()
         if result is not None:
-            logging.info(' => entry result is: {}'.format(result['entry']))
-            entry_uid = result['entry']['uid']
-            self.assertEqual(entry_uid, result['entry']['uid'])
+            ENTRY_UI = result['entry']['uid']
+            self.assertEqual(ENTRY_UI, result['entry']['uid'])
 
     def test_03_entry_environment(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type('faq').entry(
-            entry_uid).environment('test')
+            ENTRY_UI).environment('test')
         self.assertEqual("test", entry.http_instance.headers['environment'])
 
     def test_04_entry_locale(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type('faq').entry(
-            entry_uid).locale('en-eu-ei')
+            ENTRY_UI).locale('en-eu-ei')
         entry.fetch()
         self.assertEqual('en-eu-ei', entry.entry_param['locale'])
 
     def test_05_entry_version(self):
-        global entry_uid
-        entry = self.stack.content_type('faq').entry(entry_uid).version(3)
+        global ENTRY_UI
+        entry = self.stack.content_type('faq').entry(ENTRY_UI).version(3)
         entry.fetch()
         self.assertEqual(3, entry.entry_param['version'])
 
     def test_06_entry_params(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type('faq').entry(
-            entry_uid).param('param_key', 'param_value')
+            ENTRY_UI).param('param_key', 'param_value')
         entry.fetch()
         self.assertEqual('param_value', entry.entry_param['param_key'])
 
     def test_07_entry_base_only(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type(
-            'faq').entry(entry_uid).only('field_uid')
+            'faq').entry(ENTRY_UI).only('field_uid')
         entry.fetch()
         self.assertEqual({'environment': 'development',
                           'only[BASE][]': 'field_uid'}, entry.entry_param)
 
     def test_08_entry_base_excepts(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type('faq').entry(
-            entry_uid).excepts('field_uid')
+            ENTRY_UI).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 entry_uid
-        entry = self.stack.content_type('faq').entry(entry_uid).only('field1')
+        global ENTRY_UI
+        entry = self.stack.content_type('faq').entry(ENTRY_UI).only('field1')
         entry.fetch()
         self.assertEqual({'environment': 'development', 'only[BASE][]': 'field1'},
                          entry.entry_param)
 
     def test_11_entry_base_include_reference_excepts(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type(
-            'faq').entry(entry_uid).excepts('field1')
+            'faq').entry(ENTRY_UI).excepts('field1')
         entry.fetch()
         self.assertEqual({'environment': 'development', 'except[BASE][]': 'field1'},
                          entry.entry_param)
 
     def test_12_entry_include_reference_github_issue(self):
         stack_for_products = contentstack.Stack(
             "api_key", "delivery_token", "environment")
-        _entry = stack_for_products.content_type('product').entry("entry_uid").include_reference(
+        _entry = stack_for_products.content_type('product').entry("ENTRY_UI").include_reference(
             ["categories",
              "brand"])
         response = _entry.fetch()
@@ -101,15 +97,15 @@ def test_12_entry_include_reference_github_issue(self):
         # self.assertEqual(2, len(categories))
 
     def test_13_entry_support_include_fallback_unit_test(self):
-        global entry_uid
+        global ENTRY_UI
         entry = self.stack.content_type('faq').entry(
-            entry_uid).include_fallback()
+            ENTRY_UI).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(entry_uid).only(4)
+            entry = self.stack.content_type('faq').entry(ENTRY_UI).only(4)
             result = entry.fetch()
             self.assertEqual(None, result['uid'])
         except KeyError as e:
@@ -118,7 +114,7 @@ def test_14_entry_queryable_only(self):
 
     def test_15_entry_queryable_excepts(self):
         try:
-            entry = self.stack.content_type('faq').entry(entry_uid).excepts(4)
+            entry = self.stack.content_type('faq').entry(ENTRY_UI).excepts(4)
             result = entry.fetch()
             self.assertEqual(None, result['uid'])
         except KeyError as e:
@@ -127,19 +123,19 @@ def test_15_entry_queryable_excepts(self):
 
     def test_16_entry_queryable_include_content_type(self):
         entry = self.stack.content_type('faq').entry(
-            entry_uid).include_content_type()
+            ENTRY_UI).include_content_type()
         self.assertEqual({'include_content_type': 'true', 'include_global_field_schema': 'true'},
                          entry.entry_queryable_param)
 
     def test_18_entry_queryable_include_reference_content_type_uid(self):
         entry = self.stack.content_type('faq').entry(
-            entry_uid).include_reference_content_type_uid()
+            ENTRY_UI).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(
-            entry_uid).add_param('cms', 'contentstack')
+            ENTRY_UI).add_param('cms', 'contentstack')
         self.assertEqual({'cms': 'contentstack'}, entry.entry_queryable_param)
 
     def test_20_entry_include_fallback(self):