aepp 0.4.0.post2__py3-none-any.whl → 0.4.1__py3-none-any.whl

aepp/__version__.py

@@ -1 +1 @@
-__version__ = "0.4.0-2"
+__version__ = "0.4.1"

aepp/classmanager.py

@@ -4,6 +4,7 @@ import aepp
 from .configs import ConnectObject
 from aepp.schema import Schema
 import pandas as pd
+import numpy as np
 from copy import deepcopy
 from io import FileIO
 from pathlib import Path
@@ -451,11 +452,7 @@ class ClassManager:
                         res,foundFlag = self.__setField__(completePathList,fieldGroup[key]['properties'],newField,obj)
                         fieldGroup[key]['properties'] = res
                     else:
-                        if newField in fieldGroup[key]['properties'].keys():
-                            fieldGroup[key]['properties'][newField]['title'] = obj["title"]
-                            fieldGroup[key]['properties'][newField]['description'] = obj["description"]
-                        else:
-                            fieldGroup[key]['properties'][newField] = obj
+                        fieldGroup[key]['properties'][newField] = obj
                         foundFlag = True
                         return fieldGroup,foundFlag
                 elif 'items' in level.keys():
@@ -464,11 +461,7 @@ class ClassManager:
                             res, foundFlag = self.__setField__(completePathList,fieldGroup[key]['items']['properties'],newField,obj)
                             fieldGroup[key]['items']['properties'] = res
                         else:
-                            if newField in fieldGroup[key]['items']['properties'].keys():
-                                fieldGroup[key]['items']['properties'][newField]['title'] = obj['title']
-                                fieldGroup[key]['items']['properties'][newField]['description'] = obj['description']
-                            else:
-                                fieldGroup[key]['items']['properties'][newField] = obj
+                            fieldGroup[key]['items']['properties'][newField] = obj
                             foundFlag = True
                             return fieldGroup,foundFlag
         return fieldGroup,foundFlag
@@ -504,9 +497,16 @@ class ClassManager:
                             return success
         return success 
 
-    def __transformFieldType__(self,dataType:str=None)->dict:
+    def __transformFieldType__(self,dataType:str=None,**kwargs)->dict:
         """
         return the object with the type and possible meta attribute.
+        possible kwargs:
+            minimum : minimum value for number/integer
+            maximum : maximum value for number/integer
+            pattern : pattern for string
+            minLength : minimum length for string
+            maxLength : maximum length for string
+            default : default value for the field
         """
         obj = {}
         if dataType == 'double':
@@ -531,6 +531,10 @@ class ClassManager:
             obj['minimum'] = -128
         else:
             obj['type'] = dataType
+        list_possible_kwargs = ['minimum','maximum','pattern','minLength','maxLength','enum','default']
+        for kw in kwargs:
+            if kw in list_possible_kwargs:
+                obj[kw] = kwargs[kw]
         return obj
     
     def __transformationDict__(self,mydict:dict=None,typed:bool=False,dictionary:dict=None)->dict:
@@ -651,9 +655,8 @@ class ClassManager:
                              dictionary:dict=None,
                              path:str=None,
                              queryPath:bool=False,
-                             description:bool=False,
-                             xdmType:bool=False,
-                             required:bool=False)->dict:
+                             required:bool=False,
+                             full:bool=False)->dict:
         """
         Transform the current XDM schema to a dictionary.
         Arguments:
@@ -664,15 +667,21 @@ class ClassManager:
             description : boolean to tell if you want to retrieve the description
             xdmType : boolean to know if you want to retrieve the xdm Type
             required : boolean to know if you want to retrieve the required fields
+            full : boolean : to know if you want to retrieve all the information (minLength, etc)
         """
         if dictionary is None:
-            dictionary = {'path':[],'type':[],'title':[]}
-            if queryPath:
+            dictionary = {'path':[],'type':[],'title':[],'description':[],'xdmType':[],'mapType':[]}
+            if queryPath or full:
                 dictionary['querypath'] = []
-            if description:
-                dictionary['description'] = []
-            if xdmType:
-                dictionary['xdmType'] = []
+            if full:
+                dictionary['minLength'] = []
+                dictionary['maxLength'] = []
+                dictionary['minimum'] = []
+                dictionary['maximum'] = []
+                dictionary['pattern'] = []
+                dictionary['enumValues'] = []
+                dictionary['enum'] = []
+                dictionary['default'] = []
         else:
             dictionary = dictionary
         for key in mydict:
@@ -687,14 +696,29 @@ class ClassManager:
                         tmp_path = f"{path}.{key}"
                     if tmp_path is not None:
                         dictionary["path"].append(tmp_path)
