casos

Proxy para operações relacionadas a casos na API PLDPro.

Caso

Operações de casos, arquivos e configurações de execução.

Source code in pldpro_sdk/core/proxies/casos.py

class Caso:
    """
    Operações de casos, arquivos e configurações de execução.
    """

    def __init__(self, api_client: ApiClient) -> None:
        self._caso_api = CasesApi(api_client)

    def create_caso(self, name: str) -> CaseResponse | None:
        """
        Cria um novo caso vazio.

        :param name: Nome do caso a ser criado.
        :type name: str
        :return: Resposta da API com os detalhes do caso criado ou None em caso de erro.
        :rtype: CaseResponse ou None
        """
        try:
            api_response = self._caso_api.create_empty_caso(name)
            return api_response
        except ApiException as e:
            error_msg = get_error_message(e)
            logger.error(
                f"Ocorreu o seguinte erro durante a criação do caso:\n\t {error_msg}",
                exc_info=False,
            )

    def associar_cortes_to_caso(
        self,caso_uuid:UUID, cortes_request: CortesRequest
    ) -> CaseResponse | None:
        """
        Associa a configuração de cortes a um caso.

        :param caso_uuid: Identificador único do caso.
        :type caso_uuid: UUID
        :param cortes_request: Dados da configuração de cortes.
        :type cortes_request: CortesRequest
        :return: Caso atualizado ou None caso a operação falhe.
        :rtype: CaseResponse | None
        """
        try:
            api_response = self._caso_api.associar_cortes_to_caso(
                caso_uuid=caso_uuid,
                cortes_request=cortes_request,
            )
            return api_response
        except ApiException as e:
            error_msg = get_error_message(e)
            logger.error(
                f"Ocorreu o seguinte erro durante a associacao do cortes no caso:\n\t {error_msg}",
                exc_info=False,
            )

    def create_caso_attach(
        self, caso_request: CaseRequest
    ) -> CaseResponse | None :
        """
        Cria um novo caso associado a um host remoto.

        :param caso_request: Objeto contendo os detalhes do caso a ser criado.
        :type caso_request: CaseRequest
        :return: Resposta da API com os detalhes do caso criado ou None em caso de erro.
        :rtype: CaseResponse ou None
        """
        try:
            api_response = self._caso_api.create_caso(caso_request)
            return api_response
        except ApiException as e:
            error_msg = get_error_message(e)
            logger.error(
                f"Ocorreu o seguinte erro durante a criação do caso:\n\t {error_msg}",
                exc_info=False,
            )

    def clone_caso(self, caso_id: UUID | str) -> CaseResponse | None:
        """
        Clona um caso existente.

        :param caso_id: Identificador único do caso a ser clonado.
        :type caso_id: UUID ou str
        :return: Resposta da API com os detalhes do caso clonado ou None em caso de erro.
        :rtype: CaseResponse ou None
        """
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        try:
            api_response = self._caso_api.clonar_caso(caso_id)
            return api_response
        except ApiException as e:
            error_msg = get_error_message(e)
            logger.error(
                f"Ocorreu o seguinte erro durante a clonagem do caso:\n\t {error_msg}",
                exc_info=False,
            )

    def list_casos(
        self,
        nome: Optional[str] = None,
        created_at: Optional[datetime] = None,
        page: Optional[int] = None,
        size: Optional[int] = None,
        sort: Optional[str] = None,
    ) -> CasePage:
        """
        Lista ou e normaliza a pagina retornada pela API.

        :param nome: Nome do caso para filtro opcional.
        :type nome: Optional[str]
        :param created_at: Data de criação para filtro opcional.
        :type created_at: Optional[datetime]
        :param page: Número da página para paginação.
        :type page: Optional[int]
        :param size: Tamanho da página para paginação.
        :type size: Optional[int]
        :param sort: Critério de ordenação.
        :type sort: Optional[str]
        :return: Resposta paginada contendo os casos filtrados.
        :rtype: CasePage
        """
        try:
            api_response = self._caso_api.filter_casos(
                nome=nome,
                created_from=created_at,
                page=page,
                size=size,
                sort=[sort] if sort else None,
            )
            return CasePage.from_api_response(api_response)
        except ApiException as error:
            logger.error(
                "Não foi possivel listar os casos: %s",
                get_error_message(error),
            )
            return CasePage(elements=[])

    def get_caso(self, caso_id:UUID | str) -> CaseResponse | None:
        """
        Obtém informações detalhadas de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :return: Resposta da API com os detalhes do caso ou None em caso de erro.
        :rtype: CaseResponse ou None
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            api_response = self._caso_api.get_caso(caso_id)
            return api_response
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao obter o caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )

    def get_status_caso(self, caso_id: UUID | str) -> str | None:
        """
        Obtém o status atual de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :return: Status do caso ou None em caso de erro.
        :rtype: str | None
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            api_response = self._caso_api.status_caso(caso_id)
            return api_response
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao obter o status do caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )

    def delete_caso(self, caso_id: UUID | str) -> bool:
        """
        Remove um caso existente.

        :param caso_id: Identificador único do caso a ser removido.
        :type caso_id: UUID ou str
        :return: True se a remoção for bem-sucedida, False caso contrário.
        :rtype: bool
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            self._caso_api.delete_caso_without_preload_content(caso_id)
            return True
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao remover o caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )
        return False

    def upload_files(
        self,
        caso_id: Union[UUID, str],
        files: Union[List[Path], List[str], Path, str],
        save_zip: bool = False,
    ) -> FileUploadResponse | None:
        """
        Faz o upload de arquivos ou diretórios para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param files: Arquivo(s) ou diretório a ser enviado.
        :type files: Union[List[Path], List[str], Path, str]
        :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
        :type save_zip: bool
        :return: Resposta da API com os detalhes dos arquivos enviados ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        return upload(
            self._caso_api.upload_files,
            "de arquivo(s) do caso",
            caso_id,
            files,
            should_zip=False,
            save_zip=save_zip,
        )

    def upload_entrada(
        self, caso_id: Union[UUID, str], filename: Union[Path, str]
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo de entrada para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param filename: Caminho do arquivo a ser enviado.
        :type filename: Union[Path, str]
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        ret = upload(
            self._caso_api.upload_file_entrada,
            "de arquivo de entrada",
            caso_id,
            filename,
            use_full_path=False,
            should_zip=False
        )
        return ret

    def upload_prevs(
        self,
        caso_id: Union[UUID, str],
        files: Union[List[Path], List[str], Path, str],
        encadeamento: TipoEncadeamentoSemanal | str | None = None,
        save_zip: bool = False,
    ) -> FileUploadResponse | None:
        """
        Faz o upload de arquivos de previsões para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param files: Arquivo(s) de previsões a ser(em) enviado(s).
        :type files: Union[List[Path], List[str], Path, str]
        :param encadeamento: Encadeamento semanal do caso. Prefira
                              TipoEncadeamentoSemanal para novos usos.
        :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
        :type save_zip: bool
        :return: Resposta da API com os detalhes dos arquivos de previsões enviados ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        return upload(
            self._caso_api.upload_prevs_files,
            "de arquivo(s) de previsões",
            caso_id,
            files,
            save_zip=save_zip,
            should_zip=False,
            encadeamento=enum_value(encadeamento),
        )

    def upload_cenarios_dessem(
        self,
        caso_id: Union[UUID, str],
        files: Union[List[Path], List[str], Path, str],
        save_zip: bool = False,
    ) -> FileUploadResponse | None:
        """
        Faz o upload de arquivos de cenários do DESSEM para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param files: Arquivo(s) de cenários do DESSEM a ser(em) enviado(s).
        :type files: Union[List[Path], List[str], Path, str]
        :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
        :type save_zip: bool
        :return: Resposta da API com os detalhes dos arquivos de cenários do DESSEM enviados ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        # NOTE: O metodo upload espera uma lista de arquivos, mesmo que seja um único arquivo
        if isinstance(files, str) or isinstance(files, Path):
            files = [files]  # type: ignore

        return upload(
            self._caso_api.upload_cenarios_dessem,
            "de arquivo(s) de cenários do DESSEM",
            caso_id,
            files,
            should_zip=False,
            save_zip=save_zip,
        )

    def upload_deck_partida(
        self,
        caso_id: Union[UUID, str],
        file_path: Union[Path, str],
        partida_config: PartidaConfig | Mapping[str, object] | str,
        save_zip=False,
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo de deck de partida para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param file_path: Caminho do arquivo de deck de partida a ser enviado.
        :type file_path: Union[Path, str]
        :param partida_config: Configuração da partida associada ao deck.
        :type partida_config: PartidaConfig
        :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
        :type save_zip: bool
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """

        return upload(
            method=self._caso_api.upload_deck_partida,
            error_context="de arquivo de deck de partida",
            caso_id=caso_id,
            files=file_path,
            save_zip=save_zip,
            partida_config=_to_json_part(partida_config),
        )

    def upload_deck_partida_semanal(
        self,
        caso_id: Union[UUID, str],
        file_path: Union[Path, str],
        partida_semanal_config: PartidaSemanalConfig | Mapping[str, object] | str,
        save_zip=False,
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo de deck de partida semanal para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param file_path: Caminho do arquivo de deck de partida semanal a ser enviado.
        :type file_path: Union[Path, str]
        :param partida_semanal_config: Configuração da partida semanal associada ao deck.
        :type partida_semanal_config: PartidaSemanalConfig
        :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo
        :type save_zip: bool
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """

        return upload(
            method=self._caso_api.upload_deck_partida_semanal,
            error_context="de arquivo de deck de partida semanal",
            caso_id=caso_id,
            files=file_path,
            save_zip=save_zip,
            partida_semanal_config=_to_json_part(partida_semanal_config),
        )

    def attach_caso_remote(
        self, caso_id: Union[UUID, str], node_id: Union[UUID, str], path_remote: str
    ) -> CaseResponse | None:
        """
        Anexa um caminho remoto a um caso existente.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param node_id: Identificador único do node remoto.
        :type node_id: Union[UUID, str]
        :param path_remote: Caminho remoto a ser anexado.
        :type path_remote: str
        :return: Resposta da API com os detalhes do caso atualizado ou None em caso de erro.
        :rtype: CaseResponse | None
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            if isinstance(node_id, str):
                node_id = UUID(node_id)

            case_update_request = CaseUpdateRequest(
                uuidAuthHost=node_id, pathRemote=path_remote
            )
            api_response = self._caso_api.associar_caminho_remoto(
                caso_id, case_update_request
            )
            return api_response
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao anexar o caminho remoto ao caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )

    def upload_ena_ree(
        self,
        caso_id: Union[UUID, str],
        filename: Union[Path, str],
        data_prevs: Union[datetime, str],
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo ENA-REE para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param filename: Caminho do arquivo ENA-REE a ser enviado.
        :type filename: Union[Path, str]
        :param data_prevs: Data de previsão utilizada na configuração do arquivo. Formato obrigatório: YYYY-MM-DD
        :type data_prevs: Union[datetime, str]
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        if isinstance(data_prevs, datetime):
            data_prevs = data_prevs.strftime("%Y-%m-%d")
        elif isinstance(data_prevs, str):
            try:
                datetime.strptime(data_prevs, "%Y-%m-%d")
            except ValueError:
                logger.error(
                    "O formato da data_prevs está incorreto. Use o formato YYYY-MM-DD.",
                    exc_info=False,
                )
                return None

        ret = upload(
            self._caso_api.upload_ena_ree,
            "de arquivo ENA-REE",
            caso_id,
            filename,
            use_full_path=False,
            data_prevs=data_prevs,
            should_zip=False
        )
        return ret

    def upload_regras_ana(
        self,
        caso_id: Union[UUID, str],
        filename: Union[Path, str],
        apaga_regras: Optional[str] = "N",
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo de regras ANA para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param filename: Caminho do arquivo de regras ANA a ser enviado.
        :type filename: Union[Path, str]
        :param apaga_regras: Indica se as regras existentes devem ser apagadas antes do upload.
        :type apaga_regras: Optional[str]
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        ret = upload(
            self._caso_api.upload_regras_ana,
            "de arquivo de regras ANA",
            caso_id,
            filename,
            use_full_path=False,
            apaga_regras=enum_value(apaga_regras),
        )
        return ret

    def upload_volume_final_decomp(
        self,
        caso_id: Union[UUID, str],
        filename: Union[Path, str],
        tipo_alteracao: str,
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo de volume final DECOMP para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param filename: Caminho do arquivo de volume final DECOMP a ser enviado.
        :type filename: Union[Path, str]
        :param tipo_alteracao: Tipo de alteração para o upload do arquivo.
        :type tipo_alteracao: str
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        ret = upload(
            self._caso_api.upload_volume_final_decomp,
            "de arquivo de volume final DECOMP",
            caso_id,
            filename,
            use_full_path=False,
            tipo_alteracao=enum_value(tipo_alteracao),
            should_zip=False
        )
        return ret

    def upload_volume_partida_decomp(
        self,
        caso_id: Union[UUID, str],
        filename: Union[Path, str],
        data_volume_partida: Union[datetime, str],
    ) -> FileUploadResponse | None:
        """
        Faz o upload de um arquivo de volume parcial DECOMP para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param filename: Caminho do arquivo de volume parcial DECOMP a ser enviado.
        :type filename: Union[Path, str]
        :param data_volume_partida: Data do volume de partida utilizada na configuração do arquivo. Formato obrigatório: YYYY-MM-DD
        :type data_volume_partida: Union[datetime, str]
        :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
        :rtype: FileUploadResponse | None
        """
        if isinstance(data_volume_partida, datetime):
            data_volume_partida = data_volume_partida.strftime("%Y-%m-%d")
        elif isinstance(data_volume_partida, str):
            try:
                datetime.strptime(data_volume_partida, "%Y-%m-%d")
            except ValueError:
                logger.error(
                    "O formato da data_volume_partida está incorreto. Use o formato YYYY-MM-DD.",
                    exc_info=False,
                )
                return None

        ret = upload(
            self._caso_api.upload_volume_partida_decomp,
            "de arquivo de volume parcial DECOMP",
            caso_id,
            filename,
            use_full_path=False,
            data_volume_partida=data_volume_partida,
            should_zip=False
        )
        return ret

    def list_caso_files(self, caso_id: Union[UUID, str]) -> FileNode | None:
        """
        Lista os arquivos associados a um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :return: Resposta da API com a lista de arquivos do caso ou None em caso de erro.
        :rtype: FileNode | None
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            api_response = self._caso_api.get_casos_files(caso_id)
            return api_response
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao listar os arquivos do caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )

    def download_caso_all(
        self, caso_id: Union[UUID, str], save_path: Union[Path, str] = ""
    ) -> str:
        """
        Faz o download de todos os arquivos de um caso como um arquivo zip.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param save_path: Caminho onde o arquivo zip deve ser salvo.
        :type save_path: Union[Path, str]
        :return: Caminho completo do arquivo zip salvo.
        :rtype: str
        """
        filename = f"caso_{caso_id}_all_files.zip"
        return download(self._caso_api.download_inputs, caso_id, filename, save_path)

    def download_caso_inputs(
        self, caso_id: Union[UUID, str], save_path: Union[Path, str] = ""
    ) -> str:
        """
        Faz o download dos arquivos de entrada de um caso como um arquivo zip.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param save_path: Caminho onde o arquivo zip deve ser salvo.
        :type save_path: Union[Path, str]
        :return: Caminho completo do arquivo zip salvo.
        :rtype: str
        """
        filename = f"caso_{caso_id}_inputs.zip"
        return download(
            self._caso_api.download_inputs_file, caso_id, filename, save_path
        )

    def download_input_file(
        self,
        caso_id: Union[UUID, str],
        filename: Union[Path, str],
        save_path: Union[Path, str] = "",
    ) -> str:
        """
        Faz o download de um arquivo específico de entrada de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param filename: Nome do arquivo a ser baixado.
        :type filename: Union[Path, str]
        :param save_path: Caminho onde o arquivo deve ser salvo.
        :type save_path: Union[Path, str]
        :return: Caminho completo do arquivo salvo.
        :rtype: str
        """
        return download(
            self._caso_api.download_specific_file,
            caso_id,
            filename,
            save_path,
            specific_file=True,
            as_zip=True,
        )

    def delete_caso_files(
        self, caso_id: Union[UUID, str], files: Union[List[Path], List[str]]
    ) -> bool:
        """
        Remove arquivos de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param files: Lista de arquivos a serem removidos.
        :type files: Union[List[Path], List[str]]
        :return: True se a remoção dos arquivos for bem-sucedida, False caso contrário.
        :rtype: bool
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            file_paths = [str(Path(f)) for f in files]
            self._caso_api.delete_files(caso_id, file_paths)
            return True
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao remover os arquivos do caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )
            return False

    def config_informacoes_iniciais(
        self, caso_id: Union[UUID, str], initial_info: CaseInitialDataRequest
    ) -> bool:
        """
        Configura as informações iniciais de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param initial_info: Objeto contendo as informações iniciais a serem configuradas.
        :type initial_info: CaseInitialDataRequest
        :return: Resposta da API com os detalhes do caso atualizado ou None em caso de erro.
        :rtype: bool
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            self._caso_api.configure_initial_data(caso_id, initial_info)
            return True
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao configurar as informações iniciais do caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )
            return False

    def escrever_cortes_path(self, caso_id: Union[UUID, str], new_path: str) -> str:
        """
        Escreve o caminho dos cortes no arquivo de entrada do caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: Union[UUID, str]
        :param new_path: Novo caminho dos arquivos de cortes.
        :type new_path: str
        :return: Caminho dos arquivos de cortes.
        :rtype: str
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            api_response = self._caso_api.escrever_cortes_path(
                caso_id,
                new_path,
                _content_type="text/plain",
                _headers={"Accept": "text/plain"},
            )

            return api_response
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao obter o caminho dos cortes do caso {caso_id}:\n\t {error_msg}",
                exc_info=False,
            )
            return ""

    def change_files_newave(
        self,
        caso_id: Union[UUID, str],
        builder: NewaveChangeFilesBuilder,
    ) -> UploadFilesChangesResponse | None:
        """
        Registra trocas de arquivos do NEWAVE para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados das trocas de arquivos do NEWAVE.
        :type builder: NewaveChangeFilesBuilder
        :return: Resultado do envio ou None caso a operação falhe.
        :rtype: UploadFilesChangesResponse | None
        """
        return self._change_files(caso_id, builder, TIPO_NEWAVE)

    def change_files_decomp(
        self,
        caso_id: Union[UUID, str],
        builder: DecompChangeFilesBuilder,
    ) -> UploadFilesChangesResponse | None:
        """
        Registra trocas de arquivos do DECOMP para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados das trocas de arquivos do DECOMP.
        :type builder: DecompChangeFilesBuilder
        :return: Resultado do envio ou None caso a operação falhe.
        :rtype: UploadFilesChangesResponse | None
        """
        return self._change_files(caso_id, builder, TIPO_DECOMP)

    def _change_files(
        self,
        caso_id: UUID  | str,
        builder: NewaveChangeFilesBuilder | DecompChangeFilesBuilder,
        tipo: str,
    ) -> UploadFilesChangesResponse | None:
        """
        Envia trocas de arquivos de um modelo para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados das trocas de arquivos.
        :type builder: NewaveChangeFilesBuilder ou DecompChangeFilesBuilder
        :param tipo: Identificador do modelo cujos arquivos serão alterados.
        :type tipo: str
        :return: Resultado do envio ou None caso a operação falhe.
        :rtype: UploadFilesChangesResponse | None
        """
        try:
            if isinstance(caso_id, str):
                caso_id = UUID(caso_id)

            items = builder.build()
            metadata_json, files = build_metadata_and_files(tipo, items)

            serialized_request = self._serialize_change_files_request(
                caso_id,
                metadata_json,
                files,
                tipo,
            )
            response_types_map = {
                "200": "UploadFilesChangesResponse",
                "400": "ErrorResponse",
            }

            response_data = self._caso_api.api_client.call_api(*serialized_request)
            response_data.read()

            return self._caso_api.api_client.response_deserialize(
                response_data=response_data,
                response_types_map=response_types_map,
            ).data

        except (ApiException, ValueError, FileNotFoundError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Ocorreu o seguinte erro ao registrar trocas de arquivos "
                f"{tipo} para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def _serialize_change_files_request(
        self,
        caso_id: UUID,
        metadata_json: str,
        files: dict,
        tipo: str,
    ) -> tuple:
        """Acrescenta as parts dinâmicas ao request multipart gerado pelo OpenAPI."""
        serializer = (
            self._caso_api._change_files_newave_serialize
            if tipo == TIPO_NEWAVE
            else self._caso_api._change_files_decomp_serialize
        )
        method, url, headers, body, post_params = serializer(
            uuid=caso_id,
            metadata=metadata_json,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0,
        )
        post_params.extend(self._caso_api.api_client.files_parameters(files))
        return method, url, headers, body, post_params

    def change_versions_newave(
            self,
            caso_id: UUID | str,
            builder: BaseChangeVersionsBuilder,
    ) -> VersionChangeResponse | None:
        """
        Registra trocas de versão do NEWAVE para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados das versões do NEWAVE.
        :type builder: BaseChangeVersionsBuilder
        :return: Resultado da alteração ou None caso a operação falhe.
        :rtype: VersionChangeResponse | None
        """
        try:
            return self._caso_api.change_versions_newave(UUID(str(caso_id)), builder.build())
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao registrar trocas de versão do NEWAVE para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def change_versions_decomp(
            self,
            caso_id: UUID | str,
            builder: BaseChangeVersionsBuilder,
    ) -> VersionChangeResponse | None:
        """
        Registra trocas de versão do DECOMP para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados das versões do DECOMP.
        :type builder: BaseChangeVersionsBuilder
        :return: Resultado da alteração ou None caso a operação falhe.
        :rtype: VersionChangeResponse | None
        """
        try:
            return self._caso_api.change_versions_decomp(UUID(str(caso_id)), builder.build())
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao registrar trocas de versão do DECOMP para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def change_versions_gevazp(
            self,
            caso_id: UUID | str,
            builder: BaseChangeVersionsBuilder,
    ) -> VersionChangeResponse | None:
        """
        Registra trocas de versão do GEVAZP para um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados das versões do GEVAZP.
        :type builder: BaseChangeVersionsBuilder
        :return: Resultado da alteração ou None caso a operação falhe.
        :rtype: VersionChangeResponse | None
        """
        try:
            return self._caso_api.change_versions_gevazp(UUID(str(caso_id)), builder.build())
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao registrar trocas de versão do GEVAZP para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def change_processors_newave(
        self,
        caso_id: UUID | str,
        quantidade_processadores: int,
    ) -> "ProcessorCountResponse | None":
        """
        Atualiza a quantidade de processadores do NEWAVE.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param quantidade_processadores: Quantidade de processadores a ser configurada.
        :type quantidade_processadores: int
        :return: Resultado da alteração ou None caso a operação falhe.
        :rtype: ProcessorCountResponse | None
        """
        return self._change_processors(caso_id, quantidade_processadores, TIPO_NEWAVE)

    def change_processors_decomp(
        self,
        caso_id: UUID | str,
        quantidade_processadores: int,
    ) -> "ProcessorCountResponse | None":
        """
        Atualiza a quantidade de processadores do DECOMP.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param quantidade_processadores: Quantidade de processadores a ser configurada.
        :type quantidade_processadores: int
        :return: Resultado da alteração ou None caso a operação falhe.
        :rtype: ProcessorCountResponse | None
        """
        return self._change_processors(caso_id, quantidade_processadores, TIPO_DECOMP)

    def _change_processors(
        self,
        caso_id: UUID | str,
        quantidade_processadores: int,
        tipo: str,
    ) -> "ProcessorCountResponse | None":
        """
        Atualiza a quantidade de processadores de um modelo.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param quantidade_processadores: Quantidade de processadores a ser configurada.
        :type quantidade_processadores: int
        :param tipo: Identificador do modelo configurado.
        :type tipo: str
        :return: Resultado da alteração ou None caso a operação falhe.
        :rtype: ProcessorCountResponse | None
        """
        try:
            caso_uuid = UUID(str(caso_id))
            request = self._build_numero_processadores_request(
                quantidade_processadores,
                tipo,
            )

            if tipo == TIPO_NEWAVE:
                return self._caso_api.change_processors_newave(caso_uuid, request)

            return self._caso_api.change_processors_decomp(caso_uuid, request)

        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao registrar número de processadores do {tipo.upper()} "
                f"para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def _build_numero_processadores_request(
        self,
        quantidade_processadores: int,
        tipo: str,
    ) -> ProcessorCountRequest:
        if not isinstance(quantidade_processadores, int) or isinstance(quantidade_processadores, bool):
            raise ValueError("quantidade_processadores deve ser um inteiro.")

        if quantidade_processadores < 0:
            raise ValueError("quantidade_processadores não pode ser negativa.")

        limite = 999 if tipo == TIPO_NEWAVE else 99
        if quantidade_processadores > limite:
            raise ValueError(f"quantidade_processadores excede o limite permitido para {tipo.upper()}: {limite}.")

        return ProcessorCountRequest(quantidadeProcessadores=quantidade_processadores)

    def configure_consistency(
        self,
        caso_id: UUID | str,
        builder: ConsistencyConfigBuilder,
    ) -> "ConsistencyConfigResponse | None":
        """
        Configura a rodada de consistência de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados da configuração de consistência.
        :type builder: ConsistencyConfigBuilder
        :return: Configuração registrada ou None caso a operação falhe.
        :rtype: ConsistencyConfigResponse | None
        """
        try:
            caso_uuid = UUID(str(caso_id))
            return self._caso_api.configure_consistency(caso_uuid, builder.build())
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao configurar consistência para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def configure_dadger(
        self,
        caso_id: UUID | str,
        builder: DadgerConfigBuilder,
    ) -> "DadgerConfigResponse | None":
        """
        Configura a geração do DADGER de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados da configuração do DADGER.
        :type builder: DadgerConfigBuilder
        :return: Configuração registrada ou None caso a operação falhe.
        :rtype: DadgerConfigResponse | None
        """
        try:
            caso_uuid = UUID(str(caso_id))
            api_response: ApiDadgerConfigResponse = self._caso_api.configure_dadger(
                caso_uuid,
                builder.build(),
            )
            return DadgerConfigResponse.from_api_response(api_response)
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao configurar o DADGER para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def configure_execution_with_partida(
        self,
        caso_id: UUID | str,
        builder: ExecutionWithPartidaBuilder,
    ) -> "ExecutionPartidaConfigResponse | None":
        """
        Configura a execução com partida de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados da configuração de execução com partida.
        :type builder: ExecutionWithPartidaBuilder
        :return: Configuração registrada ou None caso a operação falhe.
        :rtype: ExecutionPartidaConfigResponse | None
        """
        try:
            caso_uuid = UUID(str(caso_id))
            return self._caso_api.configure_execution_with_partida(caso_uuid, builder.build())
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao configurar execução com partida para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

    def configure_execution_models(
        self,
        caso_id: UUID | str,
        builder: ModelExecutionConfigBuilder,
    ) -> "ExecutionModelsConfigResponse | None":
        """
        Configura a execução dos modelos de um caso.

        :param caso_id: Identificador único do caso.
        :type caso_id: UUID ou str
        :param builder: Dados da configuração dos modelos de execução.
        :type builder: ModelExecutionConfigBuilder
        :return: Configuração registrada ou None caso a operação falhe.
        :rtype: ExecutionModelsConfigResponse | None
        """
        try:
            caso_uuid = UUID(str(caso_id))
            return self._caso_api.configure_execution_models(caso_uuid, builder.build())
        except (ApiException, ValueError) as e:
            error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
            logger.error(
                f"Erro ao configurar a execucao dos modelos para o caso {caso_id}:\n\t{error_msg}",
                exc_info=False,
            )
            return None

associar_cortes_to_caso(caso_uuid, cortes_request)

Associa a configuração de cortes a um caso.

Parameters:

Name	Type	Description	Default
caso_uuid	UUID	Identificador único do caso.	required
cortes_request	CortesRequest	Dados da configuração de cortes.	required

Returns:

Type	Description
CaseResponse | None	Caso atualizado ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def associar_cortes_to_caso(
    self,caso_uuid:UUID, cortes_request: CortesRequest
) -> CaseResponse | None:
    """
    Associa a configuração de cortes a um caso.

    :param caso_uuid: Identificador único do caso.
    :type caso_uuid: UUID
    :param cortes_request: Dados da configuração de cortes.
    :type cortes_request: CortesRequest
    :return: Caso atualizado ou None caso a operação falhe.
    :rtype: CaseResponse | None
    """
    try:
        api_response = self._caso_api.associar_cortes_to_caso(
            caso_uuid=caso_uuid,
            cortes_request=cortes_request,
        )
        return api_response
    except ApiException as e:
        error_msg = get_error_message(e)
        logger.error(
            f"Ocorreu o seguinte erro durante a associacao do cortes no caso:\n\t {error_msg}",
            exc_info=False,
        )

attach_caso_remote(caso_id, node_id, path_remote)

Anexa um caminho remoto a um caso existente.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
node_id	Union[UUID, str]	Identificador único do node remoto.	required
path_remote	str	Caminho remoto a ser anexado.	required

Returns:

Type	Description
CaseResponse | None	Resposta da API com os detalhes do caso atualizado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def attach_caso_remote(
    self, caso_id: Union[UUID, str], node_id: Union[UUID, str], path_remote: str
) -> CaseResponse | None:
    """
    Anexa um caminho remoto a um caso existente.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param node_id: Identificador único do node remoto.
    :type node_id: Union[UUID, str]
    :param path_remote: Caminho remoto a ser anexado.
    :type path_remote: str
    :return: Resposta da API com os detalhes do caso atualizado ou None em caso de erro.
    :rtype: CaseResponse | None
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        if isinstance(node_id, str):
            node_id = UUID(node_id)

        case_update_request = CaseUpdateRequest(
            uuidAuthHost=node_id, pathRemote=path_remote
        )
        api_response = self._caso_api.associar_caminho_remoto(
            caso_id, case_update_request
        )
        return api_response
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao anexar o caminho remoto ao caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )

change_files_decomp(caso_id, builder)

Registra trocas de arquivos do DECOMP para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
builder	DecompChangeFilesBuilder	Dados das trocas de arquivos do DECOMP.	required

Returns:

Type	Description
UploadFilesChangesResponse | None	Resultado do envio ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_files_decomp(
    self,
    caso_id: Union[UUID, str],
    builder: DecompChangeFilesBuilder,
) -> UploadFilesChangesResponse | None:
    """
    Registra trocas de arquivos do DECOMP para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados das trocas de arquivos do DECOMP.
    :type builder: DecompChangeFilesBuilder
    :return: Resultado do envio ou None caso a operação falhe.
    :rtype: UploadFilesChangesResponse | None
    """
    return self._change_files(caso_id, builder, TIPO_DECOMP)

change_files_newave(caso_id, builder)

Registra trocas de arquivos do NEWAVE para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
builder	NewaveChangeFilesBuilder	Dados das trocas de arquivos do NEWAVE.	required

Returns:

Type	Description
UploadFilesChangesResponse | None	Resultado do envio ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_files_newave(
    self,
    caso_id: Union[UUID, str],
    builder: NewaveChangeFilesBuilder,
) -> UploadFilesChangesResponse | None:
    """
    Registra trocas de arquivos do NEWAVE para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados das trocas de arquivos do NEWAVE.
    :type builder: NewaveChangeFilesBuilder
    :return: Resultado do envio ou None caso a operação falhe.
    :rtype: UploadFilesChangesResponse | None
    """
    return self._change_files(caso_id, builder, TIPO_NEWAVE)

