entry.py, entryqueryable.py, basequery.py and related testcases updated.

Author: mshaileshr@gmail.com

contentstack/assetquery.py

@@ -97,22 +97,6 @@ def relative_url(self):
         self.__query_params["relative_urls"] = "true"
         return self
 
-    def include_count(self):
-        """
-        include count provides asset count
-        :return: AssetQuery: so we can chain the call
-
-        -----------------------------
-        [Example]:
-
-            >>> import contentstack
-            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
-            >>> result = stack.asset_query().include_count().find()
-        ------------------------------
-        """
-        self.__query_params["include_count"] = "true"
-        return self
-
     def find(self):
         """
         This call fetches the list of all the assets of a particular stack.

contentstack/basequery.py

@@ -43,7 +43,7 @@ class BaseQuery:
 
     def __init__(self):
         self.parameters = {}
-        self.__query_params = {}
+        self.query_params = {}
 
     def where(self, field_uid: str, query_operation: QueryOperation, fields=None):
         """
@@ -59,14 +59,31 @@ def where(self, field_uid: str, query_operation: QueryOperation, fields=None):
             self.parameters[field_uid] = result
         return self
 
+    def include_count(self):
+        """Retrieve count and data of objects in result
+        Returns:
+            [Query] -- Query object, so you can chain this call.
+        ==============================
+        [Example:]
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'access_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> query = content_type.query()
+            >>> query = query.include_count()
+            >>> result = query.find()
+        ==============================
+        """
+        self.query_params["include_count"] = 'true'
+        return self
+
     def skip(self, skip_count: int):
         """
         The number of objects to skip before returning any.
         skip_count No of objects to skip from returned objects
         :param skip_count:
         :return: self
         """
-        self.__query_params["skip"] = str(skip_count)
+        self.query_params["skip"] = str(skip_count)
         return self
 
     def limit(self, limit_count: int):
@@ -75,7 +92,7 @@ def limit(self, limit_count: int):
         :param limit_count:
         :return: self
         """
-        self.__query_params["skip"] = str(limit_count)
+        self.query_params["skip"] = str(limit_count)
         return self
 
     def order_by_ascending(self, key: str):
@@ -86,7 +103,7 @@ def order_by_ascending(self, key: str):
         :param key:  key on which ascending order to be implemented
         :return: self
         """
-        self.__query_params["asc"] = str(key)
+        self.query_params["asc"] = str(key)
         return self
 
     def order_by_descending(self, key: str):
@@ -96,7 +113,7 @@ def order_by_descending(self, key: str):
         :param key:  key on which descending order to be implemented
         :return: self - Class instance, So that method chaining can be performed
         """
-        self.__query_params["desc"] = str(key)
+        self.query_params["desc"] = str(key)
         return self
 
     def param(self, key: str, value):
@@ -127,37 +144,54 @@ def param(self, key: str, value):
         """
         if None in (key, value):
             raise KeyError('Invalid key or value')
-        self.__query_params[key] = str(value)
+        self.query_params[key] = str(value)
         return self
 
     def add_params(self, param: dict):
         """
         Adds Parameters to the to the request
-
         Arguments:
-            param {dict} --  paramters
-
+            param {dict} --  parameters
         Returns:
             [self] -- Class instance, So that method chaining can be performed
         """
-        self.__query_params.update(param)
+        self.query_params.update(param)
         return self
 
     def query(self, key: str, value):
         """
         Adds key value pairs to the to the query parameters
-
         Arguments:
             key {[str]} -- key of the query param
             value {[type]} -- value of query param
-
         Raises:
             KeyError: when key or value found None
-
         Returns:
-            [self] -- Class instance, So that method chaining can be performed]
+            self-- Class instance, So that method chaining can be performed
         """
         if None in (key, value):
             raise KeyError('Invalid key or value')
         self.parameters[key] = str(value)
         return self
+
+    def remove_param(self, key: str):
+        """
+        Remove provided query key from custom query if exist.
+        :param key {str} -- The key to be constrained
+        :return: self -- So that method chaining can be performed
+
+        ----------------------------------
+        [Example]:
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> query = content_type.query()
+            >>> query = query.remove_query("query_key")
+            >>> result = query.find()
+        ----------------------------------
+        """
+        if key is None:
+            raise ValueError('Kindly provide valid key')
+        if key in self.query_params:
+            self.query_params.pop(key, None)
+        return self

contentstack/contenttype.py

@@ -27,21 +27,24 @@ def __init__(self, http_instance, content_type_uid):
         self.__content_type_uid = content_type_uid
         self.local_param = {}
 
-    def entry(self, uid):
+    def entry(self, entry_uid: str):
         r"""
         An entry is the actual piece of content created using one of the defined content types.
-        :param uid: {str} -- uid of the entry
+        :param entry_uid: {str} -- unique ID of the entry that you wish to fetch
         :return: Entry -- Returns the Entry class object so we can chain the entry functions
+
         --------------------------------
-        [Example:]
 
+        [Example:]
             >>> import contentstack
             >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
             >>> content_type = stack.content_type('content_type_uid')
             >>> entry = content_type.entry(uid='entry_uid')
         --------------------------------
         """
-        entry = Entry(self.http_instance, self.__content_type_uid, entry_uid=uid)
+        if None in (self.__content_type_uid, entry_uid):
+            raise KeyError('Please provide valid content_type_uid and entry uid')
+        entry = Entry(self.http_instance, self.__content_type_uid, entry_uid=entry_uid)
         return entry
 
     def query(self):
