docstring

Author: mshaileshr@gmail.com

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-    "python.pythonPath": "venv/bin/python3.7",
+    "python.pythonPath": "/Library/Frameworks/Python.framework/Versions/3.7/bin/python3",
     "python.testing.unittestArgs": [
         "-v",
         "-s",

contentstack/config.py

@@ -25,8 +25,18 @@ class ContentstackRegion(enum.Enum):
 class Config(object):
 
     def __init__(self):
+
+        """
+
+        """
         self.default = dict(protocol="https", region=ContentstackRegion.US, host="cdn.contentstack.io", version="v3")
 
+    @property
+    def region(self):
+        """ :returns  region of the stack """
+        return self.default['region']
+
+    @region.setter
     def region(self, region=ContentstackRegion.US):
 
         """
@@ -40,15 +50,22 @@ def region(self, region=ContentstackRegion.US):
 
         [Example:]
 
-        >>> config  = Config().region(region=ContentstackRegion.US)
+        >>> config = Config()
+        >>> config.region = ContentstackRegion.US
 
         ==============================
         """
 
         if region is not None and isinstance(region, ContentstackRegion):
             self.default['region'] = region
-        return self
 
+
+    @property
+    def host(self):
+
+        return self.default['host']
+
+    @host.setter
     def host(self, host):
 
         """
@@ -64,7 +81,6 @@ def host(self, host):
 
         if host is not None and isinstance(host, str):
             self.default['host'] = host
-        return self
 
     def version(self, version=None):
 
@@ -102,10 +118,10 @@ def endpoint(self):
 
     def __get_url(self):
         host = self.default["host"]
-        if self.default['region'] is not ContentstackRegion.US:
-            if self.default["host"] == 'cdn.contentstack.io':
-                self.default["host"] = 'cdn.contentstack.com'
-            else:
-                regional_host = str(self.default['region'].value)
-                host = '{}-{}'.format(regional_host, self.default["host"])
-        return "{0}://{1}/{2}".format(self.default["protocol"], host, self.default["version"])
+        region = self.default['region'].value
+        if region is not None:
+            if region is not 'us':
+                if self.default["host"] == 'cdn.contentstack.io':
+                    self.default["host"] = 'cdn.contentstack.com'
+                host = '{}-{}'.format(region, self.default["host"])
+        return "{0}://{1}/{2}".format(self.default["protocol"], host, self.default["version"])

contentstack/http_connection.py

@@ -8,7 +8,7 @@
 
 import logging
 import requests
-from urllib import parse
+from urllib.parse import urlencode
 from contentstack import Error
 from json import JSONDecodeError
 from requests.exceptions import Timeout, HTTPError
@@ -18,44 +18,55 @@ class HTTPConnection(object):
 
     def __init__(self, url, query, stack_headers):
 
-        """
-        Initialises the HTTPConnection to make Http Request
-        :param url: url for the request to made
-        :param query: It will be executed to retrieve entries. This query should be in key value format.
-        :param stack_headers: It contains like API key of your stack, access token and others.
-        """
         if None not in (url, query, stack_headers):
-            self.__url = url
+            self.__payload = None
+            self.__base_url = url
             self.__query_params = query
-            self.__stack_headers = stack_headers
-            self.__stack_headers.update(self.__user_agents())
+            self.__headers = stack_headers
+            self.__headers.update(self.__user_agents())
+
+            if 'environment' in self.__headers:
+                environment = self.__headers['environment']
+                self.__query_params['environment'] = environment
 
     def get_result(self, url: str, query: dict, headers: dict):
+
         if None not in (url, query, headers):
-            if len(url) > 0 and len(self.__stack_headers) > 0:
-                self.__url = url
-                self.__query_params = query
-                self.__stack_headers.update(headers)
-            else:
-                raise ValueError('Kindly provide a valid input')
-
-        # Headers from locale
-        if 'environment' in self.__stack_headers:
-            environment = self.__stack_headers['environment']
-            self.__query_params['environment'] = environment
-        logging.info('Query Parameters ={}'.format(self.__query_params))
-        logging.info('Headers ={}'.format(self.__stack_headers))
-        payload = parse.urlencode(query=self.__query_params, encoding='UTF-8')
+            if len(url) > 0 and len(self.__headers) > 0:
+                self.__base_url = url
+                if len(headers) > 0:
+                    self.__headers.update(headers)
+                self.__query_params.update(query)
+
+                # Case: If UIR Parameter contains entries
+                if 'entries' in self.__base_url:
+                    self.__payload = self.__execute_entry()
+                    # self.__payload = parse.urlencode(query=params, encoding='UTF-8')
+                else:
+                    url_param = ''
+                    for (key, value) in self.__query_params.items():
+                        url_param = '{}&{}={}'.format(url_param, key, value)
+                    self.__payload = url_param
+
         try:
-            response = requests.get(self.__url, verify=True, timeout=(10, 8), params=payload,
-                                    headers=self.__stack_headers)
+            if self.__payload.startswith("&"):
+                self.__payload = self.__payload[1:]
+            _url = '{}?{}'.format(self.__base_url, self.__payload)
+            logging.info('{}?{}'.format(self.__base_url, self.__payload))
+            response = requests.get(_url, verify=True, timeout=(10, 8), headers=self.__headers)
+
             if response.status_code == 200:
                 if response.raise_for_status() is None:
                     return self.__parse_dict(response)
             else:
                 err = response.json()
                 if err is not None:
-                    return Error()._config(err)
+                    error = Error()
+                    error._config(err)
+                    return error
+
+            logging.info('\n\nrequest url => {}\nresponse={}'.format(response.url, response))
+
         except Timeout:
             raise TimeoutError('The request timed out')
         except ConnectionError:
@@ -65,46 +76,99 @@ def get_result(self, url: str, query: dict, headers: dict):
         except HTTPError:
             raise HTTPError('Http Error Occurred')
 
+    # def __check_for_valid_query(self):
+    #
+    #     if 'include[]' in self.__query_params:
+    #         url_params = ''
+    #         params = self.__query_params['include[]']
+    #         for param in params:
+    #             url_params = '{}&include[]={}'.format(url_params, param)
+    #         del self.__query_params['include[]']
+    #         return self.__return_query(url_params)
+    #
+    #     elif 'only[BASE][]' in self.__query_params:
+    #         url_params = ''
+    #         params = self.__query_params['only[BASE][]']
+    #         for param in params:
+    #             url_params = '{}&only[BASE][]={}'.format(url_params, param)
+    #         del self.__query_params['only[BASE][]']
+    #         return self.__return_query(url_params)
+    #
+    #     elif 'except[BASE][]' in self.__query_params:
+    #         url_params = ''
+    #         params = self.__query_params['except[BASE][]']
+    #         for param in params:
+    #             url_params = '{}&except[BASE][]={}'.format(url_params, param)
+    #         del self.__query_params['except[BASE][]']
+    #         return self.__return_query(url_params)
+    #
+    #     elif 'only' in self.__query_params:
+    #         url_params = ''
+    #         params = self.__query_params['only']
+    #         for param in params:
+    #             url_params = '{}&only={}'.format(url_params, param)
+    #         del self.__query_params['only']
+    #         return self.__return_query(url_params)
+    #
+    #     elif 'except' in self.__query_params:
+    #         url_params = ''
+    #         params = self.__query_params['except']
+    #         for param in params:
+    #             url_params = '{}&except={}'.format(url_params, param)
+    #         del self.__query_params['except']
+    #         return self.__return_query(url_params)
+    #
+    #     elif 'query' in self.__query_params:
+    #         url_params = ''
+    #         params = self.__query_params['query']
+    #         for param in params:
+    #             url_params = '{}&query={}'.format(url_params, param)
+    #         del self.__query_params['query']
+    #         return self.__return_query(url_params)
+    #     else:
+    #         pass
+    #
+    # def __return_query(self, url_params):
+    #     other_queries = ''
+    #     for key, value in self.__query_params.items():
+    #         other_queries = '{}&{}={}'.format(other_queries, key, value)
+    #     url_params = '{}{}'.format(other_queries, url_params)
+    #     self.__query_params.clear()
+    #     return url_params
+
     def __parse_dict(self, response):
         from contentstack.stack import SyncResult
         result = response.json()
-        logging.info('\n\nrequest url => {}\nresponse={}'.format(response.url, result))
 
         if 'stack' in result:
             return result['stack']
-        # If result contains entry, return Entry
         if 'entry' in result:
             dict_entry = result['entry']
             return self.__parse_entries(dict_entry)
-        # If result contains entries, return list[Entry]
         if 'entries' in result:
             entry_list = result['entries']
             return self.__parse_entries(entry_list)
-        # If result contains asset, return Asset
         if 'asset' in result:
             dict_asset = result['asset']
             return self.__parse_assets(dict_asset)
-        # If result contains assets, return list[Asset]
         if 'assets' in result:
             asset_list = result['assets']
             return self.__parse_assets(asset_list)
-        # If result contains content_type,return content_type json
         if 'content_type' in result:
             return result['content_type']
-        # If result contains content_types,return content_types json
         if 'content_types' in result:
             return result['content_types']
-        # If result contains items, return SyncResult json
         if 'items' in result:
-            sync_result = SyncResult()._configure(result)
+            sync_result = SyncResult()
+            sync_result._configure(result)
             return sync_result
 
         return None
 
     @staticmethod
     def __parse_entries(result):
         from contentstack import Entry
-        entries: list[Entry] = []
+        entries = []
         entry = Entry()
         # if 'count' in result:
         # entry.count = result['count']
@@ -120,7 +184,7 @@ def __parse_entries(result):
     @staticmethod
     def __parse_assets(result):
         from contentstack import Asset
-        assets: list[Asset] = []
+        assets = []
         asset = Asset()
 
         if result is not None and len(result) > 0:
@@ -138,37 +202,51 @@ def __user_agents() -> dict:
         import contentstack
         import platform
 
-        """
-        Contentstack-User-Agent.
-        """
         header = {'sdk': dict(name=contentstack.__package__, version=contentstack.__version__)}
-        os_name = platform.system()
-
-        if os_name == 'Darwin':
-            os_name = 'macOS'
-
-        elif not os_name or os_name == 'Java':
-            os_name = None
-
-        elif os_name and os_name not in ['macOS', 'Windows']:
-            os_name = 'Linux'
+        os = platform.system()
+        if os == 'Darwin':
+            os = 'macOS'
+        elif not os or os == 'Java':
+            os = None
+        elif os and os not in ['macOS', 'Windows']:
+            os = 'Linux'
+        header['os'] = {'name': os, 'version': platform.release()}
+        package = "contentstack-python, - {}".format(contentstack.__version__)
+        local_headers = {'User-Agent': str(header), "Content-Type": 'application/json', "X-User-Agent": package}
+        return local_headers
 
-        header['os'] = {
-            'name': os_name,
-            'version': platform.release()
-        }
+    def __execute_entry(self):
+
+        url_param = ''
+
+        for (key, value) in self.__query_params.items():
+            if key == 'include[]':
+                if isinstance(value, list):
+                    url_param = '{}&{}'.format(url_param, urlencode({key: value}, doseq=True))
+            elif key == 'only[BASE][]':
+                if isinstance(value, list):
+                    url_param = '{}&{}'.format(url_param, urlencode({key: value}, doseq=True))
+            elif key == 'except[BASE][]':
+                if isinstance(value, list):
+                    url_param = '{}&{}'.format(url_param, urlencode({key: value}, doseq=True))
+            elif key == 'only':
+                for uid in value:
+                    inner_list = value[uid]
+                    inner_key = 'only[{}][]'.format(uid)
+                    if isinstance(inner_list, list):
+                        url_param = '{}&{}'.format(url_param, urlencode({inner_key: inner_list}, doseq=True))
+            elif key == 'except':
+                for uid in value:
+                    inner_list = value[uid]
+                    inner_key = 'except[{}][]'.format(uid)
+                    if isinstance(inner_list, list):
+                        url_param = '{}&{}'.format(url_param, urlencode({inner_key: inner_list}, doseq=True))
+            elif key == 'query':
+                query = urlencode({key: value})
+                url_param = '{}&{}'.format(url_param, query, doseq=True)
+            else:
+                url_param = '{}&{}={}'.format(url_param, key, value)
 
-        local_headers = {'User-Agent': str(header),
-                         "Content-Type": 'application/json',
-                         "X-User-Agent": "contentstack-python, {}".format(contentstack.__version__)
-                         }
-        return local_headers
+        return url_param
 
-    def __is_valid_json(self, json_string):
 
-        import json
-        try:
-            json.loads(json_string)
-            return True
-        except ValueError as e:
-            return False

package.json

@@ -2,6 +2,5 @@
   "name": "contentstack.python",
   "version": "0.0.1",
   "dependencies": {
-    
   }
 }