amplify-excel-migrator 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

amplify_client.py

@@ -12,7 +12,7 @@ from botocore.exceptions import NoCredentialsError, ProfileNotFound, NoRegionErr
 from pycognito import Cognito, MFAChallengeException
 from pycognito.exceptions import ForceChangePasswordException
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 
@@ -21,11 +21,7 @@ class AmplifyClient:
     Client for Amplify GraphQL using ADMIN_USER_PASSWORD_AUTH flow
     """
 
-    def __init__(self,
-                 api_endpoint: str,
-                 user_pool_id: str,
-                 region: str,
-                 client_id: str):
+    def __init__(self, api_endpoint: str, user_pool_id: str, region: str, client_id: str):
         """
         Initialize the client
 
@@ -46,7 +42,7 @@ class AmplifyClient:
         self.boto_cognito_admin_client = None
         self.id_token = None
         self.mfa_tokens = None
-        self.admin_group_name = 'ADMINS'
+        self.admin_group_name = "ADMINS"
 
         self.records_cache = {}
 
@@ -55,17 +51,17 @@ class AmplifyClient:
             if is_aws_admin:
                 if aws_profile:
                     session = boto3.Session(profile_name=aws_profile)
-                    self.boto_cognito_admin_client = session.client('cognito-idp', region_name=self.region)
+                    self.boto_cognito_admin_client = session.client("cognito-idp", region_name=self.region)
                 else:
                     # Use default AWS credentials (from ~/.aws/credentials, env vars, or IAM role)
-                    self.boto_cognito_admin_client = boto3.client('cognito-idp', region_name=self.region)
+                    self.boto_cognito_admin_client = boto3.client("cognito-idp", region_name=self.region)
 
             else:
                 self.cognito_client = Cognito(
                     user_pool_id=self.user_pool_id,
                     client_id=self.client_id,
                     user_pool_region=self.region,
-                    username=username
+                    username=username,
                 )
 
         except NoCredentialsError:
@@ -95,8 +91,8 @@ class AmplifyClient:
             raise
 
         except ClientError as e:
-            error_code = e.response.get('Error', {}).get('Code', 'Unknown')
-            error_msg = e.response.get('Error', {}).get('Message', str(e))
+            error_code = e.response.get("Error", {}).get("Code", "Unknown")
+            error_msg = e.response.get("Error", {}).get("Message", str(e))
             logger.error(f"AWS Client Error [{error_code}]: {error_msg}")
             raise RuntimeError(f"Failed to initialize client: AWS error [{error_code}]: {error_msg}")
 
@@ -124,7 +120,7 @@ class AmplifyClient:
 
         except MFAChallengeException as e:
             logger.warning("MFA required")
-            if hasattr(e, 'get_tokens'):
+            if hasattr(e, "get_tokens"):
                 self.mfa_tokens = e.get_tokens()
 
                 mfa_code = input("Enter MFA code: ").strip()
@@ -170,17 +166,14 @@ class AmplifyClient:
             response = self.boto_cognito_admin_client.admin_initiate_auth(
                 UserPoolId=self.user_pool_id,
                 ClientId=self.client_id,
-                AuthFlow='ADMIN_USER_PASSWORD_AUTH',
-                AuthParameters={
-                    'USERNAME': username,
-                    'PASSWORD': password
-                }
+                AuthFlow="ADMIN_USER_PASSWORD_AUTH",
+                AuthParameters={"USERNAME": username, "PASSWORD": password},
             )
 
             self._check_for_mfa_challenges(response, username)
 
-            if 'AuthenticationResult' in response:
-                self.id_token = response['AuthenticationResult']['IdToken']
+            if "AuthenticationResult" in response:
+                self.id_token = response["AuthenticationResult"]["IdToken"]
             else:
                 logger.error("❌ Authentication failed: No AuthenticationResult in response")
                 return False
@@ -208,18 +201,12 @@ class AmplifyClient:
                 logger.error("No MFA session tokens available")
                 return False
 
-            challenge_name = self.mfa_tokens.get('ChallengeName', 'SMS_MFA')
+            challenge_name = self.mfa_tokens.get("ChallengeName", "SMS_MFA")
 
-            if 'SOFTWARE_TOKEN' in challenge_name:
-                self.cognito_client.respond_to_software_token_mfa_challenge(
-                    code=mfa_code,
-                    mfa_tokens=self.mfa_tokens
-                )
+            if "SOFTWARE_TOKEN" in challenge_name:
+                self.cognito_client.respond_to_software_token_mfa_challenge(code=mfa_code, mfa_tokens=self.mfa_tokens)
             else:
-                self.cognito_client.respond_to_sms_mfa_challenge(
-                    code=mfa_code,
-                    mfa_tokens=self.mfa_tokens
-                )
+                self.cognito_client.respond_to_sms_mfa_challenge(code=mfa_code, mfa_tokens=self.mfa_tokens)
 
             logger.info("✅ MFA challenge successful")
             return True
@@ -235,13 +222,10 @@ class AmplifyClient:
         try:
             if not self.boto_cognito_admin_client:
                 self.boto_cognito_admin_client(is_aws_admin=True)
-            response = self.boto_cognito_admin_client.list_user_pool_clients(
-                UserPoolId=self.user_pool_id,
-                MaxResults=1
-            )
+            response = self.boto_cognito_admin_client.list_user_pool_clients(UserPoolId=self.user_pool_id, MaxResults=1)
 