@@ -57,8 +60,9 @@ def query(self):
             >>> query = content_type.query()
         ------------------------------
         """
-        query = Query(self.__content_type_uid)
-        return query
+        if self.__content_type_uid is None:
+            raise PermissionError('Kindly provide content_type_uid')
+        return Query(self.http_instance, self.__content_type_uid)
 
     def fetch(self):
         """

contentstack/entryqueryable.py

@@ -0,0 +1,187 @@
+import enum
+
+
+class Include(enum.Enum):
+    """
+    Include is enum that Provides Options to perform operation to query the result.
+
+    Available Options for QueryOperation are below.
+    DEFAULT, ONLY, EXCEPT
+
+    Arguments:
+        enum {Include} -- Type of IncludeReference
+    """
+    EXCEPT = 'except'
+    ONLY = 'only'
+    DEFAULT = ''
+
+
+class EntryQueryable:
+    """
+    This class is base class for the Entry and Query class that shares common functions
+    """
+    def __init__(self):
+        self.entry_queryable_param = {}
+
+    def locale(self, locale: str):
+        """
+        Language code of which the entries needs to be included.
+        Only the entries published in this locale will be displayed
+
+        Arguments:
+            locale {str} -- locale_code of the language of which the entries needs to be included.
+            Only the entries published in this locale will be displayed
+
+        :return: self: so you can chain this call.
+
+        Example (locale for Entry):
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> entry = content_type.entry(uid='entry_uid')
+            >>> entry.locale('en-us')
+            >>> result = entry.fetch()
+
+        Example (locale for Query):
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> query = content_type.query()
+            >>> query.locale('en-us')
+            >>> result = query.find()
+        """
+        self.entry_queryable_param['locale'] = locale
+        return self
+
+    def only(self, field_uid):
+        """
+        Specifies an array of only keys in BASE object that would be included in the response.
+        It refers to the top-level fields of the schema
+        :param field_uid: Array of the only reference keys to be included in response
+        Returns:
+            self -- so you can chain this call.
+        """
+        if field_uid is not None:
+            self.entry_queryable_param['only[BASE][]'] = field_uid
+            return self
+
+    def excepts(self, field_uid):
+        """
+        Specifies list of field_uid that would be excluded from the response.
+        It refers to the top-level fields of the schema
+        :param field_uid: to be excluded from the response.
+        :return: self -- so you can chain this call.
+        """
+        if field_uid is not None:
+            self.entry_queryable_param['except[BASE][]'] = field_uid
+            return self
+
+    def include_reference(self, include_reference_type:  Include, reference_field_uid: str, field_uid=None):
+        """
+        **Include Reference:**
+        When you fetch an entry of a content type that has a reference field,
+        by default, the content of the referred entry is not fetched.
+        It only fetches the UID of the referred entry, along with the content of
+        the specified entry.
+
+        Arguments:
+        reference_field_uid {str} -- Key who has reference to some other class object.
+        Array of the only reference keys to be included in response
+        include_type {Include} -- Provides three options, none, only and except
+        i.e accepts list of field_uid
+        field_uid {list} -- list of field_uid on which include operation to perform
+
+        Returns:
+            self -- So you can chain this call.
+        """
+        container = {}
+        if reference_field_uid is None:
+            raise KeyError("reference_field_uid can't be None")
+        if include_reference_type.name == 'DEFAULT':
+            self.entry_queryable_param["include[]"] = reference_field_uid
+        else:
+            container[reference_field_uid] = field_uid
+            self.entry_queryable_param["include[]"] = {include_reference_type.value: container}
+        return self
+
+    def include_content_type(self):
+        """
+        This method also includes the ContentType in the entry
+        :return: self: so you can chain this call.
+
+        -------------------------------
+
+        [Example: for Entry]
+
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> entry = content_type.entry('uid')
+            >>> entry.include_content_type()
+            >>> result = entry.fetch()
+
+        -------------------------------
+
+        [Example: for Query:]
+
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> query = content_type.query()
+            >>> query.include_content_type()
+            >>> result = query.find()
+        -------------------------------
+        """
+        self.entry_queryable_param['include_content_type'] = 'true'
+        self.entry_queryable_param['include_global_field_schema'] = 'true'
+        return self
+
+    def include_reference_content_type_uid(self):
+        """
+        This method also includes the content type UIDs
+        of the referenced entries returned in the response
+        Returns:
+            :return: self: so you can chain this call.
+
+        [Example for Query]
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> query = content_type.query()
+            >>> query = query.include_reference_content_type_uid()
+            >>> result = query.find()
+
+        [Example for Entry]
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> entry = stack.content_type('content_type_uid').entry('entry_uid')
+            >>> entry = entry.include_reference_content_type_uid()
+            >>> result = entry.fetch()
+        """
+        self.entry_queryable_param['include_reference_content_type_uid'] = 'true'
+        return self
+
+    def add_param(self, key: str, value: str):
+        """
+        This method adds key and value to an Entry.
+        :param key: The key as string which needs to be added to an Entry
+        :param value: The value as string which needs to be added to an Entry
+        :return: self: object, so you can chain this call.
+
+        Example: Call from Query =>
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> query = stack.content_type('content_type_uid').query()
+            >>> query = query.include_reference_content_type_uid()
+            >>> result = query.find()
+
+        Example: Call from Entry =>
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> entry = stack.content_type('content_type_uid').entry('entry_uid')
+            >>> entry = entry.include_reference_content_type_uid()
+            >>> result = entry.fetch()
+
+        """
+        if None not in (key, value):
+            self.entry_queryable_param[key] = value