aepp 0.5.2.post2__py3-none-any.whl → 0.5.2.post3__py3-none-any.whl

aepp/__init__.py

@@ -159,9 +159,8 @@ def __titleSafe__(text: str) -> str:
     Arguments:
         text : REQUIRED : the text to be converted
     """
-    invalid_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*', ' ']
-    for char in invalid_chars:
-        text = text.replace(char, '_')
+    valid_chars = "[^a-zA-Z0-9_\n\\.]"
+    text = re.sub(valid_chars, "_", text)
     return text
 
 
@@ -187,7 +186,7 @@ def extractSandboxArtifacts(
         completePath = mypath / f'{sandbox.sandbox}'
     else:
         completePath = Path(localFolder)
-    from aepp import schema, catalog, identity,customerprofile, segmentation
+    from aepp import schema, catalog, identity,customerprofile, segmentation, tags
     sch = schema.Schema(config=sandbox)
     cat = catalog.Catalog(config=sandbox)
     ide = identity.Identity(config=sandbox,region=region)
@@ -223,6 +222,16 @@ def extractSandboxArtifacts(
     mergePolicyPath.mkdir(exist_ok=True)
     audiencePath = completePath / 'audience'
     audiencePath.mkdir(exist_ok=True)
+    tagPath = completePath / 'tag'
+    tagPath.mkdir(exist_ok=True)
+    ## handling tags
+    tag_manager = tags.Tags(config=sandbox)
+    all_tags = tag_manager.getTags()
+    dict_id_name = {tag['id']:tag['name'] for tag in all_tags}
+    for tag in all_tags:
+        safe_name = __titleSafe__(tag.get('name','unknown'))
+        with open(f"{tagPath / safe_name}.json",'w') as f:
+            json.dump(tag,f,indent=2)
     myclasses = sch.getClasses()
     classesGlobal = sch.getClassesGlobal()
     behaviors = sch.getBehaviors()
@@ -290,6 +299,9 @@ def extractSandboxArtifacts(
     datasets = cat.getDataSets()
     for key,value in datasets.items():
         value['id'] = key
+        if len(value.get('unifiedTags',[])) > 0:
+            tag_names = [dict_id_name.get(tag_id) for tag_id in value.get('unifiedTags',[])]
+            value['unifiedTags'] = tag_names
         with open(f"{datasetPath / value.get('tags',{}).get('adobe/pqs/table',[key])[0]}.json",'w') as f:
             json.dump(value,f,indent=2)
     identities = ide.getIdentities()
@@ -307,6 +319,9 @@ def extractSandboxArtifacts(
     audiences = mysegmentation.getAudiences()
     for el in audiences:
         safe_name = __titleSafe__(el.get('name','unknown'))
+        if len(el.get('tags',[])) > 0:
+            tag_names = [dict_id_name.get(tag_id) for tag_id in el.get('tags',[])]
+            el['tags'] = tag_names
         with open(f"{audiencePath / safe_name}.json",'w') as f:
             json.dump(el,f,indent=2)
 
@@ -345,9 +360,17 @@ def extractSandboxArtifact(
     with open(f'{completePath}/config.json','w') as f:
         json.dump(globalConfig,f,indent=2)
     
-    from aepp import schema, catalog, identity
+    from aepp import schema, catalog, tags
     sch = schema.Schema(config=sandbox)
     cat = catalog.Catalog(config=sandbox)
+    ### taking care of tas
+    tagPath = completePath / 'tag'
+    tagPath.mkdir(exist_ok=True)
+    tag_manager = tags.Tags(config=sandbox)
+    all_tags = tag_manager.getTags()
+    dict_tag_id_name = {tag['id']:tag['name'] for tag in all_tags}
+    with open(f'{tagPath}/tags.json','w') as f:
+        json.dump(all_tags,f,indent=2)
     if artifactType == 'class':
         __extractClass__(artifact,completePath,sandbox)
     elif artifactType == 'schema':
@@ -357,16 +380,16 @@ def extractSandboxArtifact(
     elif artifactType == 'datatype':
         __extractDataType__(artifact,completePath,sandbox)
     elif artifactType == 'dataset':
-        __extractDataset__(artifact,completePath,sandbox,region)
+        __extractDataset__(artifact,completePath,sandbox,region,dict_tag_id_name)
     elif artifactType == 'identity':
         __extractIdentity__(artifact,region,completePath,sandbox)
     elif artifactType == 'mergepolicy':
-        __extractMergePolicy__(artifact,completePath,sandbox)
+        __extractMergePolicy__(artifact,completePath,sandbox,dict_tag_id_name=dict_tag_id_name)
     elif artifactType == 'audience':
-        __extractAudience__(artifact,completePath,sandbox)
+        __extractAudience__(artifact,completePath,sandbox,dict_tag_id_name)
     else:
         raise ValueError("artifactType not recognized")
-    
+
 def __extractClass__(classEl: str,folder: Union[str, Path] = None,sandbox: 'ConnectObject' = None):
     classPath = Path(folder) / 'class'
     classPath.mkdir(exist_ok=True)
@@ -511,7 +534,7 @@ def __extractIdentity__(identityStr: str,region:str=None,folder: Union[str, Path
     with open(f"{identityPath / file_name}.json",'w') as f:
         json.dump(myIdentity,f,indent=2)
 
-def __extractDataset__(dataset: str,folder: Union[str, Path] = None,sandbox: 'ConnectObject' = None, region:str=None):
+def __extractDataset__(dataset: str,folder: Union[str, Path] = None,sandbox: 'ConnectObject' = None, region:str=None,dict_tag_id_name: dict = None,**kwargs):
     from aepp import catalog
     cat = catalog.Catalog(config=sandbox)
     datasets = cat.getDataSets()
@@ -520,6 +543,9 @@ def __extractDataset__(dataset: str,folder: Union[str, Path] = None,sandbox: 'Co
         if key == dataset or value.get('tags',{}).get('adobe/pqs/table',[''])[0] == dataset or value.get('name','') == dataset:
             myDataset = value
             myDataset['id'] = key
+            if dict_tag_id_name is not None and len(myDataset.get('unifiedTags',[])) > 0:
+                tag_names = [dict_tag_id_name.get(tag_id) for tag_id in myDataset.get('unifiedTags',[])]
+                myDataset['unifiedTags'] = tag_names
     if myDataset is None:
         raise ValueError("Dataset not found")
     datasetPath = Path(folder) / 'dataset'
@@ -531,7 +557,7 @@ def __extractDataset__(dataset: str,folder: Union[str, Path] = None,sandbox: 'Co
     if schema is not None:
         __extractSchema__(schema,folder,sandbox,region)
 
-def __extractMergePolicy__(mergePolicy: str = None,folder:Union[str, Path]=None, sandbox: 'ConnectObject' = None,region:str=None):
+def __extractMergePolicy__(mergePolicy: str = None,folder:Union[str, Path]=None, sandbox: 'ConnectObject' = None,region:str=None,dict_tag_id_name: dict = None,**kwargs):
     from aepp import customerprofile
     ups = customerprofile.Profile(config=sandbox)
     mymergePolicies = ups.getMergePolicies()
@@ -539,13 +565,13 @@ def __extractMergePolicy__(mergePolicy: str = None,folder:Union[str, Path]=None,
     if mymergePolicy['attributeMerge'].get('type','timestampOrdered') == 'dataSetPrecedence':
         list_ds = mymergePolicy['attributeMerge'].get('order',[])
         for ds in list_ds:
-            __extractDataset__(ds,folder,sandbox,region)
+            __extractDataset__(ds,folder,sandbox,region,dict_tag_id_name=dict_tag_id_name)
     mergePolicyPath = Path(folder) / 'mergePolicy'
     mergePolicyPath.mkdir(exist_ok=True)
     with open(f"{mergePolicyPath / mymergePolicy.get('id','unknown')}.json",'w') as f:
         json.dump(mymergePolicy,f,indent=2)
 
-def __extractAudience__(audienceName: str = None,folder:Union[str, Path]=None, sandbox: 'ConnectObject' = None):
+def __extractAudience__(audienceName: str = None,folder:Union[str, Path]=None, sandbox: 'ConnectObject' = None,dict_tag_id_name: dict = None,**kwargs):
     from aepp import segmentation
     mysegmentation = segmentation.Segmentation(config=sandbox) 
     audiences = mysegmentation.getAudiences()
@@ -553,5 +579,8 @@ def __extractAudience__(audienceName: str = None,folder:Union[str, Path]=None, s
     audiencePath = Path(folder) / 'audience'
     audiencePath.mkdir(exist_ok=True)
     safe_name = __titleSafe__(myaudience.get('name','unknown'))
+    if len(myaudience.get('tags',[])) > 0 and dict_tag_id_name is not None:
+        tag_names = [dict_tag_id_name.get(tag_id) for tag_id in myaudience.get('tags',[])]
+        myaudience['tags'] = tag_names
     with open(f"{audiencePath / safe_name}.json",'w') as f:
         json.dump(myaudience,f,indent=2)

aepp/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.2-2"
+__version__ = "0.5.2-3"

aepp/catalog.py

@@ -489,6 +489,7 @@ class Catalog:
                 identityEnabled:bool=False,
                 upsert:bool=False,
                 tags:dict=None,
+                unifiedTags:list[str]=None,
                 systemLabels:list[str]=None,
                 **kwargs)-> dict:
         """