-            if response['UserPoolClients']:
-                client_id = response['UserPoolClients'][0]['ClientId']
+            if response["UserPoolClients"]:
+                client_id = response["UserPoolClients"][0]["ClientId"]
                 return client_id
 
             raise Exception("No User Pool clients found")
@@ -252,37 +236,34 @@ class AmplifyClient:
             raise Exception(f"Failed to get Client ID: {e}")
 
     def _check_for_mfa_challenges(self, response, username: str) -> bool:
-        if 'ChallengeName' in response:
-            challenge = response['ChallengeName']
+        if "ChallengeName" in response:
+            challenge = response["ChallengeName"]
 
-            if challenge == 'MFA_SETUP':
+            if challenge == "MFA_SETUP":
                 logger.error("MFA setup required")
                 return False
 
-            elif challenge == 'SMS_MFA' or challenge == 'SOFTWARE_TOKEN_MFA':
+            elif challenge == "SMS_MFA" or challenge == "SOFTWARE_TOKEN_MFA":
                 mfa_code = input("Enter MFA code: ")
                 _ = self.cognito_client.admin_respond_to_auth_challenge(
                     UserPoolId=self.user_pool_id,
                     ClientId=self.client_id,
                     ChallengeName=challenge,
-                    Session=response['Session'],
+                    Session=response["Session"],
                     ChallengeResponses={
-                        'USERNAME': username,
-                        'SMS_MFA_CODE' if challenge == 'SMS_MFA' else 'SOFTWARE_TOKEN_MFA_CODE': mfa_code
-                    }
+                        "USERNAME": username,
+                        "SMS_MFA_CODE" if challenge == "SMS_MFA" else "SOFTWARE_TOKEN_MFA_CODE": mfa_code,
+                    },
                 )
 
-            elif challenge == 'NEW_PASSWORD_REQUIRED':
+            elif challenge == "NEW_PASSWORD_REQUIRED":
                 new_password = getpass("Enter new password: ")
                 _ = self.cognito_client.admin_respond_to_auth_challenge(
                     UserPoolId=self.user_pool_id,
                     ClientId=self.client_id,
                     ChallengeName=challenge,
-                    Session=response['Session'],
-                    ChallengeResponses={
-                        'USERNAME': username,
-                        'NEW_PASSWORD': new_password
-                    }
+                    Session=response["Session"],
+                    ChallengeResponses={"USERNAME": username, "NEW_PASSWORD": new_password},
                 )
 
         return False
@@ -310,27 +291,17 @@ class AmplifyClient:
         if not self.id_token:
             raise Exception("Not authenticated. Call authenticate() first.")
 
-        headers = {
-            'Authorization': self.id_token,
-            'Content-Type': 'application/json'
-        }
+        headers = {"Authorization": self.id_token, "Content-Type": "application/json"}
 
-        payload = {
-            'query': query,
-            'variables': variables or {}
-        }
+        payload = {"query": query, "variables": variables or {}}
 
         try:
-            response = requests.post(
-                self.api_endpoint,
-                headers=headers,
-                json=payload
-            )
+            response = requests.post(self.api_endpoint, headers=headers, json=payload)
 
             if response.status_code == 200:
                 result = response.json()
 
-                if 'errors' in result:
+                if "errors" in result:
                     logger.error(f"GraphQL errors: {result['errors']}")
                     return None
 
@@ -340,9 +311,10 @@ class AmplifyClient:
                 return None
 
         except Exception as e:
-            if 'NameResolutionError' in str(e):
+            if "NameResolutionError" in str(e):
                 logger.error(
-                    f"Connection error: Unable to resolve hostname. Check your internet connection or the API endpoint URL.")
+                    f"Connection error: Unable to resolve hostname. Check your internet connection or the API endpoint URL."
+                )
                 sys.exit(1)
             else:
                 logger.error(f"Request error: {e}")
@@ -363,22 +335,16 @@ class AmplifyClient:
         if not self.id_token:
             raise Exception("Not authenticated. Call authenticate() first.")
 
-        headers = {
-            'Authorization': self.id_token,
-            'Content-Type': 'application/json'
-        }
+        headers = {"Authorization": self.id_token, "Content-Type": "application/json"}
 
-        payload = {
-            'query': query,
-            'variables': variables or {}
-        }
+        payload = {"query": query, "variables": variables or {}}
 
         try:
             async with session.post(self.api_endpoint, headers=headers, json=payload) as response:
                 if response.status == 200:
                     result = await response.json()
 
-                    if 'errors' in result:
+                    if "errors" in result:
                         logger.error(f"GraphQL errors: {result['errors']}")
                         return None
 
@@ -391,8 +357,9 @@ class AmplifyClient:
             logger.error(f"Request error: {e}")
             return None
 
-    async def create_record_async(self, session: aiohttp.ClientSession, data: Dict, model_name: str,
-                                  primary_field: str) -> Dict | None:
+    async def create_record_async(
+        self, session: aiohttp.ClientSession, data: Dict, model_name: str, primary_field: str
+    ) -> Dict | None:
         mutation = f"""
         mutation Create{model_name}($input: Create{model_name}Input!)  {{
             create{model_name}(input: $input) {{
@@ -402,19 +369,25 @@ class AmplifyClient:
         }}
         """
 
