aepp 0.5.0.post8__tar.gz → 0.5.1.post1__tar.gz

{aepp-0.5.0.post8/aepp.egg-info → aepp-0.5.1.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aepp
-Version: 0.5.0.post8
+Version: 0.5.1.post1
 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.0.post8 → aepp-0.5.1.post1}/aepp/__init__.py

@@ -165,7 +165,7 @@ def __titleSafe__(text: str) -> str:
     return text
 
 
-def extractSandboxArtefacts(
+def extractSandboxArtifacts(
     sandbox: 'ConnectObject' = None, 
     localFolder: Union[str, Path] = None,
     region: str = "nld2",
@@ -310,20 +310,20 @@ def extractSandboxArtefacts(
         with open(f"{audiencePath / safe_name}.json",'w') as f:
             json.dump(el,f,indent=2)
 
-def extractSandboxArtefact(
+def extractSandboxArtifact(
     sandbox: 'ConnectObject' = None,
     localFolder: Union[str, Path] = None,
-    artefact: str = None,
-    artefactType: str = None,
+    artifact: str = None,
+    artifactType: str = None,
     region: str = "nld2",
 ):
     """
-    Export a single artefact and its dependencies from the sandbox.
+    Export a single artifact and its dependencies from the sandbox.
     Arguments:
         sandbox: REQUIRED: the instance of a ConnectObject that contains the sandbox information and connection.
         localFolder: OPTIONAL: the local folder where to extract the sandbox. If not provided, it will use the current working directory and name the folder the name of the sandbox.
-        artefact: REQUIRED: the id or the name of the artefact to export.
-        artefactType: REQUIRED: the type of artefact to export. Possible values are: 'class','schema','fieldgroup','datatype','descriptor','dataset','identity','mergepolicy',audience'
+        artifact: REQUIRED: the id or the name of the artifact to export.
+        artifactType: REQUIRED: the type of artifact to export. Possible values are: 'class','schema','fieldgroup','datatype','descriptor','dataset','identity','mergepolicy',audience'
         region: OPTIONAL: the region of the sandbox (default: nld2). This is used to fetch the correct API endpoints for the identities. 
             Possible values: "va7","aus5", "can2", "ind2"
     """
@@ -348,24 +348,24 @@ def extractSandboxArtefact(
     from aepp import schema, catalog, identity
     sch = schema.Schema(config=sandbox)
     cat = catalog.Catalog(config=sandbox)
-    if artefactType == 'class':
-        __extractClass__(artefact,completePath,sandbox)
-    elif artefactType == 'schema':
-        __extractSchema__(artefact,completePath,sandbox,region)
-    elif artefactType == 'fieldgroup':
-        __extractFieldGroup__(artefact,completePath,sandbox)
-    elif artefactType == 'datatype':
-        __extractDataType__(artefact,completePath,sandbox)
-    elif artefactType == 'dataset':
-        __extractDataset__(artefact,completePath,sandbox,region)
-    elif artefactType == 'identity':
-        __extractIdentity__(artefact,region,completePath,sandbox)
-    elif artefactType == 'mergepolicy':
-        __extractMergePolicy__(artefact,completePath,sandbox)
-    elif artefactType == 'audience':
-        __extractAudience__(artefact,completePath,sandbox)
+    if artifactType == 'class':
+        __extractClass__(artifact,completePath,sandbox)
+    elif artifactType == 'schema':
+        __extractSchema__(artifact,completePath,sandbox,region)
+    elif artifactType == 'fieldgroup':
+        __extractFieldGroup__(artifact,completePath,sandbox)
+    elif artifactType == 'datatype':
+        __extractDataType__(artifact,completePath,sandbox)
+    elif artifactType == 'dataset':
+        __extractDataset__(artifact,completePath,sandbox,region)
+    elif artifactType == 'identity':
+        __extractIdentity__(artifact,region,completePath,sandbox)
+    elif artifactType == 'mergepolicy':
+        __extractMergePolicy__(artifact,completePath,sandbox)
+    elif artifactType == 'audience':
+        __extractAudience__(artifact,completePath,sandbox)
     else:
-        raise ValueError("artefactType not recognized")
+        raise ValueError("artifactType not recognized")
     
 def __extractClass__(classEl: str,folder: Union[str, Path] = None,sandbox: 'ConnectObject' = None):
     classPath = Path(folder) / 'class'

aepp-0.5.1.post1/aepp/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.1-1"

{aepp-0.5.0.post8 → aepp-0.5.1.post1}/aepp/cli/__main__.py

@@ -13,12 +13,16 @@ from io import FileIO
 import pandas as pd
 from datetime import datetime
 import urllib.parse
+from typing import Any, Concatenate, ParamSpec, ParamSpecKwargs
+from collections.abc import Callable
+
+P = ParamSpec("P")
 
 # --- 1. The Decorator (The Gatekeeper) ---
-def login_required(f):
+def login_required(f:Callable[Concatenate["ServiceShell", P], None]) -> Callable[Concatenate["ServiceShell", P], None]:
     """Decorator to block commands if not logged in."""
     @wraps(f)
-    def wrapper(self, *args, **kwargs):
+    def wrapper(self:"ServiceShell", *args:P.args, **kwargs:P.kwargs) -> None:
         if not hasattr(self, 'config') or self.config is None:
             print("(!) Access Denied: You must setup config first.")
             return
@@ -29,26 +33,30 @@ console = Console()
 
 # --- 2. The Interactive Shell ---
 class ServiceShell(cmd.Cmd):
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs:ParamSpecKwargs) -> None:
         super().__init__()
         self.config = None
         self.connectInstance = True
-        config_path = Path(kwargs.get("config_file"))
-        if not config_path.is_absolute():
-            config_path = Path.cwd() / config_path
-        if config_path.exists() and kwargs.get("config_file") is not None:
+        if kwargs.get("config_file") is not None:
+            config_path = Path(kwargs.get("config_file"))
+            if not config_path.is_absolute():
+                config_path = Path.cwd() / config_path
+        if kwargs.get("config_file") is not None:
             dict_config = json.load(FileIO(config_path))
-            self.sandbox = kwargs.get("sandbox",dict_config.get("sandbox-name","prod"))
-            self.secret = dict_config.get("secret",kwargs.get("secret"))
-            self.org_id = dict_config.get("org_id",kwargs.get("org_id"))
-            self.client_id = dict_config.get("client_id",kwargs.get("client_id"))
-            self.scopes = dict_config.get("scopes",kwargs.get("scopes"))
+            if kwargs.get("sandbox") is None:
+                self.sandbox = str(dict_config.get("sandbox-name","prod"))
+            else:
+                self.sandbox = str(kwargs.get("sandbox","prod"))
+            self.secret = str(dict_config.get("secret",kwargs.get("secret")))
+            self.org_id = str(dict_config.get("org_id",kwargs.get("org_id")))
+            self.client_id = str(dict_config.get("client_id",kwargs.get("client_id")))
+            self.scopes = str(dict_config.get("scopes",kwargs.get("scopes")))
         else:
-            self.sandbox = kwargs.get("sandbox","prod")
-            self.secret = kwargs.get("secret")
-            self.org_id = kwargs.get("org_id")
-            self.client_id = kwargs.get("client_id")
-            self.scopes = kwargs.get("scopes")
+            self.sandbox = str(kwargs.get("sandbox","prod"))
+            self.secret = str(kwargs.get("secret"))
+            self.org_id = str(kwargs.get("org_id"))
+            self.client_id = str(kwargs.get("client_id"))
+            self.scopes = str(kwargs.get("scopes"))
         self.connectInstance = True
         if self.sandbox is not None and self.secret is not None and self.org_id is not None and self.client_id is not None and self.scopes is not None:
             print("Configuring connection...")
@@ -63,8 +71,20 @@ class ServiceShell(cmd.Cmd):
             self.prompt = f"{self.config.sandbox}> "
             console.print(Panel(f"Connected to [bold green]{self.sandbox}[/bold green]", style="blue"))
         
+    def do_createConfigFile(self, arg:Any) -> None:
+        """Create a configuration file for future use"""
+        parser = argparse.ArgumentParser(prog='createConfigFile', add_help=True)
+        parser.add_argument("-f", "--file_name", help="file name for your config file", default="aepp_config.json")
+        args = parser.parse_args(shlex.split(arg))
+        filename = args.file_name
+        aepp.createConfigFile(destination=filename)
+        filename_json = filename + ".json" if not filename.endswith(".json") else filename
+        console.print(f"Configuration file created at {Path.cwd() / Path(filename_json)}", style="green")
+        return
+
+
     # # --- Commands ---
-    def do_config(self, arg):
+    def do_config(self, arg:Any) -> None:
         """connect to an AEP instance"""
         parser = argparse.ArgumentParser(prog='config', add_help=True)
         parser.add_argument("-sx", "--sandbox", help="Auto-login sandbox")
@@ -77,18 +97,18 @@ class ServiceShell(cmd.Cmd):
         if args.config_file:
             mypath = Path.cwd()
             dict_config = json.load(FileIO(mypath / Path(args.config_file)))
-            self.sandbox = args.sandbox if args.sandbox else dict_config.get("sandbox-name",args.sandbox)
-            self.secret = dict_config.get("secret",args.secret)
-            self.org_id = dict_config.get("org_id",args.org_id)
-            self.client_id = dict_config.get("client_id",args.client_id)
-            self.scopes = dict_config.get("scopes",args.scopes)
+            self.sandbox = str(args.sandbox) if args.sandbox else str(dict_config.get("sandbox-name",args.sandbox))
+            self.secret = str(dict_config.get("secret",args.secret))
+            self.org_id = str(dict_config.get("org_id",args.org_id))
+            self.client_id = str(dict_config.get("client_id",args.client_id))
+            self.scopes = str(dict_config.get("scopes",args.scopes))
             self.connectInstance = True
         else:
-            if args.sandbox: self.sandbox = args.sandbox
-            if args.secret: self.secret = args.secret
-            if args.org_id: self.org_id = args.org_id
-            if args.scopes: self.scopes = args.scopes
-            if args.client_id: self.client_id = args.client_id
+            if args.sandbox: self.sandbox = str(args.sandbox)
+            if args.secret: self.secret = str(args.secret)
+            if args.org_id: self.org_id = str(args.org_id)
+            if args.scopes: self.scopes = str(args.scopes)
+            if args.client_id: self.client_id = str(args.client_id)
         console.print("Configuring connection...", style="blue")
         self.config = aepp.configure(
             connectInstance=self.connectInstance,
@@ -102,15 +122,15 @@ class ServiceShell(cmd.Cmd):
         self.prompt = f"{self.config.sandbox}> "
         return 
 
-    def do_change_sandbox(self, args):
+    def do_change_sandbox(self, args:Any) -> None:
         """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 = args.sandbox if args.sandbox else console.print(Panel("(!) Please provide a sandbox name using -sx or --sandbox", style="red"))
+        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(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:
@@ -118,7 +138,7 @@ class ServiceShell(cmd.Cmd):
     
     
     @login_required
-    def do_get_schemas(self, args):
+    def do_get_schemas(self, args:Any) -> None:
         """List all schemas in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_schemas', add_help=True)
         parser.add_argument("-sv", "--save",help="Save schemas to CSV file")
@@ -150,7 +170,7 @@ class ServiceShell(cmd.Cmd):
             return
 
     @login_required
-    def do_get_ups_schemas(self, args):
+    def do_get_ups_schemas(self, args) -> None:
         """List all schemas enabled for Profile in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_schemas_enabled', add_help=True)
         parser.add_argument("-sv", "--save",help="Save enabled schemas to CSV file")
@@ -188,8 +208,9 @@ class ServiceShell(cmd.Cmd):
             console.print(f"(!) Error: {str(e)}", style="red")
         except SystemExit:
             return
+    
     @login_required
-    def do_get_ups_fieldgroups(self, args):
+    def do_get_ups_fieldgroups(self, args:Any) -> None:
         """List all field groups enabled for Profile in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_fieldgroups_enabled', add_help=True)
         parser.add_argument("-sv", "--save",help="Save enabled field groups to CSV file")
@@ -229,7 +250,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_profile_schemas(self,args):
+    def do_get_profile_schemas(self,args:Any) -> None:
         """Get the current profile schema"""
         parser = argparse.ArgumentParser(prog='get_schemas_enabled', add_help=True)
         try:
@@ -256,7 +277,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_union_profile_json(self,args):
+    def do_get_union_profile_json(self,args:Any) -> None:
         """Get the current Profile union schema"""
         parser = argparse.ArgumentParser(prog='get_union_profile', add_help=True)
         try:
@@ -272,7 +293,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_union_profile_csv(self,args):
+    def do_get_union_profile_csv(self,args:Any) -> None:
         """Get the current Profile union schema"""
         parser = argparse.ArgumentParser(prog='get_union_profile', add_help=True)
         parser.add_argument("-f","--full",default=False,help="Get full schema information with all details",type=bool)
@@ -288,7 +309,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_union_event_json(self,args):
+    def do_get_union_event_json(self,args:Any) -> None:
         """Get the current Experience Event union schema"""
         parser = argparse.ArgumentParser(prog='get_union_event', add_help=True)
         try:
@@ -304,7 +325,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_union_event_csv(self,args):
+    def do_get_union_event_csv(self,args:Any) -> None:
         """Get the current Experience Event union schema"""
         parser = argparse.ArgumentParser(prog='get_union_event', add_help=True)
         parser.add_argument("-f","--full",default=False,help="Get full schema information with all details",type=bool)
@@ -320,7 +341,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_event_schemas(self,args):
+    def do_get_event_schemas(self,args:Any) -> None:
         """Get the current Experience Event schemas"""
         parser = argparse.ArgumentParser(prog='get_event_schemas', add_help=True)
         parser.add_argument("-sv", "--save",help="Save event schemas to CSV file")
@@ -352,7 +373,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_union_event_json(self,args):
+    def do_get_union_event_json(self,args:Any) -> None:
         """Get the current Experience Event union schema"""
         parser = argparse.ArgumentParser(prog='get_union_event', add_help=True)
         try:
@@ -369,7 +390,7 @@ class ServiceShell(cmd.Cmd):
          
 
     @login_required
-    def do_get_schema_xdm(self, arg):
+    def do_get_schema_xdm(self, arg:Any) -> None:
         """Get schema JSON by name or ID"""
         parser = argparse.ArgumentParser(prog='get_schema_xdm', add_help=True)
         parser.add_argument("schema", help="Schema title, $id or alt:Id to retrieve")
@@ -402,7 +423,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_schema_csv(self, arg):
+    def do_get_schema_csv(self, arg:Any) -> None:
         """Get schema CSV by name or ID"""
         parser = argparse.ArgumentParser(prog='get_schema_csv', add_help=True)
         parser.add_argument("schema", help="Schema $id or alt:Id to retrieve")
@@ -432,7 +453,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_schema_json(self, args):
+    def do_get_schema_json(self, args:Any) -> None:
         """Get schema JSON by name or ID"""
         parser = argparse.ArgumentParser(prog='get_schema_json', add_help=True)
         parser.add_argument("schema", help="Schema $id or alt:Id to retrieve")
@@ -461,7 +482,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_fieldgroups(self, args):
+    def do_get_fieldgroups(self, args:Any) -> None:
         """List all field groups in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_fieldgroups', add_help=True)
         parser.add_argument("-sv", "--save",help="Save field groups to CSV file")
@@ -491,7 +512,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_fieldgroup_json(self, args):
+    def do_get_fieldgroup_json(self, args:Any) -> None:
         """Get field group JSON by name or ID"""
         parser = argparse.ArgumentParser(prog='get_fieldgroup_json', add_help=True)
         parser.add_argument("fieldgroup", help="Field Group name, $id or alt:Id to retrieve")
@@ -520,7 +541,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_fieldgroup_csv(self, args):
+    def do_get_fieldgroup_csv(self, args:Any) -> None:
         """Get field group CSV by name or ID"""
         parser = argparse.ArgumentParser(prog='get_fieldgroup_csv', add_help=True)
         parser.add_argument("fieldgroup", help="Field Group name, $id or alt:Id to retrieve")
@@ -548,7 +569,8 @@ class ServiceShell(cmd.Cmd):
         except SystemExit:
             return
         
-    def do_get_datatypes(self, args):
+    @login_required
+    def do_get_datatypes(self, args:Any) -> None:
         """List all data types in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_datatypes', add_help=True)
         try:
@@ -573,7 +595,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_datatype_csv(self, args):
+    def do_get_datatype_csv(self, args:Any) -> None:
         """Get data type CSV by name or ID"""
         parser = argparse.ArgumentParser(prog='get_datatype_csv', add_help=True)
         parser.add_argument("datatype", help="Data Type name, $id or alt:Id to retrieve")
@@ -602,7 +624,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_datatype_json(self, args):
+    def do_get_datatype_json(self, args:Any) -> None:
         """Get data type JSON by name or ID"""
         parser = argparse.ArgumentParser(prog='get_datatype_json', add_help=True)
         parser.add_argument("datatype", help="Data Type name, $id or alt:Id to retrieve")
@@ -632,7 +654,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_enable_schema_for_ups(self, args):
+    def do_enable_schema_for_ups(self, args:Any) -> None:
         """Enable a schema for Profile"""
         parser = argparse.ArgumentParser(prog='enable_schema_for_ups', add_help=True)
         parser.add_argument("schema_id", help="Schema ID to enable for Profile")
@@ -647,7 +669,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_upload_fieldgroup_definition_csv(self,args):
+    def do_upload_fieldgroup_definition_csv(self,args:Any) -> None:
         """Upload a field group definition from a CSV file"""
         parser = argparse.ArgumentParser(prog='upload_fieldgroup_definition_csv', add_help=True)
         parser.add_argument("csv_path", help="Path to the field group CSV file")
@@ -671,7 +693,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_upload_fieldgroup_definition_xdm(self,args):
+    def do_upload_fieldgroup_definition_xdm(self,args:Any) -> None:
         """Upload a field group definition from a JSON XDM file"""
         parser = argparse.ArgumentParser(prog='upload_fieldgroup_definition_xdm', add_help=True)
         parser.add_argument("xdm_path", help="Path to the field group JSON XDM file")
@@ -696,7 +718,7 @@ class ServiceShell(cmd.Cmd):
             return
         
     @login_required
-    def do_get_datasets(self, args):
+    def do_get_datasets(self, args:Any) -> None:
         """List all datasets in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_datasets', add_help=True)
         try:
@@ -727,7 +749,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_datasets_infos(self, args):
+    def do_get_datasets_infos(self, args:Any) -> None:
         """List all datasets in the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_datasets_infos', add_help=True)
         try:
@@ -759,7 +781,7 @@ class ServiceShell(cmd.Cmd):
             return
 
     @login_required
-    def do_createDataset(self, args):
+    def do_createDataset(self, args:Any) -> None:
         """Create a new dataset in the current sandbox"""
         parser = argparse.ArgumentParser(prog='createDataset', add_help=True)
         parser.add_argument("dataset_name", help="Name of the dataset to create")
@@ -775,7 +797,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_enable_dataset_for_ups(self, args):
+    def do_enable_dataset_for_ups(self, args:Any) -> None:
         """Enable a dataset for Profile"""
         parser = argparse.ArgumentParser(prog='enable_dataset_for_ups', add_help=True)
         parser.add_argument("dataset", help="Dataset ID or Dataset Name to enable for Profile")
@@ -793,8 +815,8 @@ class ServiceShell(cmd.Cmd):
         except SystemExit:
             return
 
-    @login_required
-    def do_get_identities(self, args):
+    @login_required 
+    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')
@@ -825,7 +847,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_flows(self, args):
+    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."""
         parser = argparse.ArgumentParser(prog='get_flows', add_help=True)
         parser.add_argument("-i","--internal_flows",help="Get internal flows", default=False,type=bool)
@@ -964,19 +986,19 @@ class ServiceShell(cmd.Cmd):
                     successful_runs = fl.get("Successful Runs", 0)
                     failed_runs = fl.get("Failed Runs", 0)
                     partial_success = fl.get('Partial Success Runs',0)
-                    if partial_success>0:
-                        partialColorStart = "[orange1]"
-                        partialColorEnd = "[/orange1]"
-                    else:
-                        partialColorStart = colorStart
-                        partialColorEnd = colorEnd
+                    if partial_success>0 and failed_runs==0:
+                        colorStart = "[orange1]"
+                        colorEnd = "[/orange1]"
+                    row_data[0] = f"{colorStart}{fl.get('id','N/A')}{colorEnd}"
+                    row_data[1] = f"{colorStart}{fl.get('name','N/A')}{colorEnd}"
+                    row_data[2] = f"{colorStart}{fl.get('type','N/A')}{colorEnd}"
                     success_rate = (successful_runs / total_runs * 100) if total_runs > 0 else 0
                     failure_rate = (failed_runs / total_runs * 100) if total_runs > 0 else 0
                     row_data.extend([
                         f"{colorStart}{str(total_runs)}{colorEnd}",
                         f"{colorStart}{str(successful_runs)}{colorEnd}",
                         f"{colorStart}{str(failed_runs)}{colorEnd}",
-                        f"{partialColorStart}{str(partial_success)}{partialColorEnd}",
+                        f"{colorStart}{str(partial_success)}{colorEnd}",
                         f"{colorStart}{success_rate:.0f}%{colorEnd}",
                         f"{colorStart}{failure_rate:.0f}%{colorEnd}"
                     ])
@@ -988,7 +1010,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_flow_errors(self,args):
+    def do_get_flow_errors(self,args:Any) -> None:
         """Get errors for a specific flow, saving it in a JSON file for specific timeframe, default last 24 hours."""
         parser = argparse.ArgumentParser(prog='get_flow_errors', add_help=True)
         parser.add_argument("flow_id", help="Flow ID to get errors for")
@@ -1012,7 +1034,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_create_dataset_http_source(self,args):
+    def do_create_dataset_http_source(self,args:Any) -> None:
         """Create an HTTP Source connection for a specific dataset, XDM compatible data only."""
         parser = argparse.ArgumentParser(prog='do_create_dataset_http_source', add_help=True)
         parser.add_argument("dataset", help="Name or ID of the Dataset Source connection to create")
@@ -1038,7 +1060,7 @@ class ServiceShell(cmd.Cmd):
             return
     
     @login_required
-    def do_get_DLZ_credential(self,args):
+    def do_get_DLZ_credential(self,args:Any) -> None:
         """Get Data Lake Zone credential for the current sandbox"""
         parser = argparse.ArgumentParser(prog='get_DLZ_credential', add_help=True)
         parser.add_argument("type",nargs='?',help="Type of credential to retrieve: 'user_drop_zone' or 'dlz_destination'",default="user_drop_zone")
@@ -1054,7 +1076,7 @@ class ServiceShell(cmd.Cmd):
             return
 
     @login_required
-    def do_get_queries(self, args):
+    def do_get_queries(self, args:Any)-> None:
         """List top 1000 queries in the current sandbox for the last 24 hours by default, optionally filtered by dataset ID"""
         parser = argparse.ArgumentParser(prog='get_queries', add_help=True)
         parser.add_argument("-ds","--dataset", help="Dataset ID to filter queries", default=None)
@@ -1116,7 +1138,7 @@ class ServiceShell(cmd.Cmd):
             return
         
     @login_required
-    def do_query(self,args):
+    def do_query(self,args:Any) -> None:
         """Execute a SQL query against the current sandbox"""
         parser = argparse.ArgumentParser(prog='query', add_help=True)
         parser.add_argument("sql_query", help="SQL query to execute",type=str)
@@ -1136,15 +1158,15 @@ class ServiceShell(cmd.Cmd):
 
 
     @login_required
-    def do_extractArtefacts(self,args):
-        """extractArtefacts localfolder"""
-        console.print("Extracting artefacts...", style="blue")
-        parser = argparse.ArgumentParser(prog='extractArtefacts', description='Extract artefacts from AEP')
-        parser.add_argument('-lf','--localfolder', help='Local folder to extract artefacts to', default='./extractions')
-        parser.add_argument('-rg','--region', help='Region to extract artefacts from: "ndl2" (default), "va7", "aus5", "can2", "ind2"',default='ndl2')
+    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.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:
             args = parser.parse_args(shlex.split(args))
-            aepp.extractSandboxArtefacts(
+            aepp.extractSandboxArtifacts(
                 sandbox=self.config,
                 localFolder=args.localfolder,
                 region=args.region
@@ -1154,20 +1176,20 @@ class ServiceShell(cmd.Cmd):
             return
 
     @login_required
-    def do_extractArtefact(self,args):
-        """extractArtefacts localfolder"""
-        console.print("Extracting artefact...", style="blue")
-        parser = argparse.ArgumentParser(prog='extractArtefact', description='Extract artefacts from AEP')
-        parser.add_argument('artefact', help='artefact to extract (name or id): "schema","fieldgroup","datatype","descriptor","dataset","identity","mergepolicy","audience"')
-        parser.add_argument('-at','--artefactType', help='artefact type ')
-        parser.add_argument('-lf','--localfolder', help='Local folder to extract artefacts to',default='extractions')
-        parser.add_argument('-rg','--region', help='Region to extract artefacts from: "ndl2" (default), "va7", "aus5", "can2", "ind2"',default='ndl2')
+    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.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:
             args = parser.parse_args(shlex.split(args))
-            aepp.extractSandboxArtefact(
-                artefact=args.artefact,
-                artefactType=args.artefactType,
+            aepp.extractSandboxArtifact(
+                artifact=args.artifact,
+                artifactType=args.artifactType,
                 sandbox=self.config,
                 localFolder=args.localfolder
             )
@@ -1176,16 +1198,16 @@ class ServiceShell(cmd.Cmd):
             return
 
     @login_required
-    def do_sync(self,args):
-        """extractArtefacts localfolder"""
-        console.print("Syncing artefact...", style="blue")
-        parser = argparse.ArgumentParser(prog='extractArtefact', description='Extract artefacts from AEP')
-        parser.add_argument('artefact', help='artefact to extract (name or id): "schema","fieldgroup","datatype","descriptor","dataset","identity","mergepolicy","audience"')
-        parser.add_argument('-at','--artefactType', help='artefact type ')
+    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.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('-t','--targets', help='target sandboxes')
-        parser.add_argument('-lf','--localfolder', help='Local folder to extract artefacts to',default='extractions')
+        parser.add_argument('-lf','--localfolder', help='Local folder to extract artifacts to',default='extractions')
         parser.add_argument('-b','--baseSandbox', help='Base sandbox for synchronization')
-        parser.add_argument('-rg','--region', help='Region to extract artefacts from: "ndl2" (default), "va7", "aus5", "can2", "ind2"',default='ndl2')
+        parser.add_argument('-rg','--region', help='Region to extract artifacts from: "ndl2" (default), "va7", "aus5", "can2", "ind2"',default='ndl2')
         parser.add_argument('-v','--verbose', help='Enable verbose output',default=True)
         try:
             args = parser.parse_args(shlex.split(args))
@@ -1210,21 +1232,20 @@ class ServiceShell(cmd.Cmd):
             )
             console.print("Starting Sync...", style="blue")
             synchronizor.syncComponent(
-                component=args.artefact,
-                componentType=args.artefactType,
+                component=args.artifact,
+                componentType=args.artifactType,
                 verbose=args.verbose
             )
             console.print("Sync completed!", style="green")
         except SystemExit:
             return
     
-    
-    def do_exit(self, args):
+    def do_exit(self, args:Any) -> None:
         """Exit the application"""
         console.print(Panel("Exiting...", style="blue"))
         return True  # Stops the loop
 
-    def do_EOF(self, args):
+    def do_EOF(self, args:Any) -> None:
         """Handle Ctrl+D"""
         console.print(Panel("Exiting...", style="blue"))
         return True

{aepp-0.5.0.post8 → aepp-0.5.1.post1}/aepp/deletion.py

@@ -20,11 +20,11 @@ from aepp import connector
 
 class Deletion:
     """
-    This class regroups differet methods and combine some to clean and delete artefact from Adobe Experience Platform.
+    This class regroups differet methods and combine some to clean and delete artifact from Adobe Experience Platform.
     Supported in this class:
-    - Deleting datasets (and associated artefacts)
-    - Deleteting dataflows (and associated artefacts)
-    - Deleting schemas (and associated artefacts)
+    - Deleting datasets (and associated artifacts)
+    - Deleteting dataflows (and associated artifacts)
+    - Deleting schemas (and associated artifacts)
     - Deleting audiences
     """
     loggingEnabled = False
@@ -83,14 +83,14 @@ class Deletion:
     def __repr__self(self):
         return f"Deletion(config={self.config})"
     
-    def deleteDataset(self,datasetId: str,associatedArtefacts:bool=False) -> dict:
+    def deleteDataset(self,datasetId: str,associatedArtifacts:bool=False) -> dict:
         """
-        Delete a dataset and all associated artefacts (dataflows, schemas, data connections).
+        Delete a dataset and all associated artifacts (dataflows, schemas, data connections).
         Arguments:
             datasetId : REQUIRED : The identifier of the dataset to delete.
-            associatedArtefacts : OPTIONAL : If set to True, all associated artefacts (dataflows, schemas) will also be deleted (default False).
-                Note : Deleting associated arterfacts option will be pass down to other methods called within this method. So Field Groups, Data Type could be impacted.
-                In case, it is not possible to delete artefacts, it will be silently ignored and returns in the output dictionary.
+            associatedArtifacts : OPTIONAL : If set to True, all associated artifacts (dataflows, schemas) will also be deleted (default False).
+                Note : Deleting associated artifacts option will be pass down to other methods called within this method. So Field Groups, Data Type could be impacted.
+                In case, it is not possible to delete artifacts, it will be silently ignored and returns in the output dictionary.
         """
         result = {}
         from aepp import catalog
@@ -100,7 +100,7 @@ class Deletion:
         schemaRef = datasetInfo.get('schemaRef',{}).get('id',None)
         res = cat.deleteDataSet(datasetId=datasetId)
         result['dataset'] = res
-        if associatedArtefacts:
+        if associatedArtifacts:
             # Deleting associated dataflows
             result['flows'] = {'connections':{}, 'flows': {}} 
             from aepp import flowservice
@@ -113,21 +113,21 @@ class Deletion:
             flows = flow.getFlows()
             list_flowIds = [f['id'] for f in flows if f.get('sourceConnectionIds',[""])[0] in list_source_dataflowsIds or f.get('targetConnectionIds',[""])[0] in list_target_dataflowsIds]
             for flowId in list_flowIds:
-                res_flow = self.deleteDataFlow(flowId=flowId, associatedArtefacts=associatedArtefacts)
+                res_flow = self.deleteDataFlow(flowId=flowId, associatedArtifacts=associatedArtifacts)
                 result['flows']['flows'][flowId] = res_flow
             # Deleting associated schema
             if schemaRef is not None:
-                result['schema'] = self.deleteSchema(schemaId=schemaRef, associatedArtefacts=associatedArtefacts)
+                result['schema'] = self.deleteSchema(schemaId=schemaRef, associatedArtifacts=associatedArtifacts)
         return result
 
-    def deleteSchema(self,schemaId: str,associatedArtefacts:bool=False) -> dict:
+    def deleteSchema(self,schemaId: str,associatedArtifacts:bool=False) -> dict:
         """
-        Delete a schema and possibly all associated artefacts.
+        Delete a schema and possibly all associated artifacts.
         Arguments:
             schemaId : REQUIRED : The identifier of the schema to delete.
-            associatedArtefacts : OPTIONAL : If set to True, all associated artefacts (fieldGroup, datatype) will also be deleted (default False).
-                Note : Deleting associated arterfacts option will be pass down to other methods called within this method. So Field Groups, Data Type could be impacted.
-                In case, it is not possible to delete artefacts, it will be silently ignored and returns in the output dictionary.
+            associatedArtifacts : OPTIONAL : If set to True, all associated artifacts (fieldGroup, datatype) will also be deleted (default False).
+                Note : Deleting associated artifacts option will be pass down to other methods called within this method. So Field Groups, Data Type could be impacted.
+                In case, it is not possible to delete artifacts, it will be silently ignored and returns in the output dictionary.
         """
         result = {'fieldGroup': {}, 'schema': {} , 'datatypes':{} }
         from aepp import schema, schemamanager
@@ -135,7 +135,7 @@ class Deletion:
         schemaInfo = schemamanager.SchemaManager(schemaId,config=self.config)
         res = sch.deleteSchema(schemaId=schemaId)
         result['schema'] = res
-        if associatedArtefacts:
+        if associatedArtifacts:
             for fieldgroupId, fieldgroupName in schemaInfo.fieldGroups.items():
                 myFG = schemaInfo.getFieldGroupManager(fieldgroupName)
                 datatypes = myFG.dataTypes
@@ -146,12 +146,12 @@ class Deletion:
                 result['fieldGroupName'][fieldgroupId] = res_fg
         return result
     
-    def deleteDataFlow(self,flowId: str,associatedArtefacts:bool=False) -> dict:
+    def deleteDataFlow(self,flowId: str,associatedArtifacts:bool=False) -> dict:
         """
-        Delete a dataflow and possibly all associated artefacts.
+        Delete a dataflow and possibly all associated artifacts.
         Arguments:
             flowId : REQUIRED : The identifier of the dataflow to delete.
-            associatedArtefacts : OPTIONAL : If set to True, all associated artefacts (source and target) will also be deleted (default False).
+            associatedArtifacts : OPTIONAL : If set to True, all associated artifacts (source and target) will also be deleted (default False).
                 Note : The base connection will be identified and returned but not deleted. It can contains other dataflows still actives."""
         result = {'flow': {}, 'targetConnection': {},'sourceConnection':{}, 'baseConnection': {} }
         from aepp import flowservice
@@ -163,7 +163,7 @@ class Deletion:
         result['baseConnection'] = baseConn
         res = flow.deleteFlow(flowId=flowId)
         result['response_flow'] = res
-        if associatedArtefacts:
+        if associatedArtifacts:
             for sourceConnectionId in sourceConnectionIds:
                 res_sc = flow.deleteSourceConnection(connectionId=sourceConnectionId)
                 result["response_sourceConn"] = res_sc

{aepp-0.5.0.post8 → aepp-0.5.1.post1}/aepp/synchronizer.py

@@ -719,7 +719,7 @@ class Synchronizer:
             match descType:
                 case "xdm:descriptorIdentity":
                     target_identitiesDecs = [desc for desc in target_descriptors if desc['@type'] == 'xdm:descriptorIdentity']
-                    baseIdentityNS = baseDescriptor['xdm:namespace']
+                    baseIdentityNS = baseDescriptor['xdm:namespace'].lower()
                     if self.baseConfig is not None and self.localfolder is None:
                         identityConn = identity.Identity(config=self.baseConfig,region=self.region)
                         baseIdentities = identityConn.getIdentities()
@@ -728,8 +728,8 @@ class Synchronizer:
                         for file in self.identityFolder.glob('*.json'):
                             id_file = json.load(FileIO(file))
                             baseIdentities.append(id_file)
-                    if baseIdentityNS not in [el['xdm:namespace'] for el in target_identitiesDecs]: ## identity descriptor does not exists in target schema
-                        def_identity = [el for el in baseIdentities if el['code'] == baseIdentityNS][0]
+                    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)
                         new_desc = targetSchemaManager.createDescriptorOperation(descType=descType,
                                                                             completePath=baseDescriptor['xdm:sourceProperty'],
@@ -738,7 +738,7 @@ class Synchronizer:
                                                                             )
                         res = targetSchemaManager.createDescriptor(new_desc)
                     else:
-                        res = [el for el in target_identitiesDecs if el['xdm:namespace'] == baseIdentityNS][0]
+                        res = [el for el in target_identitiesDecs if el['xdm:namespace'].lower() == baseIdentityNS][0]
                     list_descriptors.append(res)
                 case "xdm:descriptorOneToOne": ## lookup definition
                     target_OneToOne = [desc for desc in target_descriptors if desc['@type'] == 'xdm:descriptorOneToOne']
@@ -866,15 +866,15 @@ class Synchronizer:
         """
         if not isinstance(identityDefiniton,dict):
             raise TypeError("the identityDefinition must be a dictionary")
-        code_base_identity = identityDefiniton['code']
+        code_base_identity = identityDefiniton['code'].lower()
         self.dict_baseComponents['identities'][code_base_identity] = identityDefiniton
         for target in self.dict_targetsConfig.keys():
             targetIdentity = identity.Identity(config=self.dict_targetsConfig[target],region=self.region)
             t_identities = targetIdentity.getIdentities()
-            if code_base_identity in [el['code'] for el in t_identities]:## identity already exists in target
+            if code_base_identity in [el['code'].lower() for el in t_identities]:## identity already exists in target
                 if verbose:
                     print(f"identity '{code_base_identity}' already exists in target {target}, saving it")
-                self.dict_targetComponents[target]['identities'][code_base_identity] = [el for el in t_identities if el['code'] == code_base_identity][0]
+                self.dict_targetComponents[target]['identities'][code_base_identity] = [el for el in t_identities if el['code'].lower() == code_base_identity][0]
             else:
                 if verbose:
                     print(f"identity '{code_base_identity}' does not exist in target {target}, creating it")
@@ -888,7 +888,7 @@ class Synchronizer:
     
     def __syncDataset__(self,baseDataset:dict,verbose:bool=False)-> dict:
         """
-        Synchronize the dataset to the target sandboxes. Mostly creating a new dataset and associated artefacts when not already created.
+        Synchronize the dataset to the target sandboxes. Mostly creating a new dataset and associated artifacts when not already created.
         Arguments:
             baseDataset : REQUIRED : dictionary with the dataset definition
         """
@@ -942,7 +942,7 @@ class Synchronizer:
 
     def __syncMergePolicy__(self,mergePolicy:dict,verbose:bool=False)->None:
         """
-        Synchronize the dataset to the target sandboxes. Mostly creating a new dataset and associated artefacts when not already created.
+        Synchronize the dataset to the target sandboxes. Mostly creating a new dataset and associated artifacts when not already created.
         Arguments:
             mergePolicy : REQUIRED : The merge policy dictionary to sync
         """

{aepp-0.5.0.post8 → aepp-0.5.1.post1/aepp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aepp
-Version: 0.5.0.post8
+Version: 0.5.1.post1
 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.0.post8/aepp/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.5.0-8"