@@ -503,6 +504,7 @@ class Catalog:
             upsert : OPTIONAL : If the dataset to be created with profile enbaled and Upsert capability.
             tags : OPTIONAL : set of attribute to add as tags.
             systemLabels : OPTIONAL : A list of string to attribute system based label on creation.
+            unifiedTags : OPTIONAL : a list of tags to be added to the dataset
         possible kwargs
             requestDataSource : Set to true if you want Catalog to create a dataSource on your behalf; otherwise, pass a dataSourceId in the body.
         """
@@ -533,6 +535,8 @@ class Catalog:
                 data['tags']["unifiedIdentity"] = ["enabled:true"]
             if upsert:
                 data['tags']['unifiedProfile'] = ["enabled: true","isUpsert: true"]
+            if unifiedTags is not None and type(unifiedTags) == list:
+                data["unifiedTags"] = unifiedTags
             if tags is not None and type(tags) == dict:
                 for key in tags:
                     data['tags'][key] = tags[key]

aepp/cli/__main__.py

@@ -1,4 +1,3 @@
-from ast import arg
 from matplotlib.pyplot import table
 import aepp
 from aepp import synchronizer, schema, schemamanager, fieldgroupmanager, datatypemanager, identity, queryservice,catalog,flowservice,sandboxes, segmentation
@@ -126,15 +125,20 @@ class ServiceShell(cmd.Cmd):
         """Change the current sandbox after configuration"""
         parser = argparse.ArgumentParser(prog='change sandbox', add_help=True)
         parser.add_argument("sandbox", help="sandbox name to switch to")
-        args = parser.parse_args(shlex.split(args))
-        self.sandbox = str(args.sandbox) if args.sandbox else console.print(Panel("(!) Please provide a sandbox name using -sx or --sandbox", style="red"))
-        if self.config is not None:
-            if args.sandbox:
-                self.config.setSandbox(str(args.sandbox))
-                self.prompt = f"{self.config.sandbox}> "
-                console.print(Panel(f"Sandbox changed to: [bold green]{self.config.sandbox}[/bold green]", style="blue"))
-        else:
-            console.print(Panel("(!) You must configure the connection first using the 'config' command.", style="red"))
+        try:
+            args = parser.parse_args(shlex.split(args))
+            self.sandbox = str(args.sandbox) if args.sandbox else console.print(Panel("(!) Please provide a sandbox name using -sx or --sandbox", style="red"))
+            if self.config is not None:
+                if args.sandbox:
+                    self.config.setSandbox(str(args.sandbox))
+                    self.prompt = f"{self.config.sandbox}> "
+                    console.print(Panel(f"Sandbox changed to: [bold green]{self.config.sandbox}[/bold green]", style="blue"))
+            else:
+                console.print(Panel("(!) You must configure the connection first using the 'config' command.", style="red"))
+        except Exception as e:
+            console.print(f"(!) Error: {str(e)}", style="red")
+        except SystemExit:
+            return
     
     @login_required
     def do_get_sandboxes(self, args:Any) -> None:
@@ -890,8 +894,9 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_datasets_tableName(self, args:Any) -> None:
-        parser = argparse.ArgumentParser(prog='get_datasets', add_help=True)
+    def do_get_datasets_tableNames(self, args:Any) -> None:
+        """List all datasets with their table names in the current sandbox"""
+        parser = argparse.ArgumentParser(prog='get_datasets_tableNames', add_help=True)
         try:
             args = parser.parse_args(shlex.split(args))
             aepp_cat = catalog.Catalog(config=self.config)
@@ -1063,10 +1068,11 @@ class ServiceShell(cmd.Cmd):
     def do_get_identities(self, args:Any) -> None:
         """List all identities in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_identities', add_help=True)
-        parser.add_argument("-r","--region", help="Region to get identities from: 'ndl2' (default), 'va7', 'aus5', 'can2', 'ind2'", default='ndl2')
+        parser.add_argument("-r","--region", help="Region to get identities from: 'ndl2' (default), 'va7', 'aus5', 'can2', 'ind2'", default='ndl2',type=str)
         parser.add_argument("-co","--custom_only",help="Get only custom identities", default=False,type=bool)
         try:
             args = parser.parse_args(shlex.split(args))
