ark-sdk-python 1.2.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

ark_sdk_python/actions/ark_configure_action.py

@@ -41,7 +41,7 @@ class ArkConfigureAction(ArkAction):
 
         # Add the profile settings to the arguments
         ArkPydanticArgparse.schema_to_argparse(
-            ArkProfile.schema(by_alias=False), conf_parser, ignore_keys=CONFIGURATION_IGNORED_DEFINITION_KEYS
+            ArkProfile.model_json_schema(by_alias=False), conf_parser, ignore_keys=CONFIGURATION_IGNORED_DEFINITION_KEYS
         )
 
         # Add the supported authenticator settings and whether to work with them or not
@@ -61,7 +61,7 @@ class ArkConfigureAction(ArkAction):
                 )
             # Add the rest of the ark auth profile params
             ArkPydanticArgparse.schema_to_argparse(
-                ArkAuthProfile.schema(by_alias=False),
+                ArkAuthProfile.model_json_schema(by_alias=False),
                 conf_parser,
                 key_prefix=authenticator.authenticator_name().replace('_', '-'),
                 ignore_keys=CONFIGURATION_IGNORED_DEFINITION_KEYS,
@@ -71,7 +71,7 @@ class ArkConfigureAction(ArkAction):
             for auth_method in authenticator.supported_auth_methods():
                 auth_settings = ArkAuthMethodSettingsMap[auth_method]
                 ArkPydanticArgparse.schema_to_argparse(
-                    auth_settings.schema(by_alias=False),
+                    auth_settings.model_json_schema(by_alias=False),
                     conf_parser,
                     key_prefix=authenticator.authenticator_name().replace('_', '-'),
                     ignore_keys=CONFIGURATION_IGNORED_DEFINITION_KEYS
@@ -98,7 +98,10 @@ class ArkConfigureAction(ArkAction):
 
         # Fill the rest of the profile settings
         profile_vals = ArkPydanticArgparse.argparse_to_schema_interactive(
-            ArkProfile.schema(by_alias=False), args, ignored_keys=CONFIGURATION_IGNORED_INTERACTIVE_KEYS, existing_values=profile.dict()
+            ArkProfile.model_json_schema(by_alias=False),
+            args,
+            ignored_keys=CONFIGURATION_IGNORED_INTERACTIVE_KEYS,
+            existing_values=profile.model_dump(),
         )
         profile = ArkPydanticArgparse.merge_by_model(ArkProfile, profile, profile_vals)
         if len(SUPPORTED_AUTHENTICATORS_LIST) == 1:
@@ -138,6 +141,7 @@ class ArkConfigureAction(ArkAction):
                         prioritize_existing_val=True,
                     )
                     auth_method = next(
+                        # pylint: disable-next=cell-var-from-loop
                         filter(lambda k: ArkAuthMethodsDescriptionMap[k] == auth_method, ArkAuthMethodsDescriptionMap.keys())
                     )
                     # If the default is chosen, override it by the authenticator's default
@@ -150,10 +154,10 @@ class ArkConfigureAction(ArkAction):
                 )
                 # Get the auth profile general settings
                 auth_profile_vals = ArkPydanticArgparse.argparse_to_schema_interactive(
-                    ArkAuthProfile.schema(by_alias=False),
+                    ArkAuthProfile.model_json_schema(by_alias=False),
                     args,
                     ignored_keys=ignored_keys,
-                    existing_values=auth_profile.dict(),
+                    existing_values=auth_profile.model_dump(),
                     key_prefix=authenticator.authenticator_name(),
                 )
                 auth_profile = ArkPydanticArgparse.merge_by_model(
@@ -169,11 +173,11 @@ class ArkConfigureAction(ArkAction):
                 if auth_method != auth_profile.auth_method:
                     method_settings = ArkAuthMethodSettingsMap[auth_method]()
                 else:
-                    method_settings = ArkAuthMethodSettingsMap[auth_method].parse_obj(auth_profile.auth_method_settings)
+                    method_settings = ArkAuthMethodSettingsMap[auth_method].model_validate(auth_profile.auth_method_settings)
                 method_settings_vals = ArkPydanticArgparse.argparse_to_schema_interactive(
-                    method_settings.schema(by_alias=False),
+                    method_settings.model_json_schema(by_alias=False),
                     args,
-                    existing_values=method_settings.dict(),
+                    existing_values=method_settings.model_dump(),
                     override_aliases=CONFIGURATION_OVERRIDE_ALIASES,
                     key_prefix=authenticator.authenticator_name(),
                     ignored_keys=CONFIGURATION_IGNORED_INTERACTIVE_KEYS
@@ -212,7 +216,7 @@ class ArkConfigureAction(ArkAction):
         profile = ArkPydanticArgparse.merge_by_model(
             ArkProfile,
             ArkProfileLoader.load_profile(args.profile_name) or ArkProfile(profile_name=args.profile_name),
-            ArkPydanticArgparse.argparse_to_schema(ArkProfile.schema(by_alias=False), args),
+            ArkPydanticArgparse.argparse_to_schema(ArkProfile.model_json_schema(by_alias=False), args),
         )
 
         # Load the authenticators
@@ -234,7 +238,7 @@ class ArkConfigureAction(ArkAction):
                     ArkAuthProfile,
                     auth_profile,
                     ArkPydanticArgparse.argparse_to_schema(
-                        ArkAuthProfile.schema(by_alias=False), args, key_prefix=authenticator.authenticator_name()
+                        ArkAuthProfile.model_json_schema(by_alias=False), args, key_prefix=authenticator.authenticator_name()
                     ),
                     key_prefix=authenticator.authenticator_name(),
                 )
@@ -248,11 +252,11 @@ class ArkConfigureAction(ArkAction):
                 if auth_method != auth_profile.auth_method:
                     method_settings = ArkAuthMethodSettingsMap[auth_method]()
                 else:
-                    method_settings = ArkAuthMethodSettingsMap[auth_method].parse_obj(method_settings)
+                    method_settings = ArkAuthMethodSettingsMap[auth_method].model_validate(method_settings)
 
                 # Parse and merge the method settings from the cli
                 method_settings_vals = ArkPydanticArgparse.argparse_to_schema(
-                    method_settings.schema(by_alias=False), args, key_prefix=authenticator.authenticator_name()
+                    method_settings.model_json_schema(by_alias=False), args, key_prefix=authenticator.authenticator_name()
                 )
 
                 # Remove the postfix
@@ -298,7 +302,7 @@ class ArkConfigureAction(ArkAction):
         ArkProfileLoader.save_profile(profile)
 
         # Print out results
-        ArkArgsFormatter.print_success(profile.json(indent=4))
+        ArkArgsFormatter.print_success(profile.model_dump_json(indent=4))
         ArkArgsFormatter.print_success_bright(
             f"Profile has been saved to {ArkProfileLoader.profiles_folder()}",
         )

ark_sdk_python/actions/ark_exec_action.py

@@ -8,7 +8,6 @@ from collections import namedtuple
 from typing import Any, Dict, Generator, List, Optional, Tuple, Type, Union
 
 from overrides import overrides
-from retry.api import retry_call
 
 from ark_sdk_python.actions.ark_action import ArkAction
 from ark_sdk_python.args import ArkArgsFormatter, ArkPydanticArgparse
@@ -16,6 +15,7 @@ from ark_sdk_python.auth import SUPPORTED_AUTHENTICATORS
 from ark_sdk_python.auth.ark_auth import ArkAuth
 from ark_sdk_python.cli_services import ArkCLIAPI
 from ark_sdk_python.common import ArkAsyncRequest, ArkPollers, ArkSystemConfig
+from ark_sdk_python.common.ark_retry import ArkRetry
 from ark_sdk_python.models import ArkException, ArkModel
 from ark_sdk_python.models.ark_model import ArkPollableModel
 from ark_sdk_python.models.ark_profile import ArkProfileLoader
@@ -30,25 +30,47 @@ class ArkExecAction(ArkAction):
             return self._serialize_output(list(itertools.chain.from_iterable([p.items for p in output])))
         if isinstance(output, list):
             return json.dumps(
-                [json.loads(a.json(by_alias=False, exclude={'poll_progress_callback'})) for a in output if a is not None], indent=4
+                [
+                    (
+                        json.loads(a.model_dump_json(by_alias=False, exclude={'poll_progress_callback'}))
+                        if issubclass(type(a), ArkModel)
+                        else a
+                    )
+                    for a in output
+                    if a is not None
+                ],
+                indent=4,
             )
         elif isinstance(output, tuple):
             return json.dumps(
-                [json.loads(a.json(by_alias=False, exclude={'poll_progress_callback'})) for a in output if a is not None], indent=4
+                [
+                    (
+                        json.loads(a.model_dump_json(by_alias=False, exclude={'poll_progress_callback'}))
+                        if issubclass(type(a), ArkModel)
+                        else a
+                    )
+                    for a in output
+                    if a is not None
+                ],
+                indent=4,
             )
         elif isinstance(output, dict):
             return json.dumps(
                 {
-                    k: json.loads(v.json(indent=4, by_alias=False, exclude={'poll_progress_callback'}))
+                    k: (
+                        json.loads(v.model_dump_json(indent=4, by_alias=False, exclude={'poll_progress_callback'}))
+                        if issubclass(type(v), ArkModel)
+                        else v
+                    )
                     for k, v in output.items()
                     if k is not None and v is not None
                 },
                 indent=4,
             )
         elif issubclass(type(output), ArkModel):
-            return output.json(indent=4, by_alias=False, exclude={'poll_progress_callback'})
+            return output.model_dump_json(indent=4, by_alias=False, exclude={'poll_progress_callback'})
         elif issubclass(type(output), ArkAsyncRequest):
-            return output.async_task.json(indent=4, by_alias=False)
+            return output.async_task.model_dump_json(indent=4, by_alias=False)
         return str(output)
 
     def _write_output_to_file(self, output_path: str, serialized_output: str) -> None:
@@ -63,7 +85,9 @@ class ArkExecAction(ArkAction):
     ) -> None:
         try:
             model_type: Type[ArkPollableModel] = schemas_map[action.replace('_', '-')]