-        result = await self._request_async(session, mutation, {'input': data})
+        result = await self._request_async(session, mutation, {"input": data})
 
-        if result and 'data' in result:
-            created = result['data'].get(f'create{model_name}')
+        if result and "data" in result:
+            created = result["data"].get(f"create{model_name}")
             if created:
                 logger.info(f'Created {model_name} with {primary_field}="{data[primary_field]}" (ID: {created["id"]})')
             return created
 
         return None
 
-    async def check_record_exists_async(self, session: aiohttp.ClientSession, model_name: str,
-                                        primary_field: str, value: str, is_secondary_index: bool,
-                                        record: Dict) -> Dict | None:
+    async def check_record_exists_async(
+        self,
+        session: aiohttp.ClientSession,
+        model_name: str,
+        primary_field: str,
+        value: str,
+        is_secondary_index: bool,
+        record: Dict,
+    ) -> Dict | None:
         if is_secondary_index:
             query_name = f"list{model_name}By{primary_field.capitalize()}"
             query = f"""
@@ -427,11 +400,10 @@ class AmplifyClient:
             }}
             """
             result = await self._request_async(session, query, {primary_field: value})
-            if result and 'data' in result:
-                items = result['data'].get(query_name, {}).get('items', [])
+            if result and "data" in result:
+                items = result["data"].get(query_name, {}).get("items", [])
                 if len(items) > 0:
-                    logger.error(
-                        f'Record with {primary_field}="{value}" already exists in {model_name}')
+                    logger.error(f'Record with {primary_field}="{value}" already exists in {model_name}')
                     return None
         else:
             query_name = self._get_list_query_name(model_name)
@@ -446,21 +418,22 @@ class AmplifyClient:
             """
             filter_input = {primary_field: {"eq": value}}
             result = await self._request_async(session, query, {"filter": filter_input})
-            if result and 'data' in result:
-                items = result['data'].get(query_name, {}).get('items', [])
+            if result and "data" in result:
+                items = result["data"].get(query_name, {}).get("items", [])
                 if len(items) > 0:
-                    logger.error(
-                        f'Record with {primary_field}="{value}" already exists in {model_name}')
+                    logger.error(f'Record with {primary_field}="{value}" already exists in {model_name}')
                     return None
 
         return record
 
-    async def upload_batch_async(self, batch: list, model_name: str, primary_field: str,
-                                 is_secondary_index: bool) -> tuple[int, int]:
+    async def upload_batch_async(
+        self, batch: list, model_name: str, primary_field: str, is_secondary_index: bool
+    ) -> tuple[int, int]:
         async with aiohttp.ClientSession() as session:
             duplicate_checks = [
-                self.check_record_exists_async(session, model_name, primary_field,
-                                               record[primary_field], is_secondary_index, record)
+                self.check_record_exists_async(
+                    session, model_name, primary_field, record[primary_field], is_secondary_index, record
+                )
                 for record in batch
             ]
             check_results = await asyncio.gather(*duplicate_checks, return_exceptions=True)
@@ -476,8 +449,7 @@ class AmplifyClient:
                 return 0, len(batch)
 
             create_tasks = [
-                self.create_record_async(session, record, model_name, primary_field)
-                for record in filtered_batch
+                self.create_record_async(session, record, model_name, primary_field) for record in filtered_batch
             ]
             results = await asyncio.gather(*create_tasks, return_exceptions=True)
 
@@ -514,42 +486,41 @@ class AmplifyClient:
         """
 
         response = self._request(query)
-        if response and 'data' in response and '__type' in response['data']:
-            return response['data']['__type']
+        if response and "data" in response and "__type" in response["data"]:
+            return response["data"]["__type"]
 
         return {}
 
-    def get_primary_field_name(self, model_name: str, parsed_model_structure: Dict[str, Any]) -> (
-            tuple[str, bool]):
+    def get_primary_field_name(self, model_name: str, parsed_model_structure: Dict[str, Any]) -> tuple[str, bool]:
         secondary_index = self._get_secondary_index(model_name)
         if secondary_index:
             return secondary_index, True
 
-        for field in parsed_model_structure['fields']:
-            if field['is_required'] and field['is_scalar'] and field['name'] != 'id':
-                return field['name'], False
+        for field in parsed_model_structure["fields"]:
+            if field["is_required"] and field["is_scalar"] and field["name"] != "id":
+                return field["name"], False
 
-        logger.error('No suitable primary field found (required scalar field other than id)')
-        return '', False
+        logger.error("No suitable primary field found (required scalar field other than id)")
+        return "", False
 
     def _get_secondary_index(self, model_name: str) -> str:
         query_structure = self.get_model_structure("Query")
         if not query_structure:
             logger.error("Query type not found in schema")
-            return ''
+            return ""
 
-        query_fields = query_structure['fields']
+        query_fields = query_structure["fields"]
 
         pattern = f"{model_name}By"
 
         for query in query_fields:
-            query_name = query['name']
+            query_name = query["name"]
             if pattern in query_name:
                 pattern_index = query_name.index(pattern)
-                field_name = query_name[pattern_index + len(pattern):]
-                return field_name[0].lower() + field_name[1:] if field_name else ''
+                field_name = query_name[pattern_index + len(pattern) :]
+                return field_name[0].lower() + field_name[1:] if field_name else ""
 
-        return ''
+        return ""
 
     def _get_list_query_name(self, model_name: str) -> str | None:
         """Get the correct list query name from the schema (handles pluralization)"""