+            region = args.region if args.region else 'ndl2'
             aepp_identity = identity.Identity(config=self.config,region=args.region)
             identities = aepp_identity.getIdentities(only_custom=args.custom_only)
             df_identites = pd.DataFrame(identities)
@@ -1123,7 +1129,7 @@ class ServiceShell(cmd.Cmd):
             table.add_column("Name", style="magenta")
             table.add_column("Evaluation", style="yellow")
             table.add_column("Total Profiles", style="green")
-            table.add_column("Shared", style="white")
+            table.add_column("In Flow", style="white")
             for aud in audiences:
                 table.add_row(
                     aud.get("id","N/A"),
@@ -1138,6 +1144,36 @@ class ServiceShell(cmd.Cmd):
         except SystemExit:
             return
     
+    @login_required
+    def do_get_tags(self,args)->None:
+        """
+        Provide the list of tags defined in the current organization
+        """
+        parser = argparse.ArgumentParser(prog='get_tags', add_help=True)
+        try:
+            from aepp import tags
+            args = parser.parse_args(shlex.split(args))
+            aepp_tag = tags.Tags(config=self.config)
+            tags = aepp_tag.getTags()
+            df_tags = pd.DataFrame(tags)
+            df_tags.to_csv(f"tags.csv",index=False)
+            console.print(f"Tags exported to tags.csv", style="green")
+            table = Table(title=f"Tags in Organization: {self.config.org_id}")
+            table.add_column("ID", style="cyan")
+            table.add_column("Name", style="magenta")
+            table.add_column("Category Name", style="white")
+            for _, tg in df_tags.iterrows():
+                table.add_row(
+                    str(tg.get("id","N/A")),
+                    tg.get("name","N/A"),
+                    tg.get("tagCategoryName","N/A"),
+                )
+            console.print(table)
+        except Exception as e:
+            console.print(f"(!) Error: {str(e)}", style="red")
+        except SystemExit:
+            return
+    
     @login_required
     def do_get_flows(self, args:Any) -> None:
         """List flows in the current sandbox based on parameters provided. By default, list all sources and destinations."""
@@ -1440,7 +1476,7 @@ class ServiceShell(cmd.Cmd):
             conn = aepp_query.connection()
             iqs2 = queryservice.InteractiveQuery2(conn)
             result:pd.DataFrame = iqs2.query(sql=args.sql_query)
-            result.to_csv(f"query_result_{int(datetime.now().timestamp())}.csv", index=False)
+            result.sample(5).to_csv(f"query_result_{int(datetime.now().timestamp())}.csv", index=False)
             console.print(f"Query result exported to query_result_{int(datetime.now().timestamp())}.csv", style="green")
             console.print(result)
         except Exception as e:
@@ -1452,11 +1488,11 @@ class ServiceShell(cmd.Cmd):
     @login_required
     def do_extractArtifacts(self,args:Any) -> None:
         """extractArtifacts localfolder"""
-        console.print("Extracting artifacts...", style="blue")
-        parser = argparse.ArgumentParser(prog='extractArtifacts', description='Extract artifacts from AEP')
+        parser = argparse.ArgumentParser(prog='extractArtifacts', description='Extract artifacts from AEP',add_help=True)
         parser.add_argument('-lf','--localfolder', help='Local folder to extract artifacts to', default='./extractions')
         parser.add_argument('-rg','--region', help='Region to extract artifacts from: "ndl2" (default), "va7", "aus5", "can2", "ind2"',default='ndl2')
         try:
+            console.print("Extracting artifacts...", style="blue")
             args = parser.parse_args(shlex.split(args))
             aepp.extractSandboxArtifacts(
                 sandbox=self.config,
@@ -1466,18 +1502,19 @@ class ServiceShell(cmd.Cmd):
             console.print(Panel("Extraction completed!", style="green"))
         except SystemExit:
             return
+        except Exception as e:
+            console.print(f"(!) Error: {str(e)}", style="red")
 
     @login_required
     def do_extractArtifact(self,args:Any) -> None:
         """extractArtifacts localfolder"""
-        console.print("Extracting artifact...", style="blue")
-        parser = argparse.ArgumentParser(prog='extractArtifact', description='Extract artifacts from AEP')
+        parser = argparse.ArgumentParser(prog='extractArtifact', description='Extract artifacts from AEP',add_help=True)
         parser.add_argument('artifact', help='artifact to extract (name or id): "schema","fieldgroup","datatype","descriptor","dataset","identity","mergepolicy","audience"')
         parser.add_argument('-at','--artifactType', help='artifact type ')
         parser.add_argument('-lf','--localfolder', help='Local folder to extract artifacts to',default='extractions')
         parser.add_argument('-rg','--region', help='Region to extract artifacts from: "ndl2" (default), "va7", "aus5", "can2", "ind2"',default='ndl2')
-        
         try:
+            console.print("Extracting artifact...", style="blue")
             args = parser.parse_args(shlex.split(args))
             aepp.extractSandboxArtifact(
                 artifact=args.artifact,
@@ -1488,12 +1525,13 @@ class ServiceShell(cmd.Cmd):
             console.print("Extraction completed!", style="green")
         except SystemExit:
             return
+        except Exception as e:
+            console.print(f"(!) Error: {str(e)}", style="red")
 
     @login_required
     def do_sync(self,args:Any) -> None:
         """extractArtifacts localfolder"""
-        console.print("Syncing artifact...", style="blue")
-        parser = argparse.ArgumentParser(prog='extractArtifact', description='Extract artifacts from AEP')
+        parser = argparse.ArgumentParser(prog='extractArtifact', description='Extract artifacts from AEP',add_help=True)
         parser.add_argument('artifact', help='artifact to extract (name or id): "schema","fieldgroup","datatype","descriptor","dataset","identity","mergepolicy","audience"')
         parser.add_argument('-at','--artifactType', help='artifact type ',type=str)
         parser.add_argument('-t','--targets', help='target sandboxes',nargs='+',type=str)
@@ -1504,18 +1542,22 @@ class ServiceShell(cmd.Cmd):
         try:
             args = parser.parse_args(shlex.split(args))
             console.print("Initializing Synchronizor...", style="blue")
+            if args.region:
+                region=args.region
+            else:
+                region='ndl2'
             if args.baseSandbox:
                 synchronizor = synchronizer.Synchronizer(
                     config=self.config,
                     targets=args.targets,
-                    region=args.region,
+                    region=region,
                     baseSandbox=args.baseSandbox,
                 )
             elif args.localfolder:
                 synchronizor = synchronizer.Synchronizer(
                     config=self.config,
                     targets=args.targets,
-                    region=args.region,
+                    region=region,
                     localFolder=args.localfolder,
             )
             console.print("Starting Sync...", style="blue")

aepp/fieldgroupmanager.py

@@ -241,7 +241,7 @@ class FieldGroupManager:
                                     if '/datatypes/' in str(self.fieldGroup):
                                         dataTypeSearch = f"(https://ns.adobe.com/{self.tenantId[1:]}/datatypes/[0-9a-z]+?)'"
                                         dataTypes = re.findall(dataTypeSearch,str(self.fieldGroup.get('definitions')))
-                                        for file in self.datatypeFolder.glob('*.json'):
+                                        for file in folder.glob('*.json'):
                                             tmp_def = json.load(FileIO(file))
                                             if tmp_def.get('$id') in dataTypes or tmp_def.get('meta:altId') in dataTypes:
                                                 dt_manager = DataTypeManager(tmp_def,localFolder=self.localfolder,sandbox=self.sandbox,tenantId=self.tenantId)

aepp/identity.py

@@ -86,8 +86,8 @@ class Identity:
             self.sandbox = self.connector.config["sandbox"]
 
         environment = config["environment"]
-        base_url = f"https://platform-{region}.adobe.io"
-
+        #base_url = f"https://platform-{region}.adobe.io"
+        base_url = f"https://platform.adobe.io"
         if environment != "prod":
             base_url = f"https://platform-{environment}-{region}.adobe.io"
 

aepp/schema.py

@@ -74,8 +74,8 @@ class Schema:
 
     def __init__(
         self,
-        containerId: str = "tenant",
         config: Union[dict,ConnectObject] = aepp.config.config_object,
+        containerId: str = "tenant",
         header=aepp.config.header,
         loggingObject: dict = None,
         **kwargs,
@@ -83,12 +83,10 @@ class Schema:
         """
         Copy the token and header and initiate the object to retrieve schema elements.
         Arguments:
-            containerId : OPTIONAL : "tenant"(default) or "global"
-            loggingObject : OPTIONAL : logging object to log messages.
             config : OPTIONAL : config object in the config module.
+            containerId : OPTIONAL : "tenant"(default) or "global"
             header : OPTIONAL : header object  in the config module.
-        possible kwargs:
-            x-sandbox-name : name of the sandbox you want to use (default : "prod").
+            loggingObject : OPTIONAL : logging object to log messages.
         """
         if loggingObject is not None and sorted(
             ["level", "stream", "format", "filename", "file"]

aepp/schemamanager.py

@@ -167,8 +167,10 @@ class SchemaManager:
                     fgM = FieldGroupManager(fieldGroup=definition,schemaAPI=self.schemaAPI,localFolder=localFolder,tenantId=self.tenantId,sandbox=self.sandbox)
                 self.fieldGroupsManagers[fgM.title] = fgM
             for clas in self.classIds:
+                clsM = None
                 clsM = ClassManager(clas,schemaAPI=self.schemaAPI,localFolder=localFolder,tenantId=self.tenantId,sandbox=self.sandbox)
-                self.classManagers[clsM.title] = clsM
+                if clsM is not None:
+                    self.classManagers[clsM.title] = clsM
         elif type(schema) == str:
             if self.schemaAPI is not None:
                 self.schema = self.schemaAPI.getSchema(schema,full=False,schema_type='xed')
@@ -254,6 +256,7 @@ class SchemaManager:
                 fgM = FieldGroupManager(fieldGroup=definition,schemaAPI=self.schemaAPI,localFolder=localFolder,tenantId=self.tenantId,sandbox=self.sandbox)
                 self.fieldGroupsManagers[fgM.title] = fgM
             for clas in self.classIds:
+                clsM = None
                 if self.localfolder is not None:
                     found = False
                     for folder in self.classFolder:
@@ -269,7 +272,8 @@ class SchemaManager:
                             break
                 elif self.schemaAPI is not None:
                     clsM = ClassManager(clas,schemaAPI=self.schemaAPI,localFolder=localFolder,tenantId=self.tenantId,sandbox=self.sandbox)
-                self.classManagers[clsM.title] = clsM
+                if clsM is not None:
+                    self.classManagers[clsM.title] = clsM
         elif schema is None:
             self.STATE = "NEW"
             self.classId = schemaClass
@@ -284,8 +288,10 @@ class SchemaManager:
                         ]
                     }
             for clas in self.classIds:
+                clsM = None
                 clsM = ClassManager(clas,schemaAPI=self.schemaAPI,localFolder=localFolder,tenantId=self.tenantId,sandbox=self.sandbox)
-                self.classManagers[clsM.title] = clsM
+                if clsM is not None:
+                    self.classManagers[clsM.title] = clsM
         if fieldGroups is not None and type(fieldGroups) == list:
             if fieldGroups[0] == str:
                 for fgId in fieldGroups:
@@ -322,9 +328,11 @@ class SchemaManager:
                     self.fieldGroupsManagers[fgM.title] = fgM
             elif fieldGroups[0] == dict:
                 for fg in fieldGroups:
+                    fgM = None
                     self.fieldGroupIds.append(fg.get('$id'))
                     fgM = FieldGroupManager(fg,schemaAPI=self.schemaAPI, localFolder=localFolder,tenantId=self.tenantId,sandbox=self.sandbox)
-                    self.fieldGroupsManagers[fgM.title] = fgM
+                    if fgM is not None:
+                        self.fieldGroupsManagers[fgM.title] = fgM
         self.fieldGroupTitles= tuple(fg.title for fg in list(self.fieldGroupsManagers.values()))
         self.fieldGroups = {fg.id:fg.title for fg in list(self.fieldGroupsManagers.values())}
         self.fieldGroupIds = tuple(fg.id for fg in list(self.fieldGroupsManagers.values()))

aepp/synchronizer.py

@@ -20,7 +20,12 @@ from .configs import ConnectObject
 
 class Synchronizer:
     ## TO DO -> Add support for local environment
-    def __init__(self,targets:list=None,config:'ConnectObject'=None,baseSandbox:str=None,region:str='nld2',localFolder:str|list|None=None):
+    def __init__(self,
+                 targets:list|None=None,
+                 config:ConnectObject|None=None,
+                 baseSandbox:str|None=None,
+                 region:str='nld2',
+                 localFolder:str|list|None=None):
         """
         Setup the synchronizor object with the base sandbox and target sandbox.
         Arguments:
@@ -71,6 +76,19 @@ class Synchronizer:
             self.descriptorFolder = [folder / 'descriptor' for folder in self.localfolder]
             self.mergePolicyFolder = [folder / 'mergepolicy' for folder in self.localfolder]
             self.audienceFolder = [folder / 'audience' for folder in self.localfolder]
+            self.tagFolder = [folder / 'tag' for folder in self.localfolder]
+            self.dict_tag_name_id = {}
+            for folder in self.tagFolder:
+                try:
+                    if folder.exists():
+                        with open(folder / 'tags.json','r') as f:
+                            tags_file = json.load(f)
+                        for tag in tags_file:
+                            self.dict_tag_name_id[tag['name']] = tag['id']
+                    pass
+                except Exception as e:
+                    print(f"could not load tags from folder {folder} : {e}")
+                    pass
             if baseSandbox is not None:
                 self.baseSandbox = baseSandbox
             else:
@@ -85,7 +103,7 @@ class Synchronizer:
         self.dict_baseComponents = {'schema':{},'class':{},'fieldgroup':{},'datatype':{},'datasets':{},'identities':{},"schemaDescriptors":{},'mergePolicy':{},'audience':{}}  
         self.dict_targetComponents = {target:{'schema':{},'class':{},'fieldgroup':{},'datatype':{},'datasets':{},'identities':{},"schemaDescriptors":{},'mergePolicy':{},'audience':{}} for target in targets}
 
-    def getSyncFieldGroupManager(self,fieldgroup:str,sandbox:str=None)-> dict:
+    def getSyncFieldGroupManager(self,fieldgroup:str,sandbox:str|None=None)-> dict:
         """
         Get a field group Manager from the synchronizer.
         It searches through the component cache to see if the FieldGroupManager for the target sandbox is already instantiated.
@@ -119,7 +137,7 @@ class Synchronizer:
             else:
                 raise ValueError(f"the field group '{fieldgroup}' has not been synchronized to the sandbox '{sandbox}'")
     
-    def getDatasetName(self,datasetId:str,sandbox:str=None)-> str:
+    def getDatasetName(self,datasetId:str,sandbox:str|None=None)-> str:
         """
         Get a dataset name from the synchronizer base on the ID of the dataset.
         Arguments:
@@ -139,7 +157,7 @@ class Synchronizer:
             else:
                 raise ValueError(f"the dataset '{datasetId}' has not been synchronized to the sandbox '{sandbox}'")
 
-    def syncComponent(self,component:Union[str,dict],componentType:str=None,force:bool=False,verbose:bool=False)-> dict:
+    def syncComponent(self,component:Union[str,dict],componentType:str|None=None,force:bool=False,verbose:bool=False)-> dict:
         """
         Synchronize a component to the target sandbox.
         The component could be a string (name or id of the component in the base sandbox) or a dictionary with the definition of the component.
@@ -235,6 +253,8 @@ class Synchronizer:
                         for file in folder.glob('*.json'):
                             ds_file = json.load(FileIO(file))
                             if ds_file['id'] == component or ds_file['name'] == component:
+                                if ds_file.get('UnifiedTags',[]) != [] and self.dict_tag_name_id is not None:
+                                    ds_file['unifiedTags'] = [self.dict_tag_name_id[tag_name] for tag_name in ds_file.get('UnifiedTags',[]) if tag_name in self.dict_tag_name_id.keys()]
                                 component = ds_file
                                 break
                 if len(component) == 1: ## if the component is the catalog API response {'key': {dataset definition}}
@@ -263,6 +283,8 @@ class Synchronizer:
                         for file in folder.glob('*.json'):
                             au_file = json.load(FileIO(file))
                             if au_file.get('id','') == component or au_file.get('name','') == component:
+                                if au_file.get('tags',[]) != [] and self.dict_tag_name_id is not None:
+                                    au_file['tags'] = [self.dict_tag_name_id[tag_name] for tag_name in au_file.get('tags',[]) if tag_name in self.dict_tag_name_id.keys()]
                                 component = au_file
                                 break
         elif type(component) == dict:
@@ -345,6 +367,7 @@ class Synchronizer:
             raise TypeError("the baseDataType must be a DataTypeManager object")
         self.dict_baseComponents['datatype'][baseDataType.title] = baseDataType
         name_base_datatype = baseDataType.title
+        description_base_datatype = baseDataType.description
         for target in self.dict_targetsConfig.keys():
             targetSchema = schema.Schema(config=self.dict_targetsConfig[target])
             t_datatype = None
@@ -362,7 +385,7 @@ class Synchronizer:
                 base_paths = df_base['path'].tolist()
                 target_paths = df_target['path'].tolist()
                 diff_paths = list(set(base_paths) - set(target_paths))
-                if len(diff_paths) > 0 or force==True: ## there are differences
+                if len(diff_paths) > 0 or description_base_datatype != t_datatype.description or force==True: ## there are differences
                     base_datatypes_paths = baseDataType.getDataTypePaths()
                     df_base_limited = df_base[df_base['origin'] == 'self'].copy() ## exclude field group native fields
                     df_base_limited = df_base_limited[~df_base_limited['path'].isin(list(base_datatypes_paths.keys()))] ## exclude base of datatype rows
@@ -394,6 +417,7 @@ class Synchronizer:
                     print(f"datatype '{name_base_datatype}' does not exist in target {target}, creating it")
                 df_base = baseDataType.to_dataframe(full=True)
                 new_datatype = datatypemanager.DataTypeManager(title=name_base_datatype,config=self.dict_targetsConfig[target],sandbox=target)
+                new_datatype.setDescription(description_base_datatype)
                 base_datatypes_paths = baseDataType.getDataTypePaths()
                 df_base_limited = df_base[df_base['origin'] == 'self'].copy() ## exclude field group native fields
                 df_base_limited = df_base_limited[~df_base_limited['path'].isin(list(base_datatypes_paths.keys()))] ## exclude base of datatype rows
@@ -413,7 +437,7 @@ class Synchronizer:
                         arrayBool = True
                         path = path[:-4] ## removing the [] from the path
                     new_datatype.addField(path=path,dataType='dataType',ref=tmp_t_dt.id,array=arrayBool)
-                new_datatype.setDescription(baseDataType.description)
+                new_datatype.setDescription(description_base_datatype)
                 res = new_datatype.createDataType()
                 if '$id' in res.keys():
                     t_datatype = datatypemanager.DataTypeManager(res['$id'],config=self.dict_targetsConfig[target],sandbox=target)
@@ -434,6 +458,7 @@ class Synchronizer:
         self.dict_baseComponents['fieldgroup'][baseFieldGroup.title] = baseFieldGroup
         name_base_fieldgroup = baseFieldGroup.title
         base_fg_classIds = baseFieldGroup.classIds
+        base_fg_description = baseFieldGroup.description
         for target in self.dict_targetsConfig.keys():
             t_fieldgroup = None
             targetSchema = schema.Schema(config=self.dict_targetsConfig[target])
@@ -465,7 +490,9 @@ class Synchronizer:
                 base_paths = df_base['path'].tolist()
                 target_paths = df_target['path'].tolist()
                 diff_paths = [path for path in base_paths if path not in target_paths]
-                if len(diff_paths) > 0 or force==True:
+                if len(diff_paths) > 0 or base_fg_description != t_fieldgroup.description or force==True:
+                    if verbose:
+                        print(f"updating field group '{name_base_fieldgroup}' in target {target}")
                     base_datatypes_paths = baseFieldGroup.getDataTypePaths()
                     ## handling fieldgroup native fields
                     df_base_limited = df_base[df_base['origin'] == 'fieldGroup'].copy() ## exclude datatypes
@@ -500,6 +527,8 @@ class Synchronizer:
                             t_fieldgroup.addField(path=path,dataType='dataType',ref=tmp_t_dt.id,array=arrayBool)
                     if len(t_fieldgroup.classIds) != len(fg_class_ids):
                         t_fieldgroup.updateClassSupported(fg_class_ids)
+                    if base_fg_description != t_fieldgroup.description:
+                        t_fieldgroup.setDescription(base_fg_description)
                     res = t_fieldgroup.updateFieldGroup()
                     if '$id' not in res.keys():
                         raise Exception(res)
@@ -547,7 +576,7 @@ class Synchronizer:
                         arrayBool = True
                         path = path[:-4] ## removing the [] from the path
                     new_fieldgroup.addField(path=path,dataType='dataType',ref=tmp_t_dt.id,array=arrayBool)
-                new_fieldgroup.setDescription(baseFieldGroup.description)
+                new_fieldgroup.setDescription(base_fg_description)
                 res = new_fieldgroup.createFieldGroup()
                 if '$id' in res.keys():
                     t_fieldgroup = fieldgroupmanager.FieldGroupManager(res['$id'],config=self.dict_targetsConfig[target],sandbox=target)
@@ -571,6 +600,7 @@ class Synchronizer:
         self.dict_baseComponents['schema'][name_base_schema] = baseSchema
         descriptors = baseSchema.getDescriptors()
         base_field_groups_names = list(baseSchema.fieldGroups.values())
+        base_schema_description = baseSchema.description
         dict_base_fg_name_id = {name:fg_id for fg_id,name in baseSchema.fieldGroups.items()}
         for target in self.dict_targetsConfig.keys():
             targetSchemaAPI = schema.Schema(config=self.dict_targetsConfig[target])
@@ -582,9 +612,13 @@ class Synchronizer:
                 t_schema = schemamanager.SchemaManager(targetSchemaAPI.data.schemas_altId[name_base_schema],config=self.dict_targetsConfig[target],sandbox=target)
                 new_fieldgroups = [fg for fg in base_field_groups_names if fg not in t_schema.fieldGroups.values()]
                 existing_fieldgroups = [fg for fg in base_field_groups_names if fg in t_schema.fieldGroups.values()]
-                if len(new_fieldgroups) > 0 or force==True: ## if new field groups
+                if len(new_fieldgroups) > 0 or base_schema_description != t_schema.description or force==True: ## if new field groups
                     if verbose:
-                        print('found new field groups to add to the schema')
+                        if force == False:
+                            print('found difference in the schema, updating it')
+                        else:
+                            print('force flag is set to True, updating the schema')
+                    ## handling field groups
                     for new_fieldgroup in new_fieldgroups:
                         if baseSchema.tenantId[1:] not in dict_base_fg_name_id[new_fieldgroup]: ## ootb field group
                             if verbose:
@@ -598,7 +632,7 @@ class Synchronizer:
                             print(f"Creating new custom field group '{tmp_FieldGroup.title}'")
                             self.__syncFieldGroup__(tmp_FieldGroup,verbose=verbose,force=force)
                             t_schema.addFieldGroup(self.dict_targetComponents[target]['fieldgroup'][new_fieldgroup].id)
-                    t_schema.setDescription(baseSchema.description)
+                    t_schema.setDescription(base_schema_description)
                     res = t_schema.updateSchema()
                     if '$id' not in res.keys():
                         raise Exception(res)
@@ -652,6 +686,7 @@ class Synchronizer:
                 else:
                     classId_toUse = baseClassId
                 new_schema = schemamanager.SchemaManager(title=name_base_schema,config=self.dict_targetsConfig[target],schemaClass=classId_toUse,sandbox=target)
+                new_schema.setDescription(base_schema_description)
                 for fg_name in base_field_groups_names:
                     if baseSchema.tenantId[1:] not in dict_base_fg_name_id[fg_name]: ## ootb field group
                         new_schema.addFieldGroup(dict_base_fg_name_id[fg_name])
@@ -665,7 +700,6 @@ class Synchronizer:
                         tmp_FieldGroup = baseSchema.getFieldGroupManager(fg_name)
                         self.__syncFieldGroup__(tmp_FieldGroup,force=force,verbose=verbose)
                         new_schema.addFieldGroup(self.dict_targetComponents[target]['fieldgroup'][fg_name].id)
-                new_schema.setDescription(baseSchema.description)
                 res = new_schema.createSchema()
                 if '$id' in res.keys():
                     t_schema = schemamanager.SchemaManager(res['$id'],config=self.dict_targetsConfig[target],sandbox=target)
@@ -739,9 +773,10 @@ class Synchronizer:
                         baseIdentities = identityConn.getIdentities()
                     elif self.localfolder is not None:
                         baseIdentities = []
-                        for file in self.identityFolder.glob('*.json'):
-                            id_file = json.load(FileIO(file))
-                            baseIdentities.append(id_file)
+                        for folder in self.identityFolder:
+                            for file in folder.glob('*.json'):
+                                id_file = json.load(FileIO(file))
+                                baseIdentities.append(id_file)
                     if baseIdentityNS not in [el['xdm:namespace'].lower() for el in target_identitiesDecs]: ## identity descriptor does not exists in target schema
                         def_identity = [el for el in baseIdentities if el['code'].lower() == baseIdentityNS][0]
                         self.__syncIdentity__(def_identity,verbose=verbose)
@@ -852,9 +887,10 @@ class Synchronizer:
                         baseIdentities = identityConn.getIdentities()
                     elif self.localfolder is not None:
                         baseIdentities = []
-                        for file in self.identityFolder.glob('*.json'):
-                            id_file = json.load(FileIO(file))
-                            baseIdentities.append(id_file)
+                        for folder in self.identityFolder:
+                            for file in folder.glob('*.json'):
+                                id_file = json.load(FileIO(file))
+                                baseIdentities.append(id_file)
                     def_identity = [el for el in baseIdentities if el['code'] == baseIdentityNS][0]
                     self.__syncIdentity__(def_identity,verbose=verbose)
                     target_referenceIdentity = [desc for desc in target_descriptors if desc['@type'] == 'xdm:descriptorReferenceIdentity']
@@ -916,6 +952,7 @@ class Synchronizer:
         self.dict_baseComponents['datasets'][baseDataset['name']] = baseDataset
         base_datasetName = baseDataset['name']
         base_dataset_related_schemaId = baseDataset['schemaRef']['id']
+        base_dataset_unifiedTagIds = baseDataset.get('unifiedTags',[])
         if self.baseConfig is not None:
             baseSchemaAPI = schema.Schema(config=self.baseConfig)
             base_schemas = baseSchemaAPI.getSchemas()
@@ -929,7 +966,7 @@ class Synchronizer:
         for target in self.dict_targetsConfig.keys():
             targetCatalog = catalog.Catalog(config=self.dict_targetsConfig[target])
             t_datasets = targetCatalog.getDataSets()
-            if base_datasetName not in targetCatalog.data.ids.keys(): ## only taking care if dataset does not exist
+            if base_datasetName not in targetCatalog.data.ids.keys(): ## if dataset does not exist
                 if verbose:
                     print(f"dataset '{base_datasetName}' does not exist in target {target}, creating it")
                 targetSchema = schema.Schema(config=self.dict_targetsConfig[target])
@@ -940,15 +977,18 @@ class Synchronizer:
                     baseSchemaManager = schemamanager.SchemaManager(base_dataset_related_schemaId,config=self.baseConfig,localFolder=self.localfolder,sandbox=self.baseSandbox)
                     self.__syncSchema__(baseSchemaManager,verbose=verbose)
                     targetSchemaId = self.dict_targetComponents[target]['schema'][base_dataset_related_schemaName].id
-                    res = targetCatalog.createDataSet(name=base_datasetName,schemaId=targetSchemaId)
+                    res = targetCatalog.createDataSet(name=base_datasetName,schemaId=targetSchemaId,unifiedTags=base_dataset_unifiedTagIds)
                     self.dict_targetComponents[target]['datasets'][base_datasetName] = res
                 else: ## schema already exists in target
                     if verbose:
                         print(f"related schema '{base_dataset_related_schemaName}' does exist in target {target}, checking it")
                     baseSchemaManager = schemamanager.SchemaManager(base_dataset_related_schemaId,config=self.baseConfig,localFolder=self.localfolder,sandbox=self.baseSandbox)
                     self.__syncSchema__(baseSchemaManager,verbose=verbose)
-                    targetSchemaId = targetSchema.data.schemas_id[base_dataset_related_schemaName]
-                    res = targetCatalog.createDataSet(name=base_datasetName,schemaId=targetSchemaId)
+                    target_schema = self.dict_targetComponents[target]['schema'][base_dataset_related_schemaName]
+                    targetSchemaId = target_schema.id
+                    print(f"Target Schema ID: {targetSchemaId}")
+                    print(f"unified Tags: {base_dataset_unifiedTagIds}")
+                    res = targetCatalog.createDataSet(name=base_datasetName,schemaId=targetSchemaId,unifiedTags=base_dataset_unifiedTagIds)
                     self.dict_targetComponents[target]['datasets'][base_datasetName] = res
             else: ## dataset already exists in target
                 if verbose:
@@ -958,6 +998,16 @@ class Synchronizer:
                 t_schemas = targetSchema.getSchemas()
                 baseSchemaManager = schemamanager.SchemaManager(base_dataset_related_schemaId,config=self.baseConfig,localFolder=self.localfolder,sandbox=self.baseSandbox)
                 self.__syncSchema__(baseSchemaManager,verbose=verbose)
+                if verbose:
+                    print(f"dataset '{base_datasetName}' schema synchronized, checking unified tags")
+                if len(base_dataset_unifiedTagIds) > 0:
+                    t_dataset_unifiedTagIds = t_dataset.get('unifiedTags',[])
+                    tags_toAdd = [tagId for tagId in base_dataset_unifiedTagIds if tagId not in t_dataset_unifiedTagIds]
+                    if len(tags_toAdd) > 0:
+                        if verbose:
+                            print(f"adding unified tags to dataset '{base_datasetName}' in target {target}")
+                        t_dataset['unifiedTags'] = t_dataset_unifiedTagIds + tags_toAdd
+                        res = targetCatalog.putDataset(t_dataset['id'],t_dataset)
                 self.dict_targetComponents[target]['datasets'][base_datasetName] = t_dataset
 
     def __syncMergePolicy__(self,mergePolicy:dict,verbose:bool=False)->None:
@@ -1036,7 +1086,8 @@ class Synchronizer:
                     "expression":baseAudience.get('expression',[]),
                     "ansibleDataModel":baseAudience.get('ansibleDataModel',{}),
                     "profileInstanceId":baseAudience.get('profileInstanceId',''),
-                    "evaluationInfo":baseAudience.get('evaluationInfo',{'batch': {'enabled': True}, 'continuous': {'enabled': False},'synchronous': {'enabled': False}})
+                    "evaluationInfo":baseAudience.get('evaluationInfo',{'batch': {'enabled': True}, 'continuous': {'enabled': False},'synchronous': {'enabled': False}}),
+                    "tags":baseAudience.get('tags',[])
                 }
                 res = targetAudiences.createAudience(audienceDef)
                 if 'id' in res.keys():
@@ -1052,6 +1103,7 @@ class Synchronizer:
                 t_audience['expression'] = baseAudience.get('expression',[])
                 t_audience['ansibleDataModel'] = baseAudience.get('ansibleDataModel',{})
                 t_audience['evaluationInfo'] = baseAudience.get('evaluationInfo',{'batch': {'enabled': True}, 'continuous': {'enabled': False},'synchronous': {'enabled': False}})
+                t_audience['tags'] = baseAudience.get('tags',[])
                 res = targetAudiences.putAudience(t_audience['id'],t_audience)
                 self.dict_targetComponents[target]['audience'][audience_name] = res
 

{aepp-0.5.2.post2.dist-info → aepp-0.5.2.post3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aepp
-Version: 0.5.2.post2
+Version: 0.5.2.post3
 Summary: Package to manage AEP API endpoint and some helper functions
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache-2.0

{aepp-0.5.2.post2.dist-info → aepp-0.5.2.post3.dist-info}/RECORD

@@ -1,7 +1,7 @@
-aepp/__init__.py,sha256=rsU4OMu3pJIgy8emJAD6lhAfqH0-raZ6GyIMJanNBdM,27912
-aepp/__version__.py,sha256=Cg8MGKgYvVWLyB1zXrrIwnb1heE7cYSFsuUcUYCJuQk,23
+aepp/__init__.py,sha256=slCyBeqU3LA_TAS59z2Ng-MnVIJ-1iKt6PrNu1QWHRk,29641
+aepp/__version__.py,sha256=p2cBUcJxYGyXCezEzS7TxbGXCMvfeDr--WndrJa0ASc,23
 aepp/accesscontrol.py,sha256=PB3FcrO4bvDjdNxjHx7p_20hp4ahBXewoOSxuTGMXC8,17423
-aepp/catalog.py,sha256=hK9m3SAP0fhgkYqu14Tcfq14qBhw54tLCOF0mH31b1M,68237
+aepp/catalog.py,sha256=4s3Uzm26gGW4a55dyDRvjhmY8laQiJ0iyzT2s2A1h6I,68484
 aepp/classmanager.py,sha256=16hx_hptg3PYwmezZCr9dLjvOkNSunih1PK3Q-iPoZY,66099
 aepp/config.py,sha256=232fcO8JaYJnS4glf8Ebnx9rCdHshZBVaVUbhoOAXkc,2543
 aepp/configs.py,sha256=5rRWJoUQDDaj3AAXWdKCZBZA_Xb7q1Hd58OkWhzwK34,16151
@@ -16,30 +16,30 @@ aepp/destination.py,sha256=_-Hrzb_LUNaRrqR4Y3EZZuTisIs0nF3KH_GZpFjryrs,24348
 aepp/destinationinstanceservice.py,sha256=zEZbKi519cOOdxWMZ3mv9ccP6yjNAlNwqrQMlzW_gO4,5378
 aepp/edge.py,sha256=F2QZApmITObXB8hRWXftHBZ82KNqVZ7iSNuovT8qnk4,16041
 aepp/exportDatasetToDataLandingZone.py,sha256=C6jg3XttFC-0mswa3ypZb6qx3MCQ8_A_3kyKspurXJA,18629
-aepp/fieldgroupmanager.py,sha256=4A7u3tx63HzcDiMqyZs5TRy-LN0Xsf7VGLdt1_exw2Q,103591
+aepp/fieldgroupmanager.py,sha256=KuU5WDDh48C_3AYwjzRBPXHoLKxHZSpzel2_W18qsYo,103578
 aepp/flowservice.py,sha256=WizgwY6TYn1kiLxQt6Y3d7XgoLAb9imXrFXtt94hhog,107612
 aepp/hygiene.py,sha256=VEspnyu9eUlcK3wLeJYclaFaOWl5G5I5MRwmVA-RnUg,15385
-aepp/identity.py,sha256=E9MCIgntScMssduqKZqehT6FqSfTjWHcq7E7wESj3Zc,20833
+aepp/identity.py,sha256=XH_prFTFWVtid-BbjD7B_4Z7vpebmIo4z5ecvAZf1II,20881
 aepp/ingestion.py,sha256=OamE7NDei2Ev5vXIDkMlzvdyBaN41nkIGmpAnUlQoZI,22372
 aepp/observability.py,sha256=bKe74nlXYB5E5syh7Lj4VqIgwUI3OjMxK383P05EdLU,9951
 aepp/policy.py,sha256=JbpvfCKJl2kE2McK2mn_ZI5HKd_6pTnrfMoUdyJesWQ,24924
 aepp/privacyservice.py,sha256=V6BkJeZG1LDBCyEQm9Gx0i68iRHG6uxSJiVnXzkHapI,8790
 aepp/queryservice.py,sha256=wB9GiaMwJszNjqkYjkfEDUhdT2IoI22jA3Kt_6ki4Hk,62373
 aepp/sandboxes.py,sha256=UwlSFkO2OOmH--6ISz8rxwDu2LcLH1MPqoH7yOEAZHc,29363
-aepp/schema.py,sha256=aLYDM5lCANNddk-NZPNxCxazg9HpELalKlFxQz55dRs,123111
-aepp/schemamanager.py,sha256=G3JhVikWkaT14F8vORDfGJGivarvU2AgKO1RB-1pzdM,54117
+aepp/schema.py,sha256=85TBLuSWZjObTsnY_xBqlQV5eQOEABiy6_XKpAOe8BA,122999
+aepp/schemamanager.py,sha256=8WhAh57Iqg2TNi74OVK7X706duUkdMipB4-EvEKVXHg,54407
 aepp/segmentation.py,sha256=oSgR2yx4nawYN5XAeHV_wefvmXEf0nb-bCguaDmp8F8,43555
 aepp/sensei.py,sha256=oYNy5BSWAEqsDkEexcQso6NfA6ntGGMnCOyHri0pJs8,7761
 aepp/som.py,sha256=XNm_Lu2wt2kpSSpldLptuER2eludFXeO9fI6i3iNCzo,34175
-aepp/synchronizer.py,sha256=3scwuimQJIBVdEqJ9fVsT1UgmFc9EkH3mpYxUwSoAOE,79363
+aepp/synchronizer.py,sha256=18SC4zCDA43ewIlwOXyp9YNyF-6n6qSv8Pxl-ccvltk,82928
 aepp/tags.py,sha256=t2qBallTcWR4IOXcDBmrPpqjbSay1z3E2bcRijzVm1s,17641
 aepp/utils.py,sha256=tG-YVXylm38-bynqfp5N_Mzyo7mhlZj-dLo7wLoO4tM,1200
 aepp/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aepp/cli/__main__.py,sha256=yQGX-aCz_fDCvzjK0g9XVPjHrfJ4ZeWeVXj9aFq928A,85462
+aepp/cli/__main__.py,sha256=ui3q6CdDBd5R43xg9olu-jRioSSh76vHde-S_iaUsEY,87351
 aepp/cli/upsfieldsanalyzer.py,sha256=GAVBfXN6U8_BfU7doZwcuox71NMwdqQsEpuNgM2Osjc,13124
-aepp-0.5.2.post2.dist-info/licenses/LICENSE,sha256=HjYTlfne3BbS5gNHzNqJ5COCiTQLUdf87QkzRyFbE4Y,10337
-aepp-0.5.2.post2.dist-info/METADATA,sha256=IbeoTe1HUPrINR-0ZAYJJan3Q8wAGH5lxGg1KuR-1sY,5344
-aepp-0.5.2.post2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aepp-0.5.2.post2.dist-info/entry_points.txt,sha256=e7HAumUTymoUiCuVRzFlcchennUBLcjxvuiimySF98Y,48
-aepp-0.5.2.post2.dist-info/top_level.txt,sha256=dtZJI8SzhWVgZRl68PHKZX_fD6amvDiFR-lqD9FSJvE,5
-aepp-0.5.2.post2.dist-info/RECORD,,
+aepp-0.5.2.post3.dist-info/licenses/LICENSE,sha256=HjYTlfne3BbS5gNHzNqJ5COCiTQLUdf87QkzRyFbE4Y,10337
+aepp-0.5.2.post3.dist-info/METADATA,sha256=-2p5jm8PyG-0I-faMx71Tyn0AS-t8iN_DTOwLAXGAdo,5344
+aepp-0.5.2.post3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aepp-0.5.2.post3.dist-info/entry_points.txt,sha256=e7HAumUTymoUiCuVRzFlcchennUBLcjxvuiimySF98Y,48
+aepp-0.5.2.post3.dist-info/top_level.txt,sha256=dtZJI8SzhWVgZRl68PHKZX_fD6amvDiFR-lqD9FSJvE,5
+aepp-0.5.2.post3.dist-info/RECORD,,