-                        dictionary["type"].append(f"{mydict[key].get('type')}")
-                        dictionary["title"].append(f"{mydict[key].get('title')}")
-                        if queryPath:
+                        dictionary["type"].append(f"{mydict[key].get('type','')}")
+                        dictionary["title"].append(f"{mydict[key].get('title','')}")
+                        dictionary["description"].append(f"{mydict[key].get('description','')}")
+                        dictionary["xdmType"].append(f"{mydict[key].get('meta:xdmType','')}")
+                        if mydict[key].get('meta:xdmType') == 'map':
+                            dictionary["mapType"].append(f"{mydict[key].get('additionalProperties',{}).get('type','string')}")
+                        else:
+                            dictionary["mapType"].append(pd.NA)
+                        if queryPath or full:
                             dictionary["querypath"].append(self.__cleanPath__(tmp_path))
-                        if description:
-                            dictionary["description"].append(f"{mydict[key].get('description','')}")
-                        if xdmType:
-                            dictionary["xdmType"].append(f"{mydict[key].get('meta:xdmType')}")
+                        if full:
+                            dictionary['minLength'].append(mydict[key].get('minLength',np.nan))
+                            dictionary['maxLength'].append(mydict[key].get('maxLength',np.nan))
+                            dictionary['minimum'].append(mydict[key].get('minimum',np.nan))
+                            dictionary['maximum'].append(mydict[key].get('maximum',np.nan))
+                            dictionary['pattern'].append(mydict[key].get('pattern',pd.NA))
+                            dictionary['default'].append(mydict[key].get('default',pd.NA))
+                            enumValues = mydict[key].get('meta:enum',pd.NA)
+                            dictionary['enumValues'].append(enumValues)
+                            if len(mydict[key].get('enum',[])) > 0:
+                                dictionary['enum'].append(True)
+                            else:
+                                dictionary['enum'].append(False)
                         if required:
                             if len(mydict[key].get('required',[])) > 0:
                                 for elRequired in mydict[key].get('required',[]):
@@ -705,7 +729,7 @@ class ClassManager:
                                     self.requiredFields.add(tmp_reqPath)
                     properties = mydict[key].get('properties',None)
                     if properties is not None:
-                        self.__transformationDF__(properties,dictionary,tmp_path,queryPath,description,xdmType,required)
+                        self.__transformationDF__(properties,dictionary,tmp_path,queryPath,required,full=full)
                 elif mydict[key].get('type') == 'array':
                     levelProperties = mydict[key]['items'].get('properties',None)
                     if levelProperties is not None: ## array of objects
@@ -715,13 +739,28 @@ class ClassManager:
                             tmp_path = f"{path}.{key}[]{{}}"
                         dictionary["path"].append(tmp_path)
                         dictionary["type"].append(f"{mydict[key].get('type')}")
-                        dictionary["title"].append(f"{mydict[key].get('title')}")
-                        if queryPath and tmp_path is not None:
+                        dictionary["title"].append(f"{mydict[key].get('title','')}")
+                        dictionary["description"].append(mydict[key].get('description',''))
+                        dictionary["xdmType"].append(f"{mydict[key].get('meta:xdmType','')}")
+                        if mydict[key].get('meta:xdmType') == 'map':
+                            dictionary["mapType"].append(f"{mydict[key].get('additionalProperties',{}).get('type','string')}")
+                        else:
+                            dictionary["mapType"].append(pd.NA)
+                        if (queryPath or full) and tmp_path is not None:
                             dictionary["querypath"].append(self.__cleanPath__(tmp_path))
-                        if description and tmp_path is not None:
-                            dictionary["description"].append(mydict[key].get('description',''))
-                        if xdmType:
-                            dictionary["xdmType"].append(f"{mydict[key].get('meta:xdmType')}")
+                        if full:
+                            dictionary['minLength'].append(mydict[key].get('minLength',np.nan))
+                            dictionary['maxLength'].append(mydict[key].get('maxLength',np.nan))
+                            dictionary['minimum'].append(mydict[key].get('minimum',np.nan))
+                            dictionary['maximum'].append(mydict[key].get('maximum',np.nan))
+                            dictionary['pattern'].append(mydict[key].get('pattern',pd.NA))
+                            dictionary['default'].append(mydict[key].get('default',pd.NA))
+                            enumValues = mydict[key].get('meta:enum',pd.NA)
+                            dictionary['enumValues'].append(enumValues)
+                            if len(mydict[key].get('enum',[])) > 0:
+                                dictionary['enum'].append(True)
+                            else:
+                                dictionary['enum'].append(False)
                         if required:
                             if len(mydict[key].get('required',[])) > 0:
                                 for elRequired in mydict[key].get('required',[]):
