contentstack-management 1.3.3__tar.gz → 1.5.0__tar.gz

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: contentstack-management
-Version: 1.3.3
+Version: 1.5.0
 Summary: Contentstack API Client Library for Python
 Home-page: https://github.com/contentstack/contentstack-management-python
-Author: ishaileshmishra
+Author: dev-ex
 Author-email: mobile@contentstack.com
 License: MIT
 Classifier: License :: OSI Approved :: MIT License
@@ -124,6 +124,32 @@ asset = client().stack(api_key='api_key').assets()
 result = asset.upload(asset)
 ```
 
+### Development Setup
+
+This repository includes Husky-style pre-commit hooks for security scanning and code quality checks. To set up the development environment:
+
+```bash
+# Install required tools
+brew install talisman
+brew install snyk/tap/snyk
+
+# Set up Snyk authentication
+export SNYK_TOKEN=your_snyk_token_here
+snyk auth
+
+# Install git hooks
+chmod +x .husky/pre-commit .husky/pre-push .husky/hooks/*.sh .husky/hooks/*.py
+cp .husky/pre-commit .git/hooks/pre-commit
+cp .husky/pre-push .git/hooks/pre-push
+chmod +x .git/hooks/pre-commit .git/hooks/pre-push
+```
+
+### Security Features
+
+- **Talisman**: Detects secrets and sensitive data in commits
+- **Snyk**: Scans Python dependencies for vulnerabilities
+- **Code Quality**: Black, isort, flake8 for consistent code style
+
 ### Helpful Links
 
 -   [Contentstack Website](https://www.contentstack.com/)

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/README.md

@@ -90,6 +90,32 @@ asset = client().stack(api_key='api_key').assets()
 result = asset.upload(asset)
 ```
 
+### Development Setup
+
+This repository includes Husky-style pre-commit hooks for security scanning and code quality checks. To set up the development environment:
+
+```bash
+# Install required tools
+brew install talisman
+brew install snyk/tap/snyk
+
+# Set up Snyk authentication
+export SNYK_TOKEN=your_snyk_token_here
+snyk auth
+
+# Install git hooks
+chmod +x .husky/pre-commit .husky/pre-push .husky/hooks/*.sh .husky/hooks/*.py
+cp .husky/pre-commit .git/hooks/pre-commit
+cp .husky/pre-push .git/hooks/pre-push
+chmod +x .git/hooks/pre-commit .git/hooks/pre-push
+```
+
+### Security Features
+
+- **Talisman**: Detects secrets and sensitive data in commits
+- **Snyk**: Scans Python dependencies for vulnerabilities
+- **Code Quality**: Black, isort, flake8 for consistent code style
+
 ### Helpful Links
 
 -   [Contentstack Website](https://www.contentstack.com/)

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/__init__.py

@@ -16,6 +16,7 @@ from .roles.roles import Roles
 from .auditlogs.auditlog import Auditlog
 from .environments.environment import Environment
 from .entries.entry import Entry
+from .entry_variants.entry_variants import EntryVariants
 from .contentstack import Client, Region
 from ._api_client import _APIClient
 from .common import Parameter
@@ -31,6 +32,8 @@ from .delivery_token.delivery_token import DeliveryToken
 from .management_token.management_token import ManagementToken
 from .publish_queue.publish_queue import PublishQueue
 from .extensions.extension import Extension
+from .variant_group.variant_group import VariantGroup
+from .variants.variants import Variants
 
 
 __all__ = (
@@ -55,6 +58,7 @@ __all__ = (
 "Auditlog",
 "Environment",
 "Entry",
+"EntryVariants",
 "Locale",
 "Taxonomy",
 "Label",
@@ -65,14 +69,16 @@ __all__ = (
 "DeliveryToken",
 "ManagementToken",
 "PublishQueue",
-"Extension"
+"Extension",
+"VariantGroup",
+"Variants"
 )
 
 __title__ = 'contentstack-management-python'
-__author__ = 'ishaileshmishra'
+__author__ = 'dev-ex'
 __status__ = 'debug'
 __region__ = 'na'
-__version__ = '1.3.3'
+__version__ = '1.5.0'
 __host__ = 'api.contentstack.io'
 __protocol__ = 'https://'
 __api_version__ = 'v3'

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/auditlogs/auditlog.py

@@ -3,9 +3,7 @@ which is the endpoint for the RESTFUL API that we'll be interacting with.
 The create(), read(), update(), and delete() methods each correspond to 
 the CRUD operations that can be performed on the API """
 
-import json
 from ..common import Parameter
-from urllib.parse import quote
 from .._errors import ArgumentException
 
 class Auditlog(Parameter):

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/bulk_operations/bulk_operation.py

@@ -227,4 +227,96 @@ class BulkOperation(Parameter):
         data = json.dumps(data)
         return self.client.post(url, headers = self.client.headers, data = data, params=self.params)
     
+    def add_items(self, data: dict, headers: dict = None):
+        """
+        The Add items to bulk operation request allows you to add multiple entries and assets to a bulk operation.
+        
+        :return: The `add_items` method is returning the result of the `post` request made by the
+        `client.post` method.
+        -------------------------------
+            [Example:]
+                >>> data = {
+                >>>        "release": "release_uid"
+                >>>        "action": "publish",
+                >>>        "locale": ["en-us", "hi-in"]
+                >>>        "reference": true
+                >>>        "items": [
+                >>>            {
+                >>>            "uid": "blt63177c0f00f20b61",
+                >>>            "content_type_uid": "my_blog"
+                >>>            }
+                >>>        ]
+                >>>  }
+                >>> import contentstack_management
+                >>> client = contentstack_management.Client(authtoken='your_authtoken')
+                >>> result = client.stack('api_key').bulk_operation().add_items(data).json()
+
+        -------------------------------
+        """
+        if headers is not None:
+            self.client.headers.update(headers)
+        url = f"{self.path}/release/items"
+        data = json.dumps(data)
+        return self.client.post(url, headers = self.client.headers, data = data, params=self.params)
+    
+    def update_items(self, data: dict, headers: dict = None):
+        """
+        The update items to bulk operation request allows you to update multiple entries and assets to a bulk operation.
+        
+        :return: The `update_items` method is returning the result of the `put` request made by the
+        `client.post` method.
+        -------------------------------
+            [Example:]
+                >>> data = {
+                >>>        "release": "release_uid",
+                >>>        "items": [
+                >>>            {
+                >>>                "uid": "entry_uid",
+                >>>                "locale": "en-us"
+                >>>            },
+                >>>            {
+                >>>                "uid": "entry_uid",
+                >>>                "locale": "en-us",
+                >>>                "variant_id": "entry_variant_id"
+                >>>            }
+                >>>        ]
+                >>>        or
+                >>>        [ '$all' ]
+                >>>    }
+                >>> import contentstack_management
+                >>> client = contentstack_management.Client(authtoken='your_authtoken')
+                >>> result = client.stack('api_key').bulk_operation().update_items(data).json()
+
+        -------------------------------
+        """
+        if headers is not None:
+            self.client.headers.update(headers)
+        url = f"{self.path}/release/update_items"
+        data = json.dumps(data)
+        return self.client.put(url, headers = self.client.headers, data = data, params=self.params)
+    
+    def job_status(self, job_uid: str, headers: dict = None):
+        """
+        The Job status request allows you to get the status of a bulk operation job.
+        
+        :param job_uid: The `job_uid` parameter is a string that represents the unique identifier of the job
+        whose status you want to retrieve
+        :type job_uid: str
+        :return: The `job_status` method is returning the result of the `get` request made by the
+        `client.get` method.
+        -------------------------------
+            [Example:]
+                >>> import contentstack_management
+                >>> client = contentstack_management.Client(authtoken='your_authtoken')
+                >>> result = client.stack('api_key').bulk_operation().job_status('job_uid').json()
+
+        -------------------------------
+        """
+        if job_uid is None:
+            raise ArgumentException("job_uid", "job_uid cannot be None")
+        if headers is not None:
+            self.client.headers.update(headers)
+        url = f"{self.path}/jobs/{quote(job_uid)}"
+        return self.client.get(url, headers = self.client.headers, params=self.params)
+    
     

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/content_types/content_type.py

@@ -340,7 +340,7 @@ class ContentType(Parameter):
             >>> response = content_type.imports()
         --------------------------------
         """
-        url = f"content_types/import"
+        url = "content_types/import"
         self.client.headers['Content-Type'] = "multipart/form-data"
         files = {'content_type': open(f"{file_path}", 'rb')}
         return self.client.post(url, headers=self.client.headers, params=self.params, files=files)

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/contentstack.py

@@ -1,4 +1,3 @@
-import contentstack_management
 from enum import Enum
 from ._api_client import _APIClient
 from contentstack_management.organizations import organization

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/delivery_token/delivery_token.py

@@ -5,7 +5,6 @@ the CRUD operations that can be performed on the API """
 
 import json
 from ..common import Parameter
-from urllib.parse import quote
 from .._errors import ArgumentException
 
 class DeliveryToken(Parameter):

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/entries/entry.py

@@ -5,6 +5,7 @@ the CRUD operations that can be performed on the API """
 
 import json
 from ..common import Parameter
+from ..entry_variants.entry_variants import EntryVariants
 
 class Entry(Parameter):
     """
@@ -421,13 +422,58 @@ class Entry(Parameter):
         data = json.dumps(data)
         return self.client.post(url, headers = self.client.headers, data = data, params = self.params)
     
-    
-    
-    
-    
+    def variants(self, variant_uid: str = None):
+        """
+        Returns an EntryVariants instance for managing variant entries.
+        
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        the variant. It is used to specify which variant to work with
+        :type variant_uid: str
+        :return: EntryVariants instance for managing variant entries
+        -------------------------------
+        [Example:]
 
-    
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> # Get all variant entries
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants().query().find().json()
+            >>> # Get specific variant entry
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').fetch().json()
 
+        -------------------------------
+        """
+        
+        return EntryVariants(self.client, self.content_type_uid, self.entry_uid, variant_uid)
     
+    def includeVariants(self, include_variants: str = 'true', variant_uid: str = None, params: dict = None):
+        """
+        The includeVariants method retrieves the details of a specific base entry with variant details.
+        
+        :param include_variants: The `include_variants` parameter is a string that specifies whether to include variants
+        :type include_variants: str
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        the variant. It is used to specify which variant to include
+        :type variant_uid: str
+        :param params: The `params` parameter is a dictionary that contains query parameters to be sent with the request
+        :type params: dict
+        :return: the result of the GET request made to the specified URL.
+        -------------------------------
+        [Example:]
 
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').includeVariants('true', 'variant_uid').json()
+            >>> # With parameters
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').includeVariants('true', 'variant_uid', params={'locale': 'en-us'}).json()
 
+        -------------------------------
+        """
+        if self.entry_uid is None:
+            raise Exception('Entry uid is required')
+        if params is not None:
+            self.params.update(params)
+        self.params['include_variants'] = include_variants
+        if variant_uid is not None and variant_uid != '':
+            self.params['variant_uid'] = variant_uid
+        url = f"content_types/{self.content_type_uid}/entries/{self.entry_uid}"
+        return self.client.get(url, headers = self.client.headers, params = self.params)

contentstack_management-1.5.0/contentstack_management/entry_variants/__init__.py

@@ -0,0 +1,3 @@
+from .entry_variants import EntryVariants
+
+__all__ = ['EntryVariants']

contentstack_management-1.5.0/contentstack_management/entry_variants/entry_variants.py

@@ -0,0 +1,272 @@
+"""This class takes a base URL as an argument when it's initialized, 
+which is the endpoint for the RESTFUL API that we'll be interacting with.
+The query(), create(), fetch(), delete(), update(), versions(), and includeVariants() methods each correspond to 
+the operations that can be performed on the API """
+
+import json
+from ..common import Parameter
+from .._errors import ArgumentException
+
+class EntryVariants(Parameter):
+    """
+    This class takes a base URL as an argument when it's initialized, 
+    which is the endpoint for the RESTFUL API that
+    we'll be interacting with. The query(), create(), fetch(), delete(), update(), versions(), and includeVariants() 
+    methods each correspond to the operations that can be performed on the API """
+
+    def __init__(self, client, content_type_uid: str, entry_uid: str, variant_uid: str = None):
+        self.client = client
+        self.content_type_uid = content_type_uid
+        self.entry_uid = entry_uid
+        self.variant_uid = variant_uid
+        super().__init__(self.client)
+        self.path = f"content_types/{content_type_uid}/entries/{entry_uid}/variants"
+
+
+    def find(self, params: dict = None):
+        """
+        The Find variant entries call fetches all the existing variant customizations for an entry.
+        
+        :param params: The `params` parameter is a dictionary that contains query parameters to be sent with the request
+        :type params: dict
+        :return: Json, with variant entry details.
+
+        -------------------------------
+        [Example:]
+
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack("api_key").content_types('content_type_uid').entry('entry_uid').variants().query().find().json()
+            >>> # With parameters
+            >>> result = client.stack("api_key").content_types('content_type_uid').entry('entry_uid').variants().find({'limit': 10, 'skip': 0}).json()
+
+        -------------------------------
+        """        
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        if params is not None:
+            self.params.update(params)
+        return self.client.get(self.path, headers = self.client.headers, params = self.params)
+    
+    def create(self, data: dict):
+        """
+        This call is used to create a variant entry for an entry.
+
+        :param data: The `data` parameter is the payload that you want to send in the request body. It
+        should be a dictionary or a JSON serializable object that you want to send as the request body
+        :return: Json, with variant entry details.
+
+        -------------------------------
+        [Example:]
+            >>> data = {
+            >>>        "customized_fields": [
+            >>>            "title",
+            >>>            "url"
+            >>>        ],
+            >>>        "base_entry_version": 10,  # optional
+            >>>        "entry": {
+            >>>            "title": "example",
+            >>>            "url": "/example"
+            >>>        }
+            >>>        }
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants().create(data).json()
+
+        -------------------------------
+        """
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        data = json.dumps(data)
+        return self.client.post(self.path, headers = self.client.headers, data=data, params = self.params)
+    
+    def fetch(self, variant_uid: str = None, params: dict = None):
+        """
+        The fetch Variant entry call fetches variant entry details.
+        
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        a variant. It is used to specify which variant to fetch from the server
+        :type variant_uid: str
+        :param params: The `params` parameter is a dictionary that contains query parameters to be sent with the request
+        :type params: dict
+        :return: the result of the GET request made to the specified URL.
+        -------------------------------
+        [Example:]
+
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').fetch().json()
+            >>> # With parameters
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').fetch(params={'include_count': True}).json()
+
+        -------------------------------
+        """
+        
+        if variant_uid is not None and variant_uid != '':
+            self.variant_uid = variant_uid
+
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        self.validate_variant_uid()
+        if params is not None:
+            self.params.update(params)
+        url = f"{self.path}/{self.variant_uid}"
+        return self.client.get(url, headers = self.client.headers, params = self.params)
+    
+    def delete(self, variant_uid: str = None): 
+        """
+        The delete a variant entry call is used to delete a specific variant entry.
+        
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        the variant that you want to delete
+        :type variant_uid: str
+        :return: the result of the `client.delete()` method, which is likely a response object or a
+        boolean value indicating the success of the deletion operation.
+        -------------------------------
+        [Example:]
+
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').delete().json()
+
+        -------------------------------
+        """
+        if variant_uid is not None and variant_uid != '':
+            self.variant_uid = variant_uid
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        self.validate_variant_uid()
+        url = f"{self.path}/{self.variant_uid}"
+        return self.client.delete(url, headers = self.client.headers, params = self.params)
+    
+    def update(self, data: dict, variant_uid: str = None):
+        """
+        The update a variant entry call updates an entry of a selected variant entry.
+        
+        :param data: The `data` parameter is a dictionary that contains the updated information that you
+        want to send to the server. This data will be converted to a JSON string before sending it in
+        the request
+        :type data: dict
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        the variant. It is used to specify which variant should be updated with the provided data
+        :type variant_uid: str
+        :return: the result of the `put` request made to the specified URL.
+        -------------------------------
+        [Example:]
+            >>> data = {
+            >>>        "customized_fields": [
+            >>>            "title",
+            >>>            "url"
+            >>>        ],
+            >>>        "base_entry_version": 10,  # optional
+            >>>        "entry": {
+            >>>            "title": "example",
+            >>>            "url": "/example"
+            >>>        }
+            >>>        }
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').update(data).json()
+
+        -------------------------------
+        """
+        if variant_uid is not None and variant_uid != '':
+            self.variant_uid = variant_uid
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        self.validate_variant_uid()
+        url = f"{self.path}/{self.variant_uid}"
+        data = json.dumps(data)
+        return self.client.put(url, headers = self.client.headers, data=data, params = self.params)
+    
+    def versions(self, variant_uid: str = None, params: dict = None):
+        """
+        The version method retrieves the details of a specific variant entry version details.
+        
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        the variant. It is used to specify which variant to get versions for
+        :type variant_uid: str
+        :param params: The `params` parameter is a dictionary that contains query parameters to be sent with the request
+        :type params: dict
+        :return: the result of the GET request made to the specified URL.
+        -------------------------------
+        [Example:]
+
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').versions().json()
+            >>> # With parameters
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').variants('variant_uid').versions(params={'limit': 10}).json()
+
+        -------------------------------
+        """
+        if variant_uid is not None and variant_uid != '':
+            self.variant_uid = variant_uid
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        self.validate_variant_uid()
+        if params is not None:
+            self.params.update(params)
+        url = f"{self.path}/{self.variant_uid}/versions"
+        return self.client.get(url, headers = self.client.headers, params = self.params)
+    
+    def includeVariants(self, include_variants: str = 'true', variant_uid: str = None, params: dict = None):
+        """
+        The includeVariants method retrieves the details of a specific base entry with variant details.
+        
+        :param include_variants: The `include_variants` parameter is a string that specifies whether to include variants
+        :type include_variants: str
+        :param variant_uid: The `variant_uid` parameter is a string that represents the unique identifier of
+        the variant. It is used to specify which variant to include
+        :type variant_uid: str
+        :param params: The `params` parameter is a dictionary that contains query parameters to be sent with the request
+        :type params: dict
+        :return: the result of the GET request made to the specified URL.
+        -------------------------------
+        [Example:]
+
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client(authtoken='your_authtoken')
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').includeVariants('true', 'variant_uid').json()
+            >>> # With parameters
+            >>> result = client.stack('api_key').content_types('content_type_uid').entry('entry_uid').includeVariants('true', 'variant_uid', params={'locale': 'en-us'}).json()
+
+        -------------------------------
+        """
+        if variant_uid is not None and variant_uid != '':
+            self.variant_uid = variant_uid
+        self.validate_content_type_uid()
+        self.validate_entry_uid()
+        self.validate_variant_uid()
+        if params is not None:
+            self.params.update(params)
+        self.params['include_variants'] = include_variants
+        url = f"content_types/{self.content_type_uid}/entries/{self.entry_uid}"
+        return self.client.get(url, headers = self.client.headers, params = self.params)
+    
+    def validate_content_type_uid(self):
+        """
+        The function checks if the content_type_uid is None or an empty string and raises an ArgumentException
+        if it is.
+        """
+         
+        if self.content_type_uid is None or self.content_type_uid == '':
+            raise ArgumentException("content type Uid is required")
+    
+    def validate_entry_uid(self):
+        """
+        The function checks if the entry_uid is None or an empty string and raises an ArgumentException
+        if it is.
+        """
+         
+        if self.entry_uid is None or self.entry_uid == '':
+            raise ArgumentException("entry Uid is required")
+    
+    def validate_variant_uid(self):
+        """
+        The function checks if the variant_uid is None or an empty string and raises an ArgumentException
+        if it is.
+        """
+         
+        if self.variant_uid is None or self.variant_uid == '':
+            raise ArgumentException("variant Uid is required")

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/environments/environment.py

@@ -5,7 +5,6 @@ the CRUD operations that can be performed on the API """
 
 import json
 from ..common import Parameter
-from urllib.parse import quote
 from .._errors import ArgumentException
 
 class Environment(Parameter):

{contentstack_management-1.3.3 → contentstack_management-1.5.0}/contentstack_management/extensions/extension.py

@@ -5,7 +5,6 @@ the CRUD operations that can be performed on the API """
 
 import json
 from ..common import Parameter
-from urllib.parse import quote
 from .._errors import ArgumentException
 from requests_toolbelt.multipart.encoder import MultipartEncoder