change_processors_decomp(caso_id, quantidade_processadores)

Atualiza a quantidade de processadores do DECOMP.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
quantidade_processadores	int	Quantidade de processadores a ser configurada.	required

Returns:

Type	Description
ProcessorCountResponse | None	Resultado da alteração ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_processors_decomp(
    self,
    caso_id: UUID | str,
    quantidade_processadores: int,
) -> "ProcessorCountResponse | None":
    """
    Atualiza a quantidade de processadores do DECOMP.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param quantidade_processadores: Quantidade de processadores a ser configurada.
    :type quantidade_processadores: int
    :return: Resultado da alteração ou None caso a operação falhe.
    :rtype: ProcessorCountResponse | None
    """
    return self._change_processors(caso_id, quantidade_processadores, TIPO_DECOMP)

change_processors_newave(caso_id, quantidade_processadores)

Atualiza a quantidade de processadores do NEWAVE.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
quantidade_processadores	int	Quantidade de processadores a ser configurada.	required

Returns:

Type	Description
ProcessorCountResponse | None	Resultado da alteração ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_processors_newave(
    self,
    caso_id: UUID | str,
    quantidade_processadores: int,
) -> "ProcessorCountResponse | None":
    """
    Atualiza a quantidade de processadores do NEWAVE.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param quantidade_processadores: Quantidade de processadores a ser configurada.
    :type quantidade_processadores: int
    :return: Resultado da alteração ou None caso a operação falhe.
    :rtype: ProcessorCountResponse | None
    """
    return self._change_processors(caso_id, quantidade_processadores, TIPO_NEWAVE)

