def from_dict()

in atr/tasks/bulk.py [0:0]
49 lines of code
10 McCabe index (conditional complexity)

    def from_dict(args: dict[str, Any]) -> "Args":
        """Parse command line arguments."""
        _LOGGER.debug(f"Parsing arguments: {args}")

        if len(args) != 6:
            _LOGGER.error(f"Invalid number of arguments: {len(args)}, expected 6")
            raise ValueError("Invalid number of arguments")

        release_name = args["release_name"]
        base_url = args["base_url"]
        file_types = args["file_types"]
        require_sigs = args["require_sigs"]
        max_depth = args["max_depth"]
        max_concurrent = args["max_concurrent"]

        _LOGGER.debug(
            f"Extracted values - release_name: {release_name}, base_url: {base_url}, "
            f"file_types: {file_types}, require_sigs: {require_sigs}, "
            f"max_depth: {max_depth}, max_concurrent: {max_concurrent}"
        )

        if not isinstance(release_name, str):
            _LOGGER.error(f"Release key must be a string, got {type(release_name)}")
            raise ValueError("Release key must be a string")
        if not isinstance(base_url, str):
            _LOGGER.error(f"Base URL must be a string, got {type(base_url)}")
            raise ValueError("Base URL must be a string")
        if not isinstance(file_types, list):
            _LOGGER.error(f"File types must be a list, got {type(file_types)}")
            raise ValueError("File types must be a list")
        for arg in file_types:
            if not isinstance(arg, str):
                _LOGGER.error(f"File types must be a list of strings, got {type(arg)}")
                raise ValueError("File types must be a list of strings")
        if not isinstance(require_sigs, bool):
            _LOGGER.error(f"Require sigs must be a boolean, got {type(require_sigs)}")
            raise ValueError("Require sigs must be a boolean")
        if not isinstance(max_depth, int):
            _LOGGER.error(f"Max depth must be an integer, got {type(max_depth)}")
            raise ValueError("Max depth must be an integer")
        if not isinstance(max_concurrent, int):
            _LOGGER.error(f"Max concurrent must be an integer, got {type(max_concurrent)}")
            raise ValueError("Max concurrent must be an integer")

        _LOGGER.debug("All argument validations passed")

        args_obj = Args(
            release_name=release_name,
            base_url=base_url,
            file_types=file_types,
            require_sigs=require_sigs,
            max_depth=max_depth,
            max_concurrent=max_concurrent,
        )

        _LOGGER.info(f"Args object created: {args_obj}")
        return args_obj