contentstack-management 1.4.0__tar.gz → 1.6.0__tar.gz

{contentstack_management-1.4.0 → contentstack_management-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentstack-management
-Version: 1.4.0
+Version: 1.6.0
 Summary: Contentstack API Client Library for Python
 Home-page: https://github.com/contentstack/contentstack-management-python
 Author: dev-ex
@@ -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.4.0 → contentstack_management-1.6.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.4.0 → contentstack_management-1.6.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__ = 'dev-ex'
 __status__ = 'debug'
 __region__ = 'na'
-__version__ = '1.4.0'
+__version__ = '1.6.0'
 __host__ = 'api.contentstack.io'
 __protocol__ = 'https://'
 __api_version__ = 'v3'

{contentstack_management-1.4.0 → contentstack_management-1.6.0}/contentstack_management/contentstack.py

@@ -11,9 +11,11 @@ version = '0.0.1'
 class Region(Enum):
     US = "us"
     EU = "eu"
+    AU = "au"
     AZURE_EU = "azure-eu"
     AZURE_NA = "azure-na"
     GCP_NA = "gcp-na"
+    GCP_EU = "gcp-eu"
 
 
 def user_agents(headers=None):
@@ -43,7 +45,7 @@ class Client:
         if headers is None:
             headers = {}
         if early_access is not None:
-            early_access_str = ', '.join(self.early_access)
+            early_access_str = ', '.join(early_access)
             headers['x-header-ea'] = early_access_str
 
         if authtoken is not None:

{contentstack_management-1.4.0 → contentstack_management-1.6.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.6.0/contentstack_management/entry_variants/__init__.py

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

contentstack_management-1.6.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.4.0 → contentstack_management-1.6.0}/contentstack_management/stack/stack.py

@@ -20,6 +20,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
 
 
 class Stack(Parameter):
@@ -351,4 +353,10 @@ class Stack(Parameter):
             return PublishQueue(self.client, publish_queue_uid)  
     
     def extension(self, extension_uid: str = None):
-            return Extension(self.client, extension_uid) 
+            return Extension(self.client, extension_uid) 
+        
+    def variant_group(self, variant_group_uid: str = None):
+            return VariantGroup(self.client, variant_group_uid)
+
+    def variants(self, variant_uid: str = None):
+        return Variants(self.client, None, variant_uid)