@@ -558,7 +529,7 @@ class AmplifyClient:
             logger.error("Query type not found in schema")
             return f"list{model_name}s"
 
-        query_fields = query_structure['fields']
+        query_fields = query_structure["fields"]
         candidates = [
             f"list{model_name}s",
             f"list{model_name}es",
@@ -566,8 +537,8 @@ class AmplifyClient:
         ]
 
         for query in query_fields:
-            query_name = query['name']
-            if query_name in candidates and 'By' not in query_name:
+            query_name = query["name"]
+            if query_name in candidates and "By" not in query_name:
                 return query_name
 
         logger.error(f"No list query found for model {model_name}, tried: {candidates}")
@@ -585,7 +556,7 @@ class AmplifyClient:
             return 0, len(records)
 
         for i in range(0, len(records), self.batch_size):
-            batch = records[i:i + self.batch_size]
+            batch = records[i : i + self.batch_size]
             logger.info(f"Uploading batch {i // self.batch_size + 1} ({len(batch)} items)...")
 
             batch_success, batch_error = asyncio.run(
@@ -595,16 +566,18 @@ class AmplifyClient:
             error_count += batch_error
 
             logger.info(
-                f"Processed batch {i // self.batch_size + 1} of model {model_name}: {success_count} success, {error_count} errors")
+                f"Processed batch {i // self.batch_size + 1} of model {model_name}: {success_count} success, {error_count} errors"
+            )
 
         return success_count, error_count
 
-    def list_records_by_secondary_index(self, model_name: str, secondary_index: str, value: str = None,
-                                        fields: list = None) -> Dict | None:
+    def list_records_by_secondary_index(
+        self, model_name: str, secondary_index: str, value: str = None, fields: list = None
+    ) -> Dict | None:
         if fields is None:
-            fields = ['id', secondary_index]
+            fields = ["id", secondary_index]
 
-        fields_str = '\n'.join(fields)
+        fields_str = "\n".join(fields)
 
         if not value:
             query_name = self._get_list_query_name(model_name)
@@ -631,17 +604,17 @@ class AmplifyClient:
             """
             result = self._request(query, {secondary_index: value})
 
-        if result and 'data' in result:
-            items = result['data'].get(query_name, {}).get('items', [])
+        if result and "data" in result:
+            items = result["data"].get(query_name, {}).get("items", [])
             return items if items else None
 
         return None
 
     def get_record_by_id(self, model_name: str, record_id: str, fields: list = None) -> Dict | None:
         if fields is None:
-            fields = ['id']
+            fields = ["id"]
 
-        fields_str = '\n'.join(fields)
+        fields_str = "\n".join(fields)
 
         query_name = f"get{model_name}"
         query = f"""
@@ -654,17 +627,18 @@ class AmplifyClient:
 
         result = self._request(query, {"id": record_id})
 
-        if result and 'data' in result:
-            return result['data'].get(query_name)
+        if result and "data" in result:
+            return result["data"].get(query_name)
 
         return None
 
-    def get_records_by_field(self, model_name: str, field_name: str, value: str = None,
-                             fields: list = None) -> Dict | None:
+    def get_records_by_field(
+        self, model_name: str, field_name: str, value: str = None, fields: list = None
+    ) -> Dict | None:
         if fields is None:
-            fields = ['id', field_name]
+            fields = ["id", field_name]
 
-        fields_str = '\n'.join(fields)
+        fields_str = "\n".join(fields)
 
         query_name = self._get_list_query_name(model_name)
 