-            model: ArkPollableModel = model_type.parse_obj(ArkPydanticArgparse.argparse_to_schema(model_type.schema(), args))
+            model: ArkPollableModel = model_type.model_validate(
+                ArkPydanticArgparse.argparse_to_schema(model_type.model_json_schema(), args)
+            )
             model.poll_progress_callback = ArkPollers.default_poller()
             output = getattr(service, action.replace('-', '_'))(model)
             async_req = None
@@ -77,22 +101,22 @@ class ArkExecAction(ArkAction):
             if async_req is not None:
                 if args.output_path:
                     self._write_output_to_file(
-                        args.output_path, async_req.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})
+                        args.output_path, async_req.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})
                     )
                 if async_req.task_failed():
                     if async_req.task_timeout():
                         ArkArgsFormatter.print_warning(
-                            f'Failed to execute async command due to timeout, error:\n{async_req.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                            f'Failed to execute async command due to timeout, error:\n{async_req.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                         )
                         raise ArkException(
-                            f'Failed to execute async command due to timeout, error:\n{async_req.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                            f'Failed to execute async command due to timeout, error:\n{async_req.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                         )
                     else:
                         ArkArgsFormatter.print_failure(
-                            f'Failed to execute async command, error:\n{async_req.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                            f'Failed to execute async command, error:\n{async_req.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                         )
                         raise ArkException(
-                            f'Failed to execute async command, error:\n{async_req.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                            f'Failed to execute async command, error:\n{async_req.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                         )
                 else:
                     ArkArgsFormatter.print_success(self._serialize_output(output))
@@ -100,23 +124,25 @@ class ArkExecAction(ArkAction):
                 if args.output_path:
                     self._write_output_to_file(
                         args.output_path,
-                        json.dumps([ar.async_task.dict(indent=4, by_alias=False, exclude={"poll_progress_callback"}) for ar in output]),
+                        json.dumps(
+                            [ar.async_task.model_dump(indent=4, by_alias=False, exclude={"poll_progress_callback"}) for ar in output]
+                        ),
                     )
                 for ar in output:
                     if ar.task_failed():
                         if ar.task_timeout():
                             ArkArgsFormatter.print_warning(
-                                f'Failed to execute async command due to timeout, error:\n{ar.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                                f'Failed to execute async command due to timeout, error:\n{ar.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                             )
                             raise ArkException(
-                                f'Failed to execute async command due to timeout, error:\n{ar.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                                f'Failed to execute async command due to timeout, error:\n{ar.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                             )
                         else:
                             ArkArgsFormatter.print_failure(
-                                f'Failed to execute async command, error:\n{ar.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                                f'Failed to execute async command, error:\n{ar.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                             )
                             raise ArkException(
-                                f'Failed to execute async command, error:\n{ar.async_task.json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
+                                f'Failed to execute async command, error:\n{ar.async_task.model_dump_json(indent=4, by_alias=False, exclude={"poll_progress_callback"})}',
                             )
                     else:
                         ArkArgsFormatter.print_success(self._serialize_output(ar))
@@ -134,7 +160,7 @@ class ArkExecAction(ArkAction):
         try:
             model_type: Type[ArkPollableModel] = schemas_map[action.replace('_', '-')]
             if model_type:
-                model: ArkModel = model_type.parse_obj(ArkPydanticArgparse.argparse_to_schema(model_type.schema(), args))
+                model: ArkModel = model_type.model_validate(ArkPydanticArgparse.argparse_to_schema(model_type.model_json_schema(), args))
                 output = getattr(service, action.replace('-', '_'))(model)
             else:
                 output = getattr(service, action.replace('-', '_'))()
@@ -161,7 +187,7 @@ class ArkExecAction(ArkAction):
             parser = subparsers.add_parser(action)
             if schema:
                 ArkPydanticArgparse.schema_to_argparse(
-                    schema.schema(), parser, defaults=defaults_map.get(action, None) if defaults_map else None
+                    schema.model_json_schema(), parser, defaults=defaults_map.get(action, None) if defaults_map else None
                 )
 
     @overrides
@@ -237,7 +263,7 @@ class ArkExecAction(ArkAction):
 
         # Run the actual exec fitting action with the api
         # Run it with retries as per defined by user
-        retry_call(
+        ArkRetry.retry_call(
             self.run_exec_action,
             fargs=[api, args],
             tries=args.retry_count,

ark_sdk_python/actions/ark_login_action.py

@@ -124,6 +124,7 @@ class ArkLoginAction(ArkAction):
                     and not args.__dict__[f'{authenticator_name}_secret']
                     and not args.no_shared_secrets
                 ):
+                    # pylint: disable-next=cell-var-from-loop
                     secret = next(filter(lambda s: auth_profile.username == s[0], shared_secrets_map[auth_profile.auth_method]))[1]
                 else:
                     if not args.force and (
@@ -139,7 +140,7 @@ class ArkLoginAction(ArkAction):
                         if (
                             authenticator_name == 'isp'
                             and auth_profile.auth_method == ArkAuthMethod.Identity
-                            and ArkIdentity.is_idp_user(
+                            and not ArkIdentity.is_password_required(
                                 auth_profile.username,
                                 (
                                     auth_profile.auth_method_settings.identity_url
@@ -182,7 +183,7 @@ class ArkLoginAction(ArkAction):
             if 'cookies' in v.metadata:
                 del v.metadata['cookies']
             ArkArgsFormatter.print_success(
-                f'{k} Token\n{v.json(indent=4, exclude={} if args.show_tokens else {"token", "refresh_token"})}',
+                f'{k} Token\n{v.model_dump_json(indent=4, exclude={} if args.show_tokens else {"token", "refresh_token"})}',
             )
 
     @overrides

ark_sdk_python/actions/ark_profiles_action.py

@@ -68,7 +68,7 @@ class ArkProfilesAction(ArkAction):
             profiles = [p for p in profiles if args.auth_profile in list(p.auth_profiles.keys())]
         # Print them based on request
         if args.all:
-            ArkArgsFormatter.print_success(json.dumps([p.dict() for p in profiles], indent=4))
+            ArkArgsFormatter.print_success(json.dumps([p.model_dump() for p in profiles], indent=4))
         else:
             ArkArgsFormatter.print_success(json.dumps([p.profile_name for p in profiles], indent=4))
 
@@ -80,7 +80,7 @@ class ArkProfilesAction(ArkAction):
                 f'No profile was found for the name {profile_name}',
             )
             return
-        ArkArgsFormatter.print_success(profile.json(indent=4))
+        ArkArgsFormatter.print_success(profile.model_dump_json(indent=4))
 
     def __run_delete_action(self, args: argparse.Namespace) -> None:
         profile: Optional[ArkProfile] = ArkProfileLoader.load_profile(args.profile_name)
@@ -136,7 +136,8 @@ class ArkProfilesAction(ArkAction):
             )
             return
         try:
-            profile: ArkProfile = ArkProfile.parse_file(args.profile_path)
+            with open(args.profile_path, 'r', encoding='utf-8') as fh:
+                profile: ArkProfile = ArkProfile.model_validate_json(fh.read())
             ArkProfileLoader.save_profile(profile)
         except Exception as ex:
             self._logger.exception(f'Failed to parser profile [{str(ex)}]')
@@ -156,9 +157,9 @@ class ArkProfilesAction(ArkAction):
         answer = inquirer.prompt(
             [inquirer.Editor('profile_edit', message=f'Chosen profile [{profile_name}] is about to be edited')],
             render=ArkInquirerRender(),
-            answers={'profile_edit': profile.json(indent=4)},
+            answers={'profile_edit': profile.model_dump_json(indent=4)},
         )
-        edited_profile = ArkProfile.parse_raw(answer['profile_edit'])
+        edited_profile = ArkProfile.model_validate_json(answer['profile_edit'])
         ArkProfileLoader.save_profile(edited_profile)
 
     @overrides

ark_sdk_python/actions/ark_service_exec_action.py

@@ -87,7 +87,7 @@ class ArkServiceExecAction(ArkExecAction):
         """
         action_def, action_dest = self.__deduce_action_command_def(args.command, args)
         action_value = args.__dict__[action_dest]
-        api_name = action_dest.replace('_action', '')
+        api_name = action_dest.replace('_action', '').replace('-', '_')
         while '_' in api_name and not hasattr(api, api_name):
             api_name = api_name.rsplit('_', 1)[0]
         service = getattr(api, api_name)

ark_sdk_python/args/ark_pydantic_argparse.py

@@ -128,7 +128,7 @@ class ArkPydanticArgparse:
                 is_required = True
             enum = None
             if 'enum' in def_prop:
-                enum = def_prop
+                enum = def_prop['enum']
             ArkPydanticArgparse.__populate_type(
                 prop_type, snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
             )
@@ -249,14 +249,31 @@ class ArkPydanticArgparse:
                         if item['type'] == 'object':
                             if ArkPydanticArgparse.__arg_in_schema(arg_key, item, definitions, f'{prefix}{snake_prop_name}.'):
                                 return item['type']
+                        if item['type'] == 'null':
+                            continue
                         if prefix + snake_prop_name == arg_key:
                             return item['type']
             elif (
                 'anyOf' in schema['properties'][prop_name].keys()
                 and isinstance(schema['properties'][prop_name]['anyOf'], list)
-                and all('type' in t for t in schema['properties'][prop_name]['anyOf'])
+                and all('type' in t or '$ref' in t for t in schema['properties'][prop_name]['anyOf'])
             ):
+                if any('$ref' in t for t in schema['properties'][prop_name]['anyOf']):
+                    item = [t for t in schema['properties'][prop_name]['anyOf'] if '$ref' in t][0]
+                    def_prop_name = item['$ref'].split('/')[2]
+                    def_prop = definitions[def_prop_name]
+                    if 'type' not in def_prop.keys():
+                        if 'enum' in def_prop.keys():
+                            return 'string'
+                        continue
+                    if def_prop['type'] == 'object':
+                        if ArkPydanticArgparse.__arg_in_schema(arg_key, def_prop, definitions, f'{prefix}{snake_prop_name}.'):
+                            return def_prop['type']
+                    if prefix + snake_prop_name == arg_key:
+                        return def_prop['type']
                 if prefix + snake_prop_name == arg_key:
+                    if any(t['type'] != 'null' for t in schema['properties'][prop_name]['anyOf']):
+                        return [t['type'] for t in schema['properties'][prop_name]['anyOf'] if t['type'] != 'null'][0]
                     return 'string'
             elif 'type' in schema['properties'][prop_name].keys():
                 if prefix + snake_prop_name == arg_key:
@@ -266,8 +283,41 @@ class ArkPydanticArgparse:
                         arg_key, schema['properties'][prop_name], definitions, f'{prefix}{snake_prop_name}.'
                     ):
                         return schema['properties'][prop_name]['type']
+                if schema['properties'][prop_name]['type'] == 'null':
+                    return None
         return None
 
+    @staticmethod
+    def __parse_types(args: Dict[str, str]) -> Dict[str, Any]:
+        parsed_args = {}
+        for k, v in args.items():
+            if not isinstance(v, str):
+                parsed_args[k] = v
+                continue
+            if v.lower() == 'true':
+                parsed_args[k] = True
+                continue
+            if v.lower() == 'false':
+                parsed_args[k] = False
+                continue
+            try:
+                parsed_args[k] = int(v)
+                continue
+            except:  # pylint: disable=bare-except
+                pass
+            try:
+                parsed_args[k] = float(v)
+                continue
+            except:  # pylint: disable=bare-except
+                pass
+            try:
+                parsed_args[k] = json.loads(v)
+                continue
+            except:  # pylint: disable=bare-except
+                pass
+            parsed_args[k] = v
+        return parsed_args
+
     @staticmethod
     def __arg_to_schema(
         arg_key: str, arg_val: Any, args_map: Dict[str, Any], arg_type: str, keep_empty_values: bool = False, key_prefix: str = ''
@@ -302,6 +352,7 @@ class ArkPydanticArgparse:
                         for item in next(csv.reader([arg_val], delimiter=',', quotechar="'", escapechar="\\", skipinitialspace=True))
                     )
                     if len(args_dict) > 0:
+                        args_dict = ArkPydanticArgparse.__parse_types(args_dict)
                         args_map[key_prefix + arg_key] = args_dict
                     elif arg_key != 'extrafields':
                         args_map[key_prefix + arg_key] = arg_val
@@ -321,10 +372,8 @@ class ArkPydanticArgparse:
     ) -> None:
         """
         Converts the given schema to argparse parameters.
-
         Recursively iterates over the JSON schema and adds parameters to the parser.
         The argparse parameters can then be parsed from the CLI and then converted back using argparse_to_schema function.
-
         This function does not return anything, but updates the parser itself.
 
         Args:
@@ -337,8 +386,8 @@ class ArkPydanticArgparse:
             ignore_keys (Optional[List[str]], optional): _description_. Defaults to None.
             key_prefix (str, optional): _description_. Defaults to ''.
         """
-        if not definitions and 'definitions' in schema.keys():
-            definitions = schema['definitions']
+        if not definitions and '$defs' in schema.keys():
+            definitions = schema['$defs']
         elif not definitions:
             definitions = {}
         if not required and 'required' in schema.keys():
@@ -381,25 +430,66 @@ class ArkPydanticArgparse:
             elif (
                 'anyOf' in schema['properties'][prop_name].keys()
                 and isinstance(schema['properties'][prop_name]['anyOf'], list)
-                and all('type' in t for t in schema['properties'][prop_name]['anyOf'])
+                and all('type' in t or '$ref' in t for t in schema['properties'][prop_name]['anyOf'])
             ):
                 snake_prop_name = re.sub(r'(?<!^)(?=[A-Z])', '_', prop_name).lower().replace('_', '-')
-                is_required = False
-                if prop_name in required:
-                    is_required = True
-                default = None
-                if 'default' in schema['properties'][prop_name].keys():
-                    default = schema['properties'][prop_name]['default']
-                desc = ''
-                if 'description' in schema['properties'][prop_name].keys():
-                    desc = schema['properties'][prop_name]['description']
-                enum = None
-                if 'enum' in schema['properties'][prop_name]:
-                    enum = schema['enum']
-                ArkPydanticArgparse.__populate_type(
-                    'string', snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
-                )
-                continue
+                if any('$ref' in t for t in schema['properties'][prop_name]['anyOf']):
+                    item = [t for t in schema['properties'][prop_name]['anyOf'] if '$ref' in t][0]
+                    def_prop_name = item['$ref'].split('/')[2]
+                    def_prop = definitions[def_prop_name]
+                    if 'type' not in def_prop.keys():
+                        if 'enum' in def_prop.keys():
+                            is_required = False
+                            if required and prop_name in required:
+                                is_required = True
+                            enum = def_prop['enum']
+                            ArkPydanticArgparse.__populate_type(
+                                'string', snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
+                            )
+                        continue
+                    prop_type = def_prop['type']
+                    if prop_type == 'object':
+                        ArkPydanticArgparse.schema_to_argparse(
+                            def_prop, parser, defaults, f'{prefix}{snake_prop_name}.', definitions, required, ignore_keys, key_prefix
+                        )
+                    else:
+                        is_required = False
+                        if required and prop_name in required:
+                            is_required = True
+                        default = None
+                        if 'default' in schema['properties'][prop_name].keys():
+                            default = schema['properties'][prop_name]['default']
+                        desc = ''
+                        if 'description' in schema['properties'][prop_name].keys():
+                            desc = schema['properties'][prop_name]['description']
+                        enum = None
+                        if 'enum' in def_prop:
+                            enum = def_prop['enum']
+                        ArkPydanticArgparse.__populate_type(
+                            prop_type, snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
+                        )
+                else:
+                    is_required = False
+                    if prop_name in required:
+                        is_required = True
+                    default = None
+                    if 'default' in schema['properties'][prop_name].keys():
+                        default = schema['properties'][prop_name]['default']
+                    desc = ''
+                    if 'description' in schema['properties'][prop_name].keys():
+                        desc = schema['properties'][prop_name]['description']
+                    enum = None
+                    if 'enum' in schema['properties'][prop_name]:
+                        enum = schema['enum']
+                    prop_type = 'string'
+                    if any(t['type'] != 'null' for t in schema['properties'][prop_name]['anyOf']) and all(
+                        t['type'] != 'string' for t in schema['properties'][prop_name]['anyOf']
+                    ):
+                        prop_type = [t['type'] for t in schema['properties'][prop_name]['anyOf'] if t['type'] != 'null'][0]
+                    ArkPydanticArgparse.__populate_type(
+                        prop_type, snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
+                    )
+                    continue
             desc = ''
             if 'description' in schema['properties'][prop_name].keys():
                 desc = schema['properties'][prop_name]['description']
@@ -424,6 +514,7 @@ class ArkPydanticArgparse:
                     'properties' not in schema['properties'][prop_name]
                     and (
                         'additionalProperties' in schema['properties'][prop_name]
+                        and isinstance(schema['properties'][prop_name]['additionalProperties'], dict)
                         and 'type' in schema['properties'][prop_name]['additionalProperties']
                         and len(schema['properties'][prop_name]['additionalProperties']) == 1
                     )
@@ -440,6 +531,26 @@ class ArkPydanticArgparse:
                         prop_type, snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
                     )
                 else:
+                    local_schema = schema['properties'][prop_name]
+                    if 'properties' not in local_schema.keys():
+                        prop_name = local_schema['title']
+                        snake_prop_name = re.sub(r'(?<!^)(?=[A-Z])', '_', prop_name).lower().replace('_', '-')
+                        is_required = False
+                        if prop_name in required:
+                            is_required = True
+                        default = None
+                        if 'default' in schema.keys():
+                            default = local_schema['default']
+                        desc = ''
+                        if 'description' in schema.keys():
+                            desc = local_schema['description']
+                        enum = None
+                        if 'enum' in local_schema:
+                            enum = local_schema['enum']
+                        ArkPydanticArgparse.__populate_type(
+                            local_schema['type'], snake_prop_name, default, is_required, parser, prefix, desc, ignore_keys, enum, key_prefix
+                        )
+                        continue
                     ArkPydanticArgparse.schema_to_argparse(
                         schema['properties'][prop_name],
                         parser,
@@ -489,8 +600,8 @@ class ArkPydanticArgparse:
             key_prefix = key_prefix + '_'
         if 'properties' not in schema:
             return {}
-        if not definitions and 'definitions' in schema.keys():
-            definitions = schema['definitions']
+        if not definitions and '$defs' in schema.keys():
+            definitions = schema['$defs']
         elif not definitions:
             definitions = {}
         if not override_aliases:
@@ -549,8 +660,10 @@ class ArkPydanticArgparse:
                 for key, value in loaded_args_map.items():
                     first, *others = key.split('_')
                     file_args_map[''.join([first.lower(), *map(str.title, others)])] = value
-        if 'definitions' in schema.keys():
-            definitions = schema['definitions']
+                    # Also add the snake case for models which are not camel based
+                    file_args_map[key] = value
+        if '$defs' in schema.keys():
+            definitions = schema['$defs']
         for arg_key, arg_val in args.__dict__.items():
             if ignored_keys and arg_key in ignored_keys:
                 continue
@@ -578,7 +691,6 @@ class ArkPydanticArgparse:
         """
         Converts the given schema and args into a finalized dictionary.
         The function interacts with the user and requests args that were not provided in the CLI.
-
         Returns a dict that combines the schema with the user inputs.
 
         Args:
@@ -658,15 +770,15 @@ class ArkPydanticArgparse:
         if key_prefix:
             new_vals = {k.replace(f'{key_prefix}_', ''): v for k, v in new_vals.items()}
         if isinstance(new_vals, BaseModel):
-            new_vals = new_vals.dict(by_alias=by_alias)
+            new_vals = new_vals.model_dump(by_alias=by_alias)
         new_vals = {k: v for k, v in new_vals.items() if v is not None}
-        vals_dict = existing_model.dict(by_alias=by_alias)
+        vals_dict = existing_model.model_dump(by_alias=by_alias)
         if ignore_keys:
             new_vals = {k: v for k, v in new_vals.items() if k not in ignore_keys}
         vals_dict.update(new_vals)
         if defaults:
             vals_dict.update({k: v for k, v in defaults.items() if k not in vals_dict or vals_dict[k] is None})
-        return model.parse_obj(vals_dict)
+        return model.model_validate(vals_dict)
 
     @staticmethod
     def schema_to_simple_arguments(
@@ -683,8 +795,8 @@ class ArkPydanticArgparse:
             Dict[str, TaskInputParameter]: _description_
         """
         definitions: dict = None
-        if 'definitions' in schema.keys():
-            definitions = schema['definitions']
+        if '$defs' in schema.keys():
+            definitions = schema['$defs']
         parser = argparse.ArgumentParser()
         ArkPydanticArgparse.schema_to_argparse(schema, parser, ignore_keys=ignore_keys)
         input_args = {}