change_versions_decomp(caso_id, builder)

Registra trocas de versão do DECOMP para um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	BaseChangeVersionsBuilder	Dados das versões do DECOMP.	required

Returns:

Type	Description
VersionChangeResponse | None	Resultado da alteração ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_versions_decomp(
        self,
        caso_id: UUID | str,
        builder: BaseChangeVersionsBuilder,
) -> VersionChangeResponse | None:
    """
    Registra trocas de versão do DECOMP para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados das versões do DECOMP.
    :type builder: BaseChangeVersionsBuilder
    :return: Resultado da alteração ou None caso a operação falhe.
    :rtype: VersionChangeResponse | None
    """
    try:
        return self._caso_api.change_versions_decomp(UUID(str(caso_id)), builder.build())
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao registrar trocas de versão do DECOMP para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

change_versions_gevazp(caso_id, builder)

Registra trocas de versão do GEVAZP para um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	BaseChangeVersionsBuilder	Dados das versões do GEVAZP.	required

Returns:

Type	Description
VersionChangeResponse | None	Resultado da alteração ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_versions_gevazp(
        self,
        caso_id: UUID | str,
        builder: BaseChangeVersionsBuilder,
) -> VersionChangeResponse | None:
    """
    Registra trocas de versão do GEVAZP para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados das versões do GEVAZP.
    :type builder: BaseChangeVersionsBuilder
    :return: Resultado da alteração ou None caso a operação falhe.
    :rtype: VersionChangeResponse | None
    """
    try:
        return self._caso_api.change_versions_gevazp(UUID(str(caso_id)), builder.build())
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao registrar trocas de versão do GEVAZP para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