@@ -689,21 +663,23 @@ class AmplifyClient:
               }}
             }}
             """
-            filter_input = {
-                field_name: {
-                    "eq": value
-                }
-            }
+            filter_input = {field_name: {"eq": value}}
             result = self._request(query, {"filter": filter_input})
 
-        if result and 'data' in result:
-            items = result['data'].get(query_name, {}).get('items', [])
+        if result and "data" in result:
+            items = result["data"].get(query_name, {}).get("items", [])
             return items if items else None
 
         return None
 
-    def get_records(self, model_name: str, parsed_model_structure: Dict[str, Any] = None, primary_field: str = None,
-                    is_secondary_index: bool = None, fields: list = None) -> list | None:
+    def get_records(
+        self,
+        model_name: str,
+        parsed_model_structure: Dict[str, Any] = None,
+        primary_field: str = None,
+        is_secondary_index: bool = None,
+        fields: list = None,
+    ) -> list | None:
         if model_name in self.records_cache:
             return self.records_cache[model_name]
 
@@ -724,9 +700,16 @@ class AmplifyClient:
             self.records_cache[model_name] = records
         return records
 
-    def get_record(self, model_name: str, parsed_model_structure: Dict[str, Any] = None, value: str = None,
-                   record_id: str = None, primary_field: str = None, is_secondary_index: bool = None,
-                   fields: list = None) -> Dict | None:
+    def get_record(
+        self,
+        model_name: str,
+        parsed_model_structure: Dict[str, Any] = None,
+        value: str = None,
+        record_id: str = None,
+        primary_field: str = None,
+        is_secondary_index: bool = None,
+        fields: list = None,
+    ) -> Dict | None:
         if record_id:
             return self.get_record_by_id(model_name, record_id)
 

{amplify_excel_migrator-1.0.0.dist-info → amplify_excel_migrator-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amplify-excel-migrator
-Version: 1.0.0
+Version: 1.0.1
 Summary: A CLI tool to migrate Excel data to AWS Amplify
 Home-page: https://github.com/EyalPoly/amplify-excel-migrator
 Author: Eyal Politansky
@@ -44,6 +44,14 @@ Developed for the MECO project - https://github.com/sworgkh/meco-observations-am
 
 ## Installation
 
+### From PyPI (Recommended)
+
+Install the latest stable version from PyPI:
+
+```bash
+pip install amplify-excel-migrator
+```
+
 ### From GitHub
 
 Install directly from GitHub:

amplify_excel_migrator-1.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+amplify_client.py,sha256=bv3iuSRQvykgiU4gSfmGK8QufbnXHcRRtxnZtnR5dck,26211
+migrator.py,sha256=iUrYAmKhwkuKBjayiuo9awN_5-5kEOrqHvHrBm4qQqc,12091
+model_field_parser.py,sha256=1dyfdzq3hIeK81TWAx8XnU6Bk-txt-PCYS_p8ZeQnTM,4482
+amplify_excel_migrator-1.0.1.dist-info/licenses/LICENSE,sha256=i8Sf8mXscGI9l-HTQ5RLQkAJU6Iv5hPYctJksPY70U0,1071
+amplify_excel_migrator-1.0.1.dist-info/METADATA,sha256=uUR_qYCRaOkUPe9ZdY9p0rCgzIeW3VoWX6goGf-0kmE,5675
+amplify_excel_migrator-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amplify_excel_migrator-1.0.1.dist-info/entry_points.txt,sha256=Ifd7YnV4lNbjFbbnjsmlHWiIAfIpiC5POgJtxfSlDT4,51
+amplify_excel_migrator-1.0.1.dist-info/top_level.txt,sha256=C-ffRe3F26GYiM7f6xy-pPvbwnh7Wnieyt-jS-cbdTU,43
+amplify_excel_migrator-1.0.1.dist-info/RECORD,,

migrator.py

@@ -12,11 +12,11 @@ import pandas as pd
 from amplify_client import AmplifyClient
 from model_field_parser import ModelFieldParser
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-CONFIG_DIR = Path.home() / '.amplify-migrator'
-CONFIG_FILE = CONFIG_DIR / 'config.json'
+CONFIG_DIR = Path.home() / ".amplify-migrator"
+CONFIG_FILE = CONFIG_DIR / "config.json"
 
 
 class ExcelToAmplifyMigrator:
@@ -25,8 +25,16 @@ class ExcelToAmplifyMigrator:
         self.excel_file_path = excel_file_path
         self.amplify_client = None
 
-    def init_client(self, api_endpoint: str, region: str, user_pool_id: str, is_aws_admin: bool = False,
-                    client_id: str = None, username: str = None, aws_profile: str = None):
+    def init_client(
+        self,
+        api_endpoint: str,
+        region: str,
+        user_pool_id: str,
+        is_aws_admin: bool = False,
+        client_id: str = None,
+        username: str = None,
+        aws_profile: str = None,
+    ):
 
         self.amplify_client = AmplifyClient(
             api_endpoint=api_endpoint,
@@ -36,8 +44,9 @@ class ExcelToAmplifyMigrator:
         )
 
         try:
-            self.amplify_client.init_cognito_client(is_aws_admin=is_aws_admin, username=username,
-                                                    aws_profile=aws_profile)
+            self.amplify_client.init_cognito_client(
+                is_aws_admin=is_aws_admin, username=username, aws_profile=aws_profile
+            )
 
         except RuntimeError or Exception:
             sys.exit(1)
@@ -99,31 +108,32 @@ class ExcelToAmplifyMigrator:
 
         model_record = {}
 
-        for field in parsed_model_structure['fields']:
+        for field in parsed_model_structure["fields"]:
             input = self.parse_input(row, field, parsed_model_structure)
             if input:
-                model_record[field['name']] = input
+                model_record[field["name"]] = input
 
         return model_record
 
     def parse_input(self, row: pd.Series, field: Dict[str, Any], parsed_model_structure: Dict[str, Any]) -> Any:
-        field_name = field['name'][:-2] if field['is_id'] else field['name']
+        field_name = field["name"][:-2] if field["is_id"] else field["name"]
         if field_name not in row.index or pd.isna(row[field_name]):
-            if field['is_required']:
+            if field["is_required"]:
                 raise ValueError(f"Required field '{field_name}' is missing in row {row.name}")
             else:
                 return None
 
-        value = row.get(field['name'])
-        if field['is_id']:
-            related_model = (temp := field['name'][:-2])[0].upper() + temp[1:]
-            record = self.amplify_client.get_record(related_model, parsed_model_structure=parsed_model_structure,
-                                                    value=value, fields=['id'])
+        value = row.get(field["name"])
+        if field["is_id"]:
+            related_model = (temp := field["name"][:-2])[0].upper() + temp[1:]
+            record = self.amplify_client.get_record(
+                related_model, parsed_model_structure=parsed_model_structure, value=value, fields=["id"]
+            )
             if record:
-                if record['id'] is None and field['is_required']:
+                if record["id"] is None and field["is_required"]:
                     raise ValueError(f"{related_model}: {value} does not exist")
                 else:
-                    value = record['id']
+                    value = record["id"]
             else:
                 raise ValueError(f"Error fetching related record {related_model}: {value}")
 
@@ -132,13 +142,13 @@ class ExcelToAmplifyMigrator:
     @staticmethod
     def to_camel_case(s: str) -> str:
         # Handle PascalCase
-        s_with_spaces = re.sub(r'(?<!^)(?=[A-Z])', ' ', s)
+        s_with_spaces = re.sub(r"(?<!^)(?=[A-Z])", " ", s)
 
-        parts = re.split(r'[\s_\-]+', s_with_spaces.strip())
-        return parts[0].lower() + ''.join(word.capitalize() for word in parts[1:])
+        parts = re.split(r"[\s_\-]+", s_with_spaces.strip())
+        return parts[0].lower() + "".join(word.capitalize() for word in parts[1:])
 
 
-def get_config_value(prompt: str, default: str = '', secret: bool = False) -> str:
+def get_config_value(prompt: str, default: str = "", secret: bool = False) -> str:
     if default:
         prompt = f"{prompt} [{default}]: "
     else:
@@ -155,9 +165,9 @@ def get_config_value(prompt: str, default: str = '', secret: bool = False) -> st
 def save_config(config: Dict[str, str]) -> None:
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 
-    cache_config = {k: v for k, v in config.items() if k not in ['password', 'ADMIN_PASSWORD']}
+    cache_config = {k: v for k, v in config.items() if k not in ["password", "ADMIN_PASSWORD"]}
 
-    with open(CONFIG_FILE, 'w') as f:
+    with open(CONFIG_FILE, "w") as f:
         json.dump(cache_config, f, indent=2)
 
     logger.info(f"✅ Configuration saved to {CONFIG_FILE}")
@@ -168,14 +178,14 @@ def load_cached_config() -> Dict[str, str]:
         return {}
 
     try:
-        with open(CONFIG_FILE, 'r') as f:
+        with open(CONFIG_FILE, "r") as f:
             return json.load(f)
     except Exception as e:
         logger.warning(f"Failed to load cached config: {e}")
         return {}
 
 
-def get_cached_or_prompt(key: str, prompt: str, cached_config: Dict, default: str = '', secret: bool = False) -> str:
+def get_cached_or_prompt(key: str, prompt: str, cached_config: Dict, default: str = "", secret: bool = False) -> str:
     if key in cached_config:
         return cached_config[key]
 
@@ -183,11 +193,13 @@ def get_cached_or_prompt(key: str, prompt: str, cached_config: Dict, default: st
 
 
 def cmd_show(args=None):
-    print("""
+    print(
+        """
     ╔════════════════════════════════════════════════════╗
     ║        Amplify Migrator - Current Configuration    ║
     ╚════════════════════════════════════════════════════╝
-    """)
+    """
+    )
 
     cached_config = load_cached_config()
 
@@ -210,18 +222,22 @@ def cmd_show(args=None):
 
 
 def cmd_config(args=None):
-    print("""
+    print(
+        """
     ╔════════════════════════════════════════════════════╗
     ║        Amplify Migrator - Configuration Setup      ║
     ╚════════════════════════════════════════════════════╝
-    """)
+    """
+    )
 
-    config = {'excel_path': get_config_value('Excel file path', 'data.xlsx'),
-              'api_endpoint': get_config_value('AWS Amplify API endpoint'),
-              'region': get_config_value('AWS Region', 'us-east-1'),
-              'user_pool_id': get_config_value('Cognito User Pool ID'),
-              'client_id': get_config_value('Cognito Client ID'),
-              'username': get_config_value('Admin Username')}
+    config = {
+        "excel_path": get_config_value("Excel file path", "data.xlsx"),
+        "api_endpoint": get_config_value("AWS Amplify API endpoint"),
+        "region": get_config_value("AWS Region", "us-east-1"),
+        "user_pool_id": get_config_value("Cognito User Pool ID"),
+        "client_id": get_config_value("Cognito Client ID"),
+        "username": get_config_value("Admin Username"),
+    }
 
     save_config(config)
     print("\n✅ Configuration saved successfully!")
@@ -229,13 +245,15 @@ def cmd_config(args=None):
 
 
 def cmd_migrate(args=None):
-    print("""
+    print(
+        """
     ╔════════════════════════════════════════════════════╗
     ║             Migrator Tool for Amplify              ║
     ╠════════════════════════════════════════════════════╣
     ║   This tool requires admin privileges to execute   ║
     ╚════════════════════════════════════════════════════╝
-    """)
+    """
+    )
 
     cached_config = load_cached_config()
 
@@ -244,20 +262,19 @@ def cmd_migrate(args=None):
         print("💡 Run 'amplify-migrator config' first to set up your configuration.")
         sys.exit(1)
 
-    excel_path = get_cached_or_prompt('excel_path', 'Excel file path', cached_config, 'data.xlsx')
-    api_endpoint = get_cached_or_prompt('api_endpoint', 'AWS Amplify API endpoint', cached_config)
-    region = get_cached_or_prompt('region', 'AWS Region', cached_config, 'us-east-1')
-    user_pool_id = get_cached_or_prompt('user_pool_id', 'Cognito User Pool ID', cached_config)
-    client_id = get_cached_or_prompt('client_id', 'Cognito Client ID', cached_config)
-    username = get_cached_or_prompt('username', 'Admin Username', cached_config)
+    excel_path = get_cached_or_prompt("excel_path", "Excel file path", cached_config, "data.xlsx")
+    api_endpoint = get_cached_or_prompt("api_endpoint", "AWS Amplify API endpoint", cached_config)
+    region = get_cached_or_prompt("region", "AWS Region", cached_config, "us-east-1")
+    user_pool_id = get_cached_or_prompt("user_pool_id", "Cognito User Pool ID", cached_config)
+    client_id = get_cached_or_prompt("client_id", "Cognito Client ID", cached_config)
+    username = get_cached_or_prompt("username", "Admin Username", cached_config)
 
     print("\n🔐 Authentication:")
     print("-" * 54)
-    password = get_config_value('ADMIN_PASSWORD', 'Admin Password', secret=True)
+    password = get_config_value("ADMIN_PASSWORD", "Admin Password", secret=True)
 
     migrator = ExcelToAmplifyMigrator(excel_path)
-    migrator.init_client(api_endpoint, region, user_pool_id, client_id=client_id,
-                         username=username)
+    migrator.init_client(api_endpoint, region, user_pool_id, client_id=client_id, username=username)
     if not migrator.authenticate(username, password):
         return
 
@@ -266,19 +283,19 @@ def cmd_migrate(args=None):
 
 def main():
     parser = argparse.ArgumentParser(
-        description='Amplify Excel Migrator - Migrate Excel data to AWS Amplify GraphQL API',
-        formatter_class=argparse.RawDescriptionHelpFormatter
+        description="Amplify Excel Migrator - Migrate Excel data to AWS Amplify GraphQL API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
     )
 
-    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
-    config_parser = subparsers.add_parser('config', help='Configure the migration tool')
+    config_parser = subparsers.add_parser("config", help="Configure the migration tool")
     config_parser.set_defaults(func=cmd_config)
 
-    show_parser = subparsers.add_parser('show', help='Show current configuration')
+    show_parser = subparsers.add_parser("show", help="Show current configuration")
     show_parser.set_defaults(func=cmd_show)
 
-    migrate_parser = subparsers.add_parser('migrate', help='Run the migration')
+    migrate_parser = subparsers.add_parser("migrate", help="Run the migration")
     migrate_parser.set_defaults(func=cmd_migrate)
 
     args = parser.parse_args()

model_field_parser.py

@@ -6,47 +6,60 @@ class ModelFieldParser:
 
     def __init__(self):
         self.scalar_types = {
-            'String', 'Int', 'Float', 'Boolean',
-            'AWSDate', 'AWSTime', 'AWSDateTime', 'AWSTimestamp',
-            'AWSEmail', 'AWSJSON', 'AWSURL', 'AWSPhone', 'AWSIPAddress'
+            "String",
+            "Int",
+            "Float",
+            "Boolean",
+            "AWSDate",
+            "AWSTime",
+            "AWSDateTime",
+            "AWSTimestamp",
+            "AWSEmail",
+            "AWSJSON",
+            "AWSURL",
+            "AWSPhone",
+            "AWSIPAddress",
         }
-        self.metadata_fields = {'id', 'createdAt', 'updatedAt', 'owner'}
+        self.metadata_fields = {"id", "createdAt", "updatedAt", "owner"}
 
     def parse_model_structure(self, introspection_result: Dict) -> Dict[str, Any]:
-        if 'data' in introspection_result and '__type' in introspection_result['data']:
-            type_data = introspection_result['data']['__type']
+        if "data" in introspection_result and "__type" in introspection_result["data"]:
+            type_data = introspection_result["data"]["__type"]
         else:
             type_data = introspection_result
 
         model_info = {
-            'name': type_data.get('name'),
-            'kind': type_data.get('kind'),
-            'description': type_data.get('description'),
-            'fields': []
+            "name": type_data.get("name"),
+            "kind": type_data.get("kind"),
+            "description": type_data.get("description"),
+            "fields": [],
         }
 
-        if type_data.get('fields'):
-            for field in type_data['fields']:
+        if type_data.get("fields"):
+            for field in type_data["fields"]:
                 parsed_field = self._parse_field(field)
-                model_info['fields'].append(parsed_field) if parsed_field else None
+                model_info["fields"].append(parsed_field) if parsed_field else None
 
         return model_info
 
     def _parse_field(self, field: Dict) -> Dict[str, Any]:
-        base_type = self._get_base_type_name(field.get('type', {}))
-        if 'Connection' in base_type or field.get('name') in self.metadata_fields or self._get_type_kind(
-                field.get('type', {})) in ['OBJECT', 'INTERFACE']:
+        base_type = self._get_base_type_name(field.get("type", {}))
+        if (
+            "Connection" in base_type
+            or field.get("name") in self.metadata_fields
+            or self._get_type_kind(field.get("type", {})) in ["OBJECT", "INTERFACE"]
+        ):
             return {}
 
         field_info = {
-            'name': field.get('name'),
-            'description': field.get('description'),
-            'type': base_type,
-            'is_required': self._is_required_field(field.get('type', {})),
-            'is_list': self._is_list_type(field.get('type', {})),
-            'is_scalar': base_type in self.scalar_types,
-            'is_id': base_type == 'ID',
-            'is_enum': field.get('type', {}).get('kind') == 'ENUM',
+            "name": field.get("name"),
+            "description": field.get("description"),
+            "type": base_type,
+            "is_required": self._is_required_field(field.get("type", {})),
+            "is_list": self._is_list_type(field.get("type", {})),
+            "is_scalar": base_type in self.scalar_types,
+            "is_id": base_type == "ID",
+            "is_enum": field.get("type", {}).get("kind") == "ENUM",
         }
 
         return field_info
@@ -57,17 +70,17 @@ class ModelFieldParser:
         """
 
         if not type_obj:
-            return {'name': 'Unknown', 'kind': 'UNKNOWN'}
+            return {"name": "Unknown", "kind": "UNKNOWN"}
 
         type_info = {
-            'name': type_obj.get('name'),
-            'kind': type_obj.get('kind'),
-            'full_type': self._get_full_type_string(type_obj)
+            "name": type_obj.get("name"),
+            "kind": type_obj.get("kind"),
+            "full_type": self._get_full_type_string(type_obj),
         }
 
         # If there's nested type info (NON_NULL, LIST), include it
-        if type_obj.get('ofType'):
-            type_info['of_type'] = self._parse_type(type_obj['ofType'])
+        if type_obj.get("ofType"):
+            type_info["of_type"] = self._parse_type(type_obj["ofType"])
 
         return type_info
 
@@ -77,20 +90,20 @@ class ModelFieldParser:
         """
 
         if not type_obj:
-            return 'Unknown'
+            return "Unknown"
 
-        if type_obj.get('name'):
-            return type_obj['name']
+        if type_obj.get("name"):
+            return type_obj["name"]
 
-        if type_obj['kind'] == 'NON_NULL':
-            inner = self._get_full_type_string(type_obj.get('ofType', {}))
+        if type_obj["kind"] == "NON_NULL":
+            inner = self._get_full_type_string(type_obj.get("ofType", {}))
             return f"{inner}!"
 
-        if type_obj['kind'] == 'LIST':
-            inner = self._get_full_type_string(type_obj.get('ofType', {}))
+        if type_obj["kind"] == "LIST":
+            inner = self._get_full_type_string(type_obj.get("ofType", {}))
             return f"[{inner}]"
 
-        return type_obj.get('kind', 'Unknown')
+        return type_obj.get("kind", "Unknown")
 
     def _get_base_type_name(self, type_obj: Dict) -> str:
         """
