doc string

Author: ishaileshmishra

contentstack/__init__.py

@@ -15,8 +15,11 @@
 
 # Set a default logger to prevent "No handler found" warnings
 import logging
+
 try:
     from logging import NullHandler
+    # logging.basicConfig(filename='cs.log', format='%(asctime)s - %(message)s', level=logging.DEBUG)
+    # logging.getLogger("__init__.py")
 except ImportError:
     class NullHandler(logging.Handler):
         def emit(self, record):

contentstack/config.py

@@ -21,67 +21,71 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
 
- """
+"""
 import logging
 
 
-logging.basicConfig(filename='contentstack.log', format='%(asctime)s - %(message)s', level=logging.INFO)
+logging.basicConfig(filename='cs.log', format='%(asctime)s - %(message)s', level=logging.INFO)
 logging.getLogger("Config")
 
 
-class Config:
+class Config(object):
+    """
+    All API paths are relative to this base URL, for example, /users actually means <scheme>://<host>/<basePath>/users.
+
+    """
 
     def __init__(self):
-        self.defaultConfig = dict(protocol="https:/",
-                                  host="cdn.contentstack.io",
-                                  port=443,
-                                  version="v3",
-                                  path={
-                                      "stacks": "stacks",
-                                      "sync": "stacks/sync",
-                                      "content_types": "content_types",
-                                      "entries": "content_types",
-                                      "assets": "assets",
-                                      "environments": "environments"
-                                  })
-
-    def host(self, host_url=None):
-        if host_url is not None and isinstance(host_url, str):
-            self.defaultConfig['host'] = host_url
-        return self.defaultConfig['host']
+
+        # It initialises the Config with the default endpoint
+        self.default = dict(protocol="https", host="cdn.contentstack.io", port=443, version="v3")
+
+    def host(self, host):
+
+        """
+        The base URL for Content Delivery API is cdn.contentstack.io.
+        host is the domain name or IP address (
+        IPv4) of the host that serves the API. It may include the port number if different from the scheme's default
+        port (443 for HTTPS).
+
+        Note: contentstack supports HTTPS only
+        :param host: host is the domain name
+        :type host: str
+        :return: self
+        :rtype: Config
+
+        Example:
+
+            >>> config  = Config().host('api.contentstack.io')
+
+        """
+
+        if host is not None and isinstance(host, str):
+            self.default['host'] = host
+        return self
 
     def version(self, version=None):
-        if version is not None and isinstance(version, str):
-            self.defaultConfig['version'] = version
-            return self.defaultConfig['version']
-        else:
-            return self.defaultConfig['version']
-
-    def path(self, path):
-        url_section = self.defaultConfig['path']
-        if path in url_section:
-            return url_section[path]
-        else:
-            logging.error("{0} is invalid endpoint path".format(path))
-            raise Exception('Invalid endpoint!!, {0} is invalid endpoint path, Path can be found among {1}'
-                            .format(path, url_section.keys()))
 
-    @property
-    def default_endpoint(self):
-        endpoint_url = "{0}/{1}/{2}".format(self.defaultConfig["protocol"], self.host(), self.version())
-        return endpoint_url
+        """
+        Note: Only version 3 is supported on the CDN. If you're still using version 2 (which we recommend you should
+        not), switch to the CDN version for even faster loading.
+        :param version: The API version can be found in the URL that is basePath
+        :type version: str
+        :return: self
+        :rtype: Config
 
-    def endpoint(self, path):
-        url = self.path(path)
-        if url is not None and isinstance(url, str):
-            url = "{0}/{1}/{2}/{3}".format(self.defaultConfig["protocol"], self.host(), self.version(), url)
-            logging.info('endpoint is :: {0} '.format(url))
+        Example: The API version (in our case, 'v3') can be found in the URL, e.g.
 
-        return url
+            >>> config  = Config()
+            >>> config.version = 'v3'
 
+        """
+        if version is not None and isinstance(version, str):
+            self.default['version'] = version
 
-# config = Config()
-# config.host("stag-cdn.contentstack.io")
-# result_url = config.endpoint('assets')
-# print(result_url)
+        return self
 
+    @property
+    def endpoint(self):
+        url = "{0}://{1}/{2}".format(self.default["protocol"], self.default["host"], self.default["version"])
+        return url

contentstack/errors.py

@@ -24,54 +24,91 @@
 
 
 class Error:
+
     """
     contentstack.error
     ~~~~~~~~~~~~~~~~~~
     This module implements the Error class.
     API Reference: https://www.contentstack.com/docs/apis/content-delivery-api/#error
+
     """
 
     def __init__(self):
+
+        """
+
+        """
         self.__error_dict = {}
         self.__error_code = str
         self.__msg = str
         self.__cause_err = str
 
     def config(self, result: dict):
 
+        """
+
+        :param result:
+        :type result:
+        :return:
+        :rtype:
+        """
         if result is not None and len(result) > 0:
             self.__error_dict = result
             self.__error_code = self.__error_dict['error_code']
             self.__msg = self.__error_dict['error_message']
             self.__cause_err = self.__error_dict['errors']
-
         return self
 
     @property
     def error_code(self):
+
         """
+        It returns error code from the stack response
         :return: error_code as int
+        :rtype: int
+
+        Example. code = error.error_code
+
         """
         return self.__error_code
 
     @property
     def error_message(self):
+
         """
+        Returns error_message from the stack response
         :return: error_message
+        :rtype: str
+
+        Example. error.error_message
+
         """
+
         return self.__msg
 
     @property
     def error(self):
+
         """
+        This returns error code and error_message in dict formats
         :return: error dict
+        :rtype: dict
+
+        Example. error = error.error
         """
+
         return self.__cause_err
 
     @property
     def error_info(self) -> dict:
+
         """
-        :return: dict, error information
+        error information
+        :return: error information
+        :rtype: dict
+
+        Example. error.error_info
+
         """
         return self.__error_dict
 

contentstack/http_connection.py

@@ -1,3 +1,8 @@
+
+from json import JSONDecodeError
+import logging
+
+
 class HTTPConnection:
 
     def __init__(self, url: str, query: dict, headers: dict):
@@ -32,10 +37,12 @@ def get_result(self, url: str, query: dict, headers: dict):
             # requesting for url, payload and headers
             response: Response = requests.get(self.url, params=payload, headers=self.headers)
             # if response.status_code = 200
+            # logging.info('Request url :: -> ', response.url)
             if response.ok:
 
                 # Decode byte response to json
                 result = response.json()
+                logging.info('url={}\nresponse={}'.format(response.url, result))
                 # If result contains stack, return json response
                 if 'stack' in result:
                     return result['stack']
@@ -70,11 +77,12 @@ def get_result(self, url: str, query: dict, headers: dict):
                 err = response.json()
                 if err is not None:
                     return Error().config(err)
-                    # raise ContentstackError('Server Error Code {} Message: {}'.format(error_code, error_message))
 
         except requests.RequestException as err:
-            # Error().config(err)
-            raise ConnectionError(err)
+            if isinstance(err, ConnectionError):
+                raise ConnectionError(err)
+        except JSONDecodeError:
+            raise ValueError("Inappropriate response")
 
     @staticmethod
     def __parse_entries(result):
@@ -134,3 +142,10 @@ def __user_agents() -> dict:
 
         local_headers = {'X-User-Agent': str(header), "Content-Type": 'application/json'}
         return local_headers
+
+    # def is_json(self, myjson):
+    #    try:
+    #        json.loads(myjson.json())
+    #        return True
+    #    except JSONDecodeError:
+    #        return False