change_versions_newave(caso_id, builder)

Registra trocas de versão do NEWAVE para um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	BaseChangeVersionsBuilder	Dados das versões do NEWAVE.	required

Returns:

Type	Description
VersionChangeResponse | None	Resultado da alteração ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def change_versions_newave(
        self,
        caso_id: UUID | str,
        builder: BaseChangeVersionsBuilder,
) -> VersionChangeResponse | None:
    """
    Registra trocas de versão do NEWAVE para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados das versões do NEWAVE.
    :type builder: BaseChangeVersionsBuilder
    :return: Resultado da alteração ou None caso a operação falhe.
    :rtype: VersionChangeResponse | None
    """
    try:
        return self._caso_api.change_versions_newave(UUID(str(caso_id)), builder.build())
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao registrar trocas de versão do NEWAVE para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

clone_caso(caso_id)

Clona um caso existente.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso a ser clonado.	required

Returns:

Type	Description
CaseResponse ou None	Resposta da API com os detalhes do caso clonado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def clone_caso(self, caso_id: UUID | str) -> CaseResponse | None:
    """
    Clona um caso existente.

    :param caso_id: Identificador único do caso a ser clonado.
    :type caso_id: UUID ou str
    :return: Resposta da API com os detalhes do caso clonado ou None em caso de erro.
    :rtype: CaseResponse ou None
    """
    if isinstance(caso_id, str):
        caso_id = UUID(caso_id)

    try:
        api_response = self._caso_api.clonar_caso(caso_id)
        return api_response
    except ApiException as e:
        error_msg = get_error_message(e)
        logger.error(
            f"Ocorreu o seguinte erro durante a clonagem do caso:\n\t {error_msg}",
            exc_info=False,
        )

config_informacoes_iniciais(caso_id, initial_info)

Configura as informações iniciais de um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
initial_info	CaseInitialDataRequest	Objeto contendo as informações iniciais a serem configuradas.	required

Returns:

Type	Description
bool	Resposta da API com os detalhes do caso atualizado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def config_informacoes_iniciais(
    self, caso_id: Union[UUID, str], initial_info: CaseInitialDataRequest
) -> bool:
    """
    Configura as informações iniciais de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param initial_info: Objeto contendo as informações iniciais a serem configuradas.
    :type initial_info: CaseInitialDataRequest
    :return: Resposta da API com os detalhes do caso atualizado ou None em caso de erro.
    :rtype: bool
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        self._caso_api.configure_initial_data(caso_id, initial_info)
        return True
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao configurar as informações iniciais do caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )
        return False

configure_consistency(caso_id, builder)

Configura a rodada de consistência de um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	ConsistencyConfigBuilder	Dados da configuração de consistência.	required

Returns:

Type	Description
ConsistencyConfigResponse | None	Configuração registrada ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def configure_consistency(
    self,
    caso_id: UUID | str,
    builder: ConsistencyConfigBuilder,
) -> "ConsistencyConfigResponse | None":
    """
    Configura a rodada de consistência de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados da configuração de consistência.
    :type builder: ConsistencyConfigBuilder
    :return: Configuração registrada ou None caso a operação falhe.
    :rtype: ConsistencyConfigResponse | None
    """
    try:
        caso_uuid = UUID(str(caso_id))
        return self._caso_api.configure_consistency(caso_uuid, builder.build())
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao configurar consistência para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

configure_dadger(caso_id, builder)

Configura a geração do DADGER de um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	DadgerConfigBuilder	Dados da configuração do DADGER.	required

Returns:

Type	Description
DadgerConfigResponse | None	Configuração registrada ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def configure_dadger(
    self,
    caso_id: UUID | str,
    builder: DadgerConfigBuilder,
) -> "DadgerConfigResponse | None":
    """
    Configura a geração do DADGER de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados da configuração do DADGER.
    :type builder: DadgerConfigBuilder
    :return: Configuração registrada ou None caso a operação falhe.
    :rtype: DadgerConfigResponse | None
    """
    try:
        caso_uuid = UUID(str(caso_id))
        api_response: ApiDadgerConfigResponse = self._caso_api.configure_dadger(
            caso_uuid,
            builder.build(),
        )
        return DadgerConfigResponse.from_api_response(api_response)
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao configurar o DADGER para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

configure_execution_models(caso_id, builder)

Configura a execução dos modelos de um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	ModelExecutionConfigBuilder	Dados da configuração dos modelos de execução.	required

Returns:

Type	Description
ExecutionModelsConfigResponse | None	Configuração registrada ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def configure_execution_models(
    self,
    caso_id: UUID | str,
    builder: ModelExecutionConfigBuilder,
) -> "ExecutionModelsConfigResponse | None":
    """
    Configura a execução dos modelos de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados da configuração dos modelos de execução.
    :type builder: ModelExecutionConfigBuilder
    :return: Configuração registrada ou None caso a operação falhe.
    :rtype: ExecutionModelsConfigResponse | None
    """
    try:
        caso_uuid = UUID(str(caso_id))
        return self._caso_api.configure_execution_models(caso_uuid, builder.build())
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao configurar a execucao dos modelos para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

configure_execution_with_partida(caso_id, builder)

Configura a execução com partida de um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required
builder	ExecutionWithPartidaBuilder	Dados da configuração de execução com partida.	required

Returns:

Type	Description
ExecutionPartidaConfigResponse | None	Configuração registrada ou None caso a operação falhe.

Source code in pldpro_sdk/core/proxies/casos.py

def configure_execution_with_partida(
    self,
    caso_id: UUID | str,
    builder: ExecutionWithPartidaBuilder,
) -> "ExecutionPartidaConfigResponse | None":
    """
    Configura a execução com partida de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :param builder: Dados da configuração de execução com partida.
    :type builder: ExecutionWithPartidaBuilder
    :return: Configuração registrada ou None caso a operação falhe.
    :rtype: ExecutionPartidaConfigResponse | None
    """
    try:
        caso_uuid = UUID(str(caso_id))
        return self._caso_api.configure_execution_with_partida(caso_uuid, builder.build())
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Erro ao configurar execução com partida para o caso {caso_id}:\n\t{error_msg}",
            exc_info=False,
        )
        return None

create_caso(name)

Cria um novo caso vazio.

Parameters:

Name	Type	Description	Default
name	str	Nome do caso a ser criado.	required

Returns:

Type	Description
CaseResponse ou None	Resposta da API com os detalhes do caso criado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def create_caso(self, name: str) -> CaseResponse | None:
    """
    Cria um novo caso vazio.

    :param name: Nome do caso a ser criado.
    :type name: str
    :return: Resposta da API com os detalhes do caso criado ou None em caso de erro.
    :rtype: CaseResponse ou None
    """
    try:
        api_response = self._caso_api.create_empty_caso(name)
        return api_response
    except ApiException as e:
        error_msg = get_error_message(e)
        logger.error(
            f"Ocorreu o seguinte erro durante a criação do caso:\n\t {error_msg}",
            exc_info=False,
        )

create_caso_attach(caso_request)

Cria um novo caso associado a um host remoto.

Parameters:

Name	Type	Description	Default
caso_request	CaseRequest	Objeto contendo os detalhes do caso a ser criado.	required

Returns:

Type	Description
CaseResponse ou None	Resposta da API com os detalhes do caso criado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def create_caso_attach(
    self, caso_request: CaseRequest
) -> CaseResponse | None :
    """
    Cria um novo caso associado a um host remoto.

    :param caso_request: Objeto contendo os detalhes do caso a ser criado.
    :type caso_request: CaseRequest
    :return: Resposta da API com os detalhes do caso criado ou None em caso de erro.
    :rtype: CaseResponse ou None
    """
    try:
        api_response = self._caso_api.create_caso(caso_request)
        return api_response
    except ApiException as e:
        error_msg = get_error_message(e)
        logger.error(
            f"Ocorreu o seguinte erro durante a criação do caso:\n\t {error_msg}",
            exc_info=False,
        )

delete_caso(caso_id)

Remove um caso existente.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso a ser removido.	required

Returns:

Type	Description
bool	True se a remoção for bem-sucedida, False caso contrário.

Source code in pldpro_sdk/core/proxies/casos.py

def delete_caso(self, caso_id: UUID | str) -> bool:
    """
    Remove um caso existente.

    :param caso_id: Identificador único do caso a ser removido.
    :type caso_id: UUID ou str
    :return: True se a remoção for bem-sucedida, False caso contrário.
    :rtype: bool
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        self._caso_api.delete_caso_without_preload_content(caso_id)
        return True
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao remover o caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )
    return False

delete_caso_files(caso_id, files)

Remove arquivos de um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
files	Union[List[Path], List[str]]	Lista de arquivos a serem removidos.	required

Returns:

Type	Description
bool	True se a remoção dos arquivos for bem-sucedida, False caso contrário.

Source code in pldpro_sdk/core/proxies/casos.py

def delete_caso_files(
    self, caso_id: Union[UUID, str], files: Union[List[Path], List[str]]
) -> bool:
    """
    Remove arquivos de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param files: Lista de arquivos a serem removidos.
    :type files: Union[List[Path], List[str]]
    :return: True se a remoção dos arquivos for bem-sucedida, False caso contrário.
    :rtype: bool
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        file_paths = [str(Path(f)) for f in files]
        self._caso_api.delete_files(caso_id, file_paths)
        return True
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao remover os arquivos do caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )
        return False

download_caso_all(caso_id, save_path='')

Faz o download de todos os arquivos de um caso como um arquivo zip.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
save_path	Union[Path, str]	Caminho onde o arquivo zip deve ser salvo.	''

Returns:

Type	Description
str	Caminho completo do arquivo zip salvo.

Source code in pldpro_sdk/core/proxies/casos.py

def download_caso_all(
    self, caso_id: Union[UUID, str], save_path: Union[Path, str] = ""
) -> str:
    """
    Faz o download de todos os arquivos de um caso como um arquivo zip.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param save_path: Caminho onde o arquivo zip deve ser salvo.
    :type save_path: Union[Path, str]
    :return: Caminho completo do arquivo zip salvo.
    :rtype: str
    """
    filename = f"caso_{caso_id}_all_files.zip"
    return download(self._caso_api.download_inputs, caso_id, filename, save_path)

download_caso_inputs(caso_id, save_path='')

Faz o download dos arquivos de entrada de um caso como um arquivo zip.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
save_path	Union[Path, str]	Caminho onde o arquivo zip deve ser salvo.	''

Returns:

Type	Description
str	Caminho completo do arquivo zip salvo.

Source code in pldpro_sdk/core/proxies/casos.py

def download_caso_inputs(
    self, caso_id: Union[UUID, str], save_path: Union[Path, str] = ""
) -> str:
    """
    Faz o download dos arquivos de entrada de um caso como um arquivo zip.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param save_path: Caminho onde o arquivo zip deve ser salvo.
    :type save_path: Union[Path, str]
    :return: Caminho completo do arquivo zip salvo.
    :rtype: str
    """
    filename = f"caso_{caso_id}_inputs.zip"
    return download(
        self._caso_api.download_inputs_file, caso_id, filename, save_path
    )

download_input_file(caso_id, filename, save_path='')

Faz o download de um arquivo específico de entrada de um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
filename	Union[Path, str]	Nome do arquivo a ser baixado.	required
save_path	Union[Path, str]	Caminho onde o arquivo deve ser salvo.	''

Returns:

Type	Description
str	Caminho completo do arquivo salvo.

Source code in pldpro_sdk/core/proxies/casos.py

def download_input_file(
    self,
    caso_id: Union[UUID, str],
    filename: Union[Path, str],
    save_path: Union[Path, str] = "",
) -> str:
    """
    Faz o download de um arquivo específico de entrada de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param filename: Nome do arquivo a ser baixado.
    :type filename: Union[Path, str]
    :param save_path: Caminho onde o arquivo deve ser salvo.
    :type save_path: Union[Path, str]
    :return: Caminho completo do arquivo salvo.
    :rtype: str
    """
    return download(
        self._caso_api.download_specific_file,
        caso_id,
        filename,
        save_path,
        specific_file=True,
        as_zip=True,
    )

escrever_cortes_path(caso_id, new_path)

Escreve o caminho dos cortes no arquivo de entrada do caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
new_path	str	Novo caminho dos arquivos de cortes.	required

Returns:

Type	Description
str	Caminho dos arquivos de cortes.

Source code in pldpro_sdk/core/proxies/casos.py

def escrever_cortes_path(self, caso_id: Union[UUID, str], new_path: str) -> str:
    """
    Escreve o caminho dos cortes no arquivo de entrada do caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param new_path: Novo caminho dos arquivos de cortes.
    :type new_path: str
    :return: Caminho dos arquivos de cortes.
    :rtype: str
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        api_response = self._caso_api.escrever_cortes_path(
            caso_id,
            new_path,
            _content_type="text/plain",
            _headers={"Accept": "text/plain"},
        )

        return api_response
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao obter o caminho dos cortes do caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )
        return ""