@@ -98,37 +111,37 @@ class ModelFieldParser:
         """
 
         if not type_obj:
-            return 'Unknown'
+            return "Unknown"
 
-        if type_obj.get('name'):
-            return type_obj['name']
+        if type_obj.get("name"):
+            return type_obj["name"]
 
-        if type_obj.get('ofType'):
-            return self._get_base_type_name(type_obj['ofType'])
+        if type_obj.get("ofType"):
+            return self._get_base_type_name(type_obj["ofType"])
 
-        return 'Unknown'
+        return "Unknown"
 
     def _get_type_kind(self, type_obj: Dict) -> str:
         if not type_obj:
-            return 'UNKNOWN'
+            return "UNKNOWN"
 
-        if type_obj['kind'] in ['NON_NULL', 'LIST'] and type_obj.get('ofType'):
-            return self._get_type_kind(type_obj['ofType'])
+        if type_obj["kind"] in ["NON_NULL", "LIST"] and type_obj.get("ofType"):
+            return self._get_type_kind(type_obj["ofType"])
 
-        return type_obj.get('kind', 'UNKNOWN')
+        return type_obj.get("kind", "UNKNOWN")
 
     @staticmethod
     def _is_required_field(type_obj: Dict) -> bool:
-        return type_obj and type_obj.get('kind') == 'NON_NULL'
+        return type_obj and type_obj.get("kind") == "NON_NULL"
 
     def _is_list_type(self, type_obj: Dict) -> bool:
         if not type_obj:
             return False
 
-        if type_obj['kind'] == 'LIST':
+        if type_obj["kind"] == "LIST":
             return True
 
-        if type_obj.get('ofType'):
-            return self._is_list_type(type_obj['ofType'])
+        if type_obj.get("ofType"):
+            return self._is_list_type(type_obj["ofType"])
 
         return False

amplify_excel_migrator-1.0.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-amplify_client.py,sha256=fZ9LKCzEMOY3upNGaPCEuofVXI8IN2JemQFxTsQN6q8,26916
-migrator.py,sha256=03YO5n6jymPA5bDr1Ks6FeSwi7bb8lZ_9LBjFSJCDi8,12081
-model_field_parser.py,sha256=u7f55WYg6eRS-_iyq9swzxntqyUQMH9vaX3j-RUG76w,4328
-amplify_excel_migrator-1.0.0.dist-info/licenses/LICENSE,sha256=i8Sf8mXscGI9l-HTQ5RLQkAJU6Iv5hPYctJksPY70U0,1071
-amplify_excel_migrator-1.0.0.dist-info/METADATA,sha256=7qXRVir9VJq6NEM7B1WswHe0jx4YF95iutb2nPWMLog,5552
-amplify_excel_migrator-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amplify_excel_migrator-1.0.0.dist-info/entry_points.txt,sha256=Ifd7YnV4lNbjFbbnjsmlHWiIAfIpiC5POgJtxfSlDT4,51
-amplify_excel_migrator-1.0.0.dist-info/top_level.txt,sha256=C-ffRe3F26GYiM7f6xy-pPvbwnh7Wnieyt-jS-cbdTU,43
-amplify_excel_migrator-1.0.0.dist-info/RECORD,,