@@ -730,21 +769,36 @@ class ClassManager:
                                     else:
                                         tmp_reqPath = f"{elRequired}"
                                     self.requiredFields.add(tmp_reqPath)
-                        self.__transformationDF__(levelProperties,dictionary,tmp_path,queryPath,description,xdmType,required)
+                        self.__transformationDF__(levelProperties,dictionary,tmp_path,queryPath,required,full=full)
                     else: ## simple arrays
                         if path is None:
                             finalpath = f"{key}[]"
                         else:
                             finalpath = f"{path}.{key}[]"
                         dictionary["path"].append(finalpath)
-                        dictionary["type"].append(f"{mydict[key]['items'].get('type')}[]")
-                        dictionary["title"].append(f"{mydict[key].get('title')}")
-                        if queryPath and finalpath is not None:
+                        dictionary["type"].append(f"{mydict[key]['items'].get('type','')}[]")
+                        dictionary["title"].append(f"{mydict[key].get('title','')}")
+                        dictionary["description"].append(mydict[key].get('description',''))
+                        dictionary["xdmType"].append(mydict[key]['items'].get('meta:xdmType',''))
+                        if mydict[key]['items'].get('meta:xdmType') == 'map':
+                            dictionary["mapType"].append(f"{mydict[key]['items'].get('additionalProperties',{}).get('type','string')}")
+                        else:
+                            dictionary["mapType"].append(pd.NA)
+                        if queryPath or full:
                             dictionary["querypath"].append(self.__cleanPath__(finalpath))
-                        if description and finalpath is not None:
-                            dictionary["description"].append(mydict[key].get('description',''))
-                        if xdmType:
-                            dictionary["xdmType"].append(mydict[key]['items'].get('meta:xdmType',''))
+                        if full:
+                            dictionary['minLength'].append(mydict[key]['items'].get('minLength',np.nan))
+                            dictionary['maxLength'].append(mydict[key]['items'].get('maxLength',np.nan))
+                            dictionary['minimum'].append(mydict[key]['items'].get('minimum',np.nan))
+                            dictionary['maximum'].append(mydict[key]['items'].get('maximum',np.nan))
+                            dictionary['pattern'].append(mydict[key]['items'].get('pattern',np.nan))
+                            dictionary['default'].append(mydict[key]['items'].get('default',np.nan))
+                            enumValues = mydict[key]['items'].get('meta:enum',pd.NA)
+                            dictionary['enumValues'].append(enumValues)
+                            if len(mydict[key]['items'].get('enum',[])) > 0:
+                                dictionary['enum'].append(True)
+                            else:
+                                dictionary['enum'].append(False)
                         if required:
                             if len(mydict[key].get('required',[])) > 0:
                                 for elRequired in mydict[key].get('required',[]):
@@ -758,12 +812,27 @@ class ClassManager:
                     dictionary["path"].append(finalpath)
                     dictionary["type"].append(mydict[key].get('type','object'))
                     dictionary["title"].append(mydict[key].get('title',''))
-                    if queryPath and finalpath is not None:
+                    dictionary["description"].append(mydict[key].get('description',''))
+                    dictionary["xdmType"].append(mydict[key].get('meta:xdmType',''))
+                    if mydict[key].get('meta:xdmType') == 'map':
+                        dictionary["mapType"].append(f"{mydict[key].get('additionalProperties',{}).get('type','string')}")
+                    else:
+                        dictionary["mapType"].append(pd.NA)
+                    if queryPath or full:
                         dictionary["querypath"].append(self.__cleanPath__(finalpath))
-                    if description :
-                        dictionary["description"].append(mydict[key].get('description',''))
-                    if xdmType :
-                        dictionary["xdmType"].append(mydict[key].get('meta:xdmType',''))
+                    if full:
+                        dictionary['minLength'].append(mydict[key].get('minLength',np.nan))
+                        dictionary['maxLength'].append(mydict[key].get('maxLength',np.nan))
+                        dictionary['minimum'].append(mydict[key].get('minimum',np.nan))
+                        dictionary['maximum'].append(mydict[key].get('maximum',np.nan))
+                        dictionary['pattern'].append(mydict[key].get('pattern',pd.NA))
+                        dictionary['default'].append(mydict[key].get('default',pd.NA))
+                        enumValues = mydict[key].get('meta:enum',pd.NA)
+                        dictionary['enumValues'].append(enumValues)
+                        if len(mydict[key].get('enum',[])) > 0:
+                                dictionary['enum'].append(True)
+                        else:
+                            dictionary['enum'].append(False)
                     if required:
                         if len(mydict[key].get('required',[])) > 0:
                             for elRequired in mydict[key].get('required',[]):