get_caso(caso_id)

Obtém informações detalhadas de um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required

Returns:

Type	Description
CaseResponse ou None	Resposta da API com os detalhes do caso ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def get_caso(self, caso_id:UUID | str) -> CaseResponse | None:
    """
    Obtém informações detalhadas de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :return: Resposta da API com os detalhes do caso ou None em caso de erro.
    :rtype: CaseResponse ou None
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        api_response = self._caso_api.get_caso(caso_id)
        return api_response
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao obter o caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )

get_status_caso(caso_id)

Obtém o status atual de um caso.

Parameters:

Name	Type	Description	Default
caso_id	UUID | str	Identificador único do caso.	required

Returns:

Type	Description
str | None	Status do caso ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def get_status_caso(self, caso_id: UUID | str) -> str | None:
    """
    Obtém o status atual de um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: UUID ou str
    :return: Status do caso ou None em caso de erro.
    :rtype: str | None
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        api_response = self._caso_api.status_caso(caso_id)
        return api_response
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao obter o status do caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )

list_caso_files(caso_id)

Lista os arquivos associados a um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required

Returns:

Type	Description
FileNode | None	Resposta da API com a lista de arquivos do caso ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def list_caso_files(self, caso_id: Union[UUID, str]) -> FileNode | None:
    """
    Lista os arquivos associados a um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :return: Resposta da API com a lista de arquivos do caso ou None em caso de erro.
    :rtype: FileNode | None
    """
    try:
        if isinstance(caso_id, str):
            caso_id = UUID(caso_id)

        api_response = self._caso_api.get_casos_files(caso_id)
        return api_response
    except (ApiException, ValueError) as e:
        error_msg = get_error_message(e) if isinstance(e, ApiException) else str(e)
        logger.error(
            f"Ocorreu o seguinte erro ao listar os arquivos do caso {caso_id}:\n\t {error_msg}",
            exc_info=False,
        )

list_casos(nome=None, created_at=None, page=None, size=None, sort=None)

Lista ou e normaliza a pagina retornada pela API.

Parameters:

Name	Type	Description	Default
nome	Optional[str]	Nome do caso para filtro opcional.	None
created_at	Optional[datetime]	Data de criação para filtro opcional.	None
page	Optional[int]	Número da página para paginação.	None
size	Optional[int]	Tamanho da página para paginação.	None
sort	Optional[str]	Critério de ordenação.	None

Returns:

Type	Description
CasePage	Resposta paginada contendo os casos filtrados.

Source code in pldpro_sdk/core/proxies/casos.py

def list_casos(
    self,
    nome: Optional[str] = None,
    created_at: Optional[datetime] = None,
    page: Optional[int] = None,
    size: Optional[int] = None,
    sort: Optional[str] = None,
) -> CasePage:
    """
    Lista ou e normaliza a pagina retornada pela API.

    :param nome: Nome do caso para filtro opcional.
    :type nome: Optional[str]
    :param created_at: Data de criação para filtro opcional.
    :type created_at: Optional[datetime]
    :param page: Número da página para paginação.
    :type page: Optional[int]
    :param size: Tamanho da página para paginação.
    :type size: Optional[int]
    :param sort: Critério de ordenação.
    :type sort: Optional[str]
    :return: Resposta paginada contendo os casos filtrados.
    :rtype: CasePage
    """
    try:
        api_response = self._caso_api.filter_casos(
            nome=nome,
            created_from=created_at,
            page=page,
            size=size,
            sort=[sort] if sort else None,
        )
        return CasePage.from_api_response(api_response)
    except ApiException as error:
        logger.error(
            "Não foi possivel listar os casos: %s",
            get_error_message(error),
        )
        return CasePage(elements=[])

upload_cenarios_dessem(caso_id, files, save_zip=False)

Faz o upload de arquivos de cenários do DESSEM para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
files	Union[List[Path], List[str], Path, str]	Arquivo(s) de cenários do DESSEM a ser(em) enviado(s).	required
save_zip	bool	Indica se o arquivo zip gerado em memória deve ser salvo localmente.	False

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes dos arquivos de cenários do DESSEM enviados ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_cenarios_dessem(
    self,
    caso_id: Union[UUID, str],
    files: Union[List[Path], List[str], Path, str],
    save_zip: bool = False,
) -> FileUploadResponse | None:
    """
    Faz o upload de arquivos de cenários do DESSEM para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param files: Arquivo(s) de cenários do DESSEM a ser(em) enviado(s).
    :type files: Union[List[Path], List[str], Path, str]
    :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
    :type save_zip: bool
    :return: Resposta da API com os detalhes dos arquivos de cenários do DESSEM enviados ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    # NOTE: O metodo upload espera uma lista de arquivos, mesmo que seja um único arquivo
    if isinstance(files, str) or isinstance(files, Path):
        files = [files]  # type: ignore

    return upload(
        self._caso_api.upload_cenarios_dessem,
        "de arquivo(s) de cenários do DESSEM",
        caso_id,
        files,
        should_zip=False,
        save_zip=save_zip,
    )

upload_deck_partida(caso_id, file_path, partida_config, save_zip=False)

Faz o upload de um arquivo de deck de partida para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
file_path	Union[Path, str]	Caminho do arquivo de deck de partida a ser enviado.	required
partida_config	PartidaConfig | Mapping[str, object] | str	Configuração da partida associada ao deck.	required
save_zip	bool	Indica se o arquivo zip gerado em memória deve ser salvo localmente.	False

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_deck_partida(
    self,
    caso_id: Union[UUID, str],
    file_path: Union[Path, str],
    partida_config: PartidaConfig | Mapping[str, object] | str,
    save_zip=False,
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo de deck de partida para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param file_path: Caminho do arquivo de deck de partida a ser enviado.
    :type file_path: Union[Path, str]
    :param partida_config: Configuração da partida associada ao deck.
    :type partida_config: PartidaConfig
    :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
    :type save_zip: bool
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """

    return upload(
        method=self._caso_api.upload_deck_partida,
        error_context="de arquivo de deck de partida",
        caso_id=caso_id,
        files=file_path,
        save_zip=save_zip,
        partida_config=_to_json_part(partida_config),
    )

upload_deck_partida_semanal(caso_id, file_path, partida_semanal_config, save_zip=False)