@@ -857,6 +926,12 @@ class ClassManager:
         possible kwargs:
             defaultPath : Define which path to take by default for adding new field on tenant. Default "customFields", possible alternative : "property"
             description : if you want to add a description on your field
+            maximum : if you want to add a maximum value for numeric field
+            minimum : if you want to add a minimum value for numeric field
+            pattern : if you want to add a pattern for string field
+            minLength : if you want to add a minimum length for string field
+            maxLength : if you want to add a maximum length for string field
+            default : if you want to add a default value for the field
         """
         if self.EDITABLE == False:
             raise Exception("The Field Group is not Editable via Field Group Manager")
@@ -916,14 +991,20 @@ class ClassManager:
                     "title":title
                 }
         else:
-            obj = self.__transformFieldType__(dataType)
+            minimum = kwargs.get('minimum',None)
+            maximum = kwargs.get('maximum',None)
+            pattern = kwargs.get('pattern',None)
+            minLength = kwargs.get('minLength',None)
+            maxLength = kwargs.get('maxLength',None)
+            default = kwargs.get('default',None)
+            obj = self.__transformFieldType__(dataType,minimum=minimum,maximum=maximum,pattern=pattern,minLength=minLength,maxLength=maxLength,default=default)
             obj['title'] = title
             obj["description"] = description,
             if type(obj["description"]) == tuple:
                 obj["description"] = obj["description"][0]
             if array:
                 obj['type'] = "array"
-                obj['items'] = self.__transformFieldType__(dataType)
+                obj['items'] = self.__transformFieldType__(dataType,minimum=minimum,maximum=maximum,pattern=pattern,minLength=minLength,maxLength=maxLength,default=default)
         if enumValues is not None and type(enumValues) == dict:
             if array == False:
                 obj['meta:enum'] = enumValues
@@ -987,28 +1068,28 @@ class ClassManager:
                      xdmType:bool=True,
                      editable:bool=False,
                      excludeObjects:bool=False,
-                     required:bool=False)->pd.DataFrame:
+                     required:bool=False,
+                     full:bool=False)->pd.DataFrame:
         """
         Generate a dataframe with the row representing each possible path.
         Arguments:
             save : OPTIONAL : If you wish to save it with the title used by the field group.
                 save as csv with the title used. Not title, used "unknown_fieldGroup_" + timestamp.
             queryPath : OPTIONAL : If you want to have the query path to be used.
-            description : OPTIONAL : If you want to have the description used (default False)
-            xdmType : OPTIONAL : If you want to have the xdmType also returned (default True)
             editable : OPTIONAL : If you can manipulate the structure of the field groups (default False)
             excludeObjects : OPTIONAL : Remove the fields that are noted down as object so only fields containing data are returned.
             required : OPTIONAL : If you want to have the required field in the dataframe (default False)
+            full : OPTIONAL : If you want to have all the possible attributes (minLength, maxLength, pattern, enum, default) in the dataframe (default False)
         """
         definition = self.aepclass.get('definitions',self.aepclass.get('properties',{}))
-        data = self.__transformationDF__(definition,queryPath=queryPath,description=description,xdmType=xdmType,required=required)
+        data = self.__transformationDF__(definition,queryPath=queryPath,required=required,full=full)
         df = pd.DataFrame(data)
         df = df[~df.path.duplicated()].copy() ## dedup the paths
         df = df[~(df['path']==self.tenantId)].copy()## remove the root
         df['origin'] = 'class'
         if self.EDITABLE:
             behaviorDefinition = self.behaviorDefinition.get('properties')
-            dataBehavior = self.__transformationDF__(behaviorDefinition,queryPath=queryPath,description=description,xdmType=xdmType,required=required)
+            dataBehavior = self.__transformationDF__(behaviorDefinition,queryPath=queryPath,required=required,full=full)
             dfBehavior = pd.DataFrame(dataBehavior)
             dfBehavior['origin'] = 'class behavior'
             df = pd.concat([df,dfBehavior],axis=0,ignore_index=True)

aepp/connector.py

@@ -250,7 +250,10 @@ class AdobeRequest:
         endpoint = f"{self.endpoints['global']}{self.endpoints['sandboxes']}/sandboxes/{sandbox}"
         res = self.getData(endpoint)
         if "id" not in res:
-            raise Exception("sandbox Id not found")
+            error_message = res.get("message", "sandbox Id not found")
+            if self.loggingEnabled:
+                self.logger.error(f"sandbox id '{sandbox}' retrieval failed: {error_message}")
+            raise Exception(error_message)
         sandbox_id = res["id"]
         self.header["x-sandbox-id"] = sandbox_id