Faz o upload de um arquivo de deck de partida semanal para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
file_path	Union[Path, str]	Caminho do arquivo de deck de partida semanal a ser enviado.	required
partida_semanal_config	PartidaSemanalConfig | Mapping[str, object] | str	Configuração da partida semanal associada ao deck.	required
save_zip	bool	Indica se o arquivo zip gerado em memória deve ser salvo	False

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_deck_partida_semanal(
    self,
    caso_id: Union[UUID, str],
    file_path: Union[Path, str],
    partida_semanal_config: PartidaSemanalConfig | Mapping[str, object] | str,
    save_zip=False,
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo de deck de partida semanal para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param file_path: Caminho do arquivo de deck de partida semanal a ser enviado.
    :type file_path: Union[Path, str]
    :param partida_semanal_config: Configuração da partida semanal associada ao deck.
    :type partida_semanal_config: PartidaSemanalConfig
    :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo
    :type save_zip: bool
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """

    return upload(
        method=self._caso_api.upload_deck_partida_semanal,
        error_context="de arquivo de deck de partida semanal",
        caso_id=caso_id,
        files=file_path,
        save_zip=save_zip,
        partida_semanal_config=_to_json_part(partida_semanal_config),
    )

upload_ena_ree(caso_id, filename, data_prevs)

Faz o upload de um arquivo ENA-REE para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
filename	Union[Path, str]	Caminho do arquivo ENA-REE a ser enviado.	required
data_prevs	Union[datetime, str]	Data de previsão utilizada na configuração do arquivo. Formato obrigatório: YYYY-MM-DD	required

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_ena_ree(
    self,
    caso_id: Union[UUID, str],
    filename: Union[Path, str],
    data_prevs: Union[datetime, str],
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo ENA-REE para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param filename: Caminho do arquivo ENA-REE a ser enviado.
    :type filename: Union[Path, str]
    :param data_prevs: Data de previsão utilizada na configuração do arquivo. Formato obrigatório: YYYY-MM-DD
    :type data_prevs: Union[datetime, str]
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    if isinstance(data_prevs, datetime):
        data_prevs = data_prevs.strftime("%Y-%m-%d")
    elif isinstance(data_prevs, str):
        try:
            datetime.strptime(data_prevs, "%Y-%m-%d")
        except ValueError:
            logger.error(
                "O formato da data_prevs está incorreto. Use o formato YYYY-MM-DD.",
                exc_info=False,
            )
            return None

    ret = upload(
        self._caso_api.upload_ena_ree,
        "de arquivo ENA-REE",
        caso_id,
        filename,
        use_full_path=False,
        data_prevs=data_prevs,
        should_zip=False
    )
    return ret

upload_entrada(caso_id, filename)

Faz o upload de um arquivo de entrada para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
filename	Union[Path, str]	Caminho do arquivo a ser enviado.	required

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_entrada(
    self, caso_id: Union[UUID, str], filename: Union[Path, str]
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo de entrada para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param filename: Caminho do arquivo a ser enviado.
    :type filename: Union[Path, str]
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    ret = upload(
        self._caso_api.upload_file_entrada,
        "de arquivo de entrada",
        caso_id,
        filename,
        use_full_path=False,
        should_zip=False
    )
    return ret

upload_files(caso_id, files, save_zip=False)

Faz o upload de arquivos ou diretórios para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
files	Union[List[Path], List[str], Path, str]	Arquivo(s) ou diretório a ser enviado.	required
save_zip	bool	Indica se o arquivo zip gerado em memória deve ser salvo localmente.	False

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes dos arquivos enviados ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_files(
    self,
    caso_id: Union[UUID, str],
    files: Union[List[Path], List[str], Path, str],
    save_zip: bool = False,
) -> FileUploadResponse | None:
    """
    Faz o upload de arquivos ou diretórios para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param files: Arquivo(s) ou diretório a ser enviado.
    :type files: Union[List[Path], List[str], Path, str]
    :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
    :type save_zip: bool
    :return: Resposta da API com os detalhes dos arquivos enviados ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    return upload(
        self._caso_api.upload_files,
        "de arquivo(s) do caso",
        caso_id,
        files,
        should_zip=False,
        save_zip=save_zip,
    )

upload_prevs(caso_id, files, encadeamento=None, save_zip=False)

Faz o upload de arquivos de previsões para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
files	Union[List[Path], List[str], Path, str]	Arquivo(s) de previsões a ser(em) enviado(s).	required
encadeamento	TipoEncadeamentoSemanal | str | None	Encadeamento semanal do caso. Prefira TipoEncadeamentoSemanal para novos usos.	None
save_zip	bool	Indica se o arquivo zip gerado em memória deve ser salvo localmente.	False

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes dos arquivos de previsões enviados ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_prevs(
    self,
    caso_id: Union[UUID, str],
    files: Union[List[Path], List[str], Path, str],
    encadeamento: TipoEncadeamentoSemanal | str | None = None,
    save_zip: bool = False,
) -> FileUploadResponse | None:
    """
    Faz o upload de arquivos de previsões para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param files: Arquivo(s) de previsões a ser(em) enviado(s).
    :type files: Union[List[Path], List[str], Path, str]
    :param encadeamento: Encadeamento semanal do caso. Prefira
                          TipoEncadeamentoSemanal para novos usos.
    :param save_zip: Indica se o arquivo zip gerado em memória deve ser salvo localmente.
    :type save_zip: bool
    :return: Resposta da API com os detalhes dos arquivos de previsões enviados ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    return upload(
        self._caso_api.upload_prevs_files,
        "de arquivo(s) de previsões",
        caso_id,
        files,
        save_zip=save_zip,
        should_zip=False,
        encadeamento=enum_value(encadeamento),
    )

upload_regras_ana(caso_id, filename, apaga_regras='N')

Faz o upload de um arquivo de regras ANA para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
filename	Union[Path, str]	Caminho do arquivo de regras ANA a ser enviado.	required
apaga_regras	Optional[str]	Indica se as regras existentes devem ser apagadas antes do upload.	'N'

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_regras_ana(
    self,
    caso_id: Union[UUID, str],
    filename: Union[Path, str],
    apaga_regras: Optional[str] = "N",
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo de regras ANA para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param filename: Caminho do arquivo de regras ANA a ser enviado.
    :type filename: Union[Path, str]
    :param apaga_regras: Indica se as regras existentes devem ser apagadas antes do upload.
    :type apaga_regras: Optional[str]
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    ret = upload(
        self._caso_api.upload_regras_ana,
        "de arquivo de regras ANA",
        caso_id,
        filename,
        use_full_path=False,
        apaga_regras=enum_value(apaga_regras),
    )
    return ret

upload_volume_final_decomp(caso_id, filename, tipo_alteracao)

Faz o upload de um arquivo de volume final DECOMP para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
filename	Union[Path, str]	Caminho do arquivo de volume final DECOMP a ser enviado.	required
tipo_alteracao	str	Tipo de alteração para o upload do arquivo.	required

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_volume_final_decomp(
    self,
    caso_id: Union[UUID, str],
    filename: Union[Path, str],
    tipo_alteracao: str,
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo de volume final DECOMP para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param filename: Caminho do arquivo de volume final DECOMP a ser enviado.
    :type filename: Union[Path, str]
    :param tipo_alteracao: Tipo de alteração para o upload do arquivo.
    :type tipo_alteracao: str
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    ret = upload(
        self._caso_api.upload_volume_final_decomp,
        "de arquivo de volume final DECOMP",
        caso_id,
        filename,
        use_full_path=False,
        tipo_alteracao=enum_value(tipo_alteracao),
        should_zip=False
    )
    return ret

upload_volume_partida_decomp(caso_id, filename, data_volume_partida)

Faz o upload de um arquivo de volume parcial DECOMP para um caso.

Parameters:

Name	Type	Description	Default
caso_id	Union[UUID, str]	Identificador único do caso.	required
filename	Union[Path, str]	Caminho do arquivo de volume parcial DECOMP a ser enviado.	required
data_volume_partida	Union[datetime, str]	Data do volume de partida utilizada na configuração do arquivo. Formato obrigatório: YYYY-MM-DD	required

Returns:

Type	Description
FileUploadResponse | None	Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.

Source code in pldpro_sdk/core/proxies/casos.py

def upload_volume_partida_decomp(
    self,
    caso_id: Union[UUID, str],
    filename: Union[Path, str],
    data_volume_partida: Union[datetime, str],
) -> FileUploadResponse | None:
    """
    Faz o upload de um arquivo de volume parcial DECOMP para um caso.

    :param caso_id: Identificador único do caso.
    :type caso_id: Union[UUID, str]
    :param filename: Caminho do arquivo de volume parcial DECOMP a ser enviado.
    :type filename: Union[Path, str]
    :param data_volume_partida: Data do volume de partida utilizada na configuração do arquivo. Formato obrigatório: YYYY-MM-DD
    :type data_volume_partida: Union[datetime, str]
    :return: Resposta da API com os detalhes do arquivo enviado ou None em caso de erro.
    :rtype: FileUploadResponse | None
    """
    if isinstance(data_volume_partida, datetime):
        data_volume_partida = data_volume_partida.strftime("%Y-%m-%d")
    elif isinstance(data_volume_partida, str):
        try:
            datetime.strptime(data_volume_partida, "%Y-%m-%d")
        except ValueError:
            logger.error(
                "O formato da data_volume_partida está incorreto. Use o formato YYYY-MM-DD.",
                exc_info=False,
            )
            return None

    ret = upload(
        self._caso_api.upload_volume_partida_decomp,
        "de arquivo de volume parcial DECOMP",
        caso_id,
        filename,
        use_full_path=False,
        data_volume_partida=data_volume_partida,
        should_zip=False
    )
    return ret