psr-factory 4.1.0b3__py3-none-win_amd64.whl → 4.1.0b5__py3-none-win_amd64.whl

psr/cloud/cloud.py

@@ -68,12 +68,8 @@ def _check_for_errors(
 
 
 def _hide_password(params: str) -> str:
-    # Define a expressão regular para encontrar o parâmetro senha com atributos adicionais
     pattern = r'(<Parametro nome="senha"[^>]*>)(.*?)(</Parametro>)'
-
-    # Substitui o conteúdo da senha por ********
     result = re.sub(pattern, r"\1********\3", params)
-
     return result
 
 
@@ -328,7 +324,7 @@ class Client:
             _hide_password(xml_content)
             raise CloudInputError(
                 f"Invalid XML content.\n"
-                f"Contact PSR support with following data:\n\n{xml_content}\n\nsuporte@psr-inc.com"
+                f"Contact PSR support at psrcloud@psr-inc.com with following data:\n\n{xml_content}\n\n"
             )
 
     def _get_clusters_by_user(self) -> list:
@@ -631,7 +627,7 @@ class Client:
             xml_str = _xml_to_str(xml)
             raise CloudError(
                 f"Case id not found on returned XML response.\n"
-                f"Contact PSR support with following data:\n\n{xml_str}\n\nsuporte@psr-inc.com"
+                f"Contact PSR support at psrcloud@psr-inc.com with following data:\n\n{xml_str}\n\n"
             )
 
         case_id = int(id_parameter.text)
@@ -679,7 +675,7 @@ class Client:
                 xml_str = _xml_to_str(xml)
                 raise CloudError(
                     f"Status not found on returned XML response.\n"
-                    f"Contact PSR support with following data:\n\n{xml_str}\n\nsuporte@psr-inc.com"
+                    f"Contact PSR support at psrcloud@psr-inc.com with following data:\n\n{xml_str}\n\n"
                 )
             try:
                 status = ExecutionStatus(int(parameter_status.text))
@@ -687,12 +683,35 @@ class Client:
                 xml_str = _xml_to_str(xml)
                 raise CloudError(
                     f"Unrecognized status on returned XML response.\n"
-                    f"Contact PSR support with following data:\n\n{xml_str}\n\nsuporte@psr-inc.com"
+                    f"Contact PSR support at psrcloud@psr-inc.com with following data:\n\n{xml_str}\n\n"
                 )
 
             self._logger.info(f"Status: {STATUS_MAP_TEXT[status]}")
             return status, STATUS_MAP_TEXT[status]
 
+    def list_download_files(self, case_id: int) -> List[str]:
+        xml_files = self._make_soap_request(
+            "prepararListaArquivosRemotaDownload",
+            "listaArquivoRemota",
+            additional_arguments={
+                "cluster": self.cluster["name"],
+                "filtro": "(.*)",
+                "diretorioRemoto": str(case_id),
+            },
+        )
+
+        files = []
+
+        for file in xml_files.findall("Arquivo"):
+            file_info = {
+                "name": file.attrib.get("nome"),
+                "filesize": file.attrib.get("filesize"),
+                "filedate": file.attrib.get("filedate"),
+            }
+            files.append(file_info)
+
+        return files
+
     def download_results(
         self,
         case_id: int,
@@ -816,7 +835,9 @@ class Client:
             initial_date_iso = since.strftime("%Y-%m-%d %H:%M:%S")
 
         xml = self._make_soap_request(
-            "listarFila", "dados", adition_arguments={"dataInicial": initial_date_iso}
+            "listarFila",
+            "dados",
+            additional_arguments={"dataInicial": initial_date_iso},
         )
 
         return self._cases_from_xml(xml)
@@ -830,7 +851,9 @@ class Client:
     def get_cases(self, case_ids: List[int]) -> List["Case"]:
         case_ids_str = ",".join(map(str, case_ids))
         xml = self._make_soap_request(
-            "listarFila", "dados", adition_arguments={"listaRepositorio": case_ids_str}
+            "listarFila",
+            "dados",
+            additional_arguments={"listaRepositorio": case_ids_str},
         )
         return self._cases_from_xml(xml)
 
@@ -851,18 +874,29 @@ class Client:
         budgets.sort()
         return budgets
 
-    def _make_soap_request(self, service: str, nome: str, **kwargs) -> ET.Element:
+    def _make_soap_request(self, service: str, name: str = "", **kwargs) -> ET.Element:
         portal_ws = zeep.Client(self.cluster["url"] + "?WSDL")
         section = str(id(self))
         password_md5 = _md5sum(self.username + self.__password + section).upper()
-        addition_arguments = kwargs.get("adition_arguments", "")
+        password_md5 = (
+            password_md5
+            if self.cluster["name"] == "PSR-US"
+            or self.cluster["name"] == "PSR-HOTFIX"
+            or self.cluster["name"] == "PSR-US_OHIO"
+            else self.__password.upper()
+        )
+        additional_arguments = kwargs.get("additional_arguments", None)
         parameters = {
             "sessao_id": section,
-            "tipo_autenticacao": "portal",
+            "tipo_autenticacao": "portal"
+            if self.cluster["name"] == "PSR-US"
+            or self.cluster["name"] == "PSR-HOTFIX"
+            or self.cluster["name"] == "PSR-US_OHIO"
+            else "bcrypt",
             "idioma": "3",
         }
-        if addition_arguments:
-            parameters.update(addition_arguments)
+        if additional_arguments:
+            parameters.update(additional_arguments)
 
         # FIXME make additional arguments work as a dictionary to work with this code
         xml_input = create_case_xml(parameters)
@@ -871,22 +905,26 @@ class Client:
             xml_output_str = portal_ws.service.despacharServico(
                 service, self.username, password_md5, xml_input
             )
-        except zeep.exceptions.Fault:
+        except zeep.exceptions.Fault as e:
+            # Log the full exception details
+            self._logger.error(f"Zeep Fault: {str(e)}")
             raise CloudError(
-                "Failed to connect to PSR Cloud service. Contact PSR support: suporte@psr-inc.com"
+                "Failed to connect to PSR Cloud service. Contact PSR support: psrcloud@psr-inc.com"
             )
-
         # Remove control characters - this is a thing
         xml_output_str = xml_output_str.replace("&amp;#x1F;", "")
 
         xml_output = ET.fromstring(xml_output_str)
-        xml_output = next(
-            (
-                ET.fromstring(child.text)
-                for child in xml_output
-                if child.attrib.get("nome") == nome
-            )
-        )
+
+        if name:
+            for child in xml_output:
+                if child.attrib.get("nome") == name:
+                    xml_output = ET.fromstring(child.text)
+                    break
+            else:
+                raise ValueError(
+                    f"Invalid XML response from PSR Cloud: {xml_output_str}. Please contact PSR support at psrcloud@psr-inc.com"
+                )
         return xml_output
 
     def _get_cloud_versions_xml(self) -> ET.Element:

psr/cloud/version.py

@@ -2,4 +2,4 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "0.3.0"
+__version__ = "0.3.3"

psr/factory/__init__.py

@@ -2,6 +2,6 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "4.1.0b3"
+__version__ = "4.1.0b5"
 
 from .api import *

psr/factory/api.py

@@ -257,6 +257,23 @@ def _get_context(models_or_context: Union[str, list, dict, "Context", None],
     value.set(context)
     return value
 
+def _get_arg_object(arg: Union[dict, "Value", "DataObject", None]) -> "Value":
+    if isinstance(arg, dict):
+        value = Value()
+        value.set(arg)
+        return value
+    elif isinstance(arg, Value):
+        return arg
+    elif isinstance(arg, DataObject):
+        value = Value()
+        value.set(arg)
+        return value
+    elif arg is None:
+        return Value()
+    else:
+        raise TypeError("Unexpected type for argument.")
+
+
 
 class _BaseObject:
     def __init__(self):
@@ -545,6 +562,7 @@ class ValueDict(_BaseObject):
 class Value(_BaseObject):
     def __init__(self):
         super().__init__()
+        _check_loaded()
         self._hdr = factorylib.lib.psrd_new_value()
 
     def __del__(self):
@@ -1270,36 +1288,51 @@ class Study(_BaseObject):
 
     @staticmethod
     def load(study_path: Union[str, pathlib.Path], profile_or_context: Union[str, Context, None],
-             options: Optional[DataObject] = None):
+             settings_only: bool = False,
+             options: Optional[Union[dict, "Value", "DataObject"]] = None):
         if not isinstance(options, (DataObject, type(None))):
             raise TypeError("options must be a DataObject or None.")
+        _check_initialized()
         study_path = str(study_path)
         context = _get_context(profile_or_context, None)
         err = Error()
-        options_handler = options.handler() if options is not None else None
+        options_value = _get_arg_object(options)
         study = Study()
-        study._hdr = factorylib.lib.psrd_study_load(_c_str(study_path),
-                                                    _bytes(study_path),
-                                                    options_handler,
-                                                    context.handler(),
-                                                    err.handler())
+        if not settings_only:
+            load_fn = factorylib.lib.psrd_study_load
+        else:
+            load_fn = factorylib.lib.psrd_study_load_settings
+        study._hdr = load_fn(_c_str(study_path), _bytes(study_path),
+                             options_value.handler(), context.handler(),
+                             err.handler())
         if err.code != 0:
             raise FactoryException(err.what)
         return study
 
-    def save(self, output_path: Union[str, pathlib.Path], options: Optional[DataObject] = None):
-        if not isinstance(options, (DataObject, type(None))):
-            raise TypeError("options must be a DataObject or None.")
+    def save(self, output_path: Union[str, pathlib.Path],
+             options: Optional[Union[dict, Value, DataObject]] = None):
         output_path = str(output_path)
         _err = Error()
-        _options_handler = options.handler() if options is not None else None
-        factorylib.lib.psrd_study_save(self._hdr, _c_str(output_path),
-                                       _bytes(output_path),
-                                       _options_handler,
+        options_value = _get_arg_object(options)
+        factorylib.lib.psrd_study_save(self._hdr,
+                                       _c_str(output_path), _bytes(output_path),
+                                       options_value.handler(),
                                        _err.handler())
         if _err.code != 0:
             raise FactoryException(_err.what)
 
+    def save_settings(self, output_path: Union[str, pathlib.Path],
+             options: Optional[Union[dict, Value, DataObject]] = None):
+        output_path = str(output_path)
+        _err = Error()
+        options_value = _get_arg_object(options)
+        factorylib.lib.psrd_study_save_settings(self._hdr, _c_str(output_path),
+                                                _bytes(output_path),
+                                                options_value.handler(),
+                                                _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+
     @property
     def context(self) -> "Context":
         _check_initialized()
@@ -1377,6 +1410,16 @@ class Study(_BaseObject):
         if _err.code != 0:
             raise FactoryException(_err.what)
 
+    def get_all_objects(self) -> List[DataObject]:
+        object_list = ValueList(False)
+        error = Error()
+        ref = factorylib.lib.psrd_study_get_all_objects(self._hdr,
+                                                        error.handler())
+        if error.code != 0 or ref is None:
+            raise FactoryException(error.what)
+        object_list._hdr = ref
+        return object_list.to_list()
+
     def find(self, expression: str) -> List[DataObject]:
         object_list = ValueList(False)
         _err = Error()
@@ -1388,6 +1431,20 @@ class Study(_BaseObject):
         object_list._hdr = ref
         return object_list.to_list()
 
+    def find_by_name(self, type_name: str, name: str) -> List[DataObject]:
+        object_list = ValueList(False)
+        _err = Error()
+        if name.strip() == "":
+            name = "*"
+        expression = f"{type_name}.{name}"
+        ref = factorylib.lib.psrd_study_find(self._hdr,
+                                             _c_str(expression),
+                                             _err.handler())
+        if _err.code != 0 or ref is None:
+            raise FactoryException(_err.what)
+        object_list._hdr = ref
+        return object_list.to_list()
+
     def find_by_code(self, type_name: str, code: Optional[int] = None) -> List[DataObject]:
         if code is None:
             warnings.warn(DeprecationWarning("Starting from Factory 4.0.9 "
@@ -2091,16 +2148,16 @@ class DataFrame(_BaseObject):
             factorylib.lib.psrd_free_table(self._hdr)
 
     @staticmethod
-    def load_from_file(input_file: Union[str, pathlib.Path], options: Optional[DataObject] = None) -> "DataFrame":
+    def load_from_file(input_file: Union[str, pathlib.Path], options: Optional[Union[dict, Value, DataObject]] = None) -> "DataFrame":
         input_file = str(input_file)
         _check_initialized()
         _err = Error()
         table = DataFrame()
-        options_handler = options.handler() if options is not None else None
+        options_value = _get_arg_object(options)
         factorylib.lib.psrd_table_load(table.handler(),
                                        _c_str(input_file),
                                        _bytes(input_file),
-                                       options_handler,
+                                       options_value.handler(),
                                        _err.handler())
         if _err.code != 0:
             raise FactoryException(_err.what)
@@ -2119,13 +2176,13 @@ class DataFrame(_BaseObject):
             return df_builder.build_from_polars(dataframe_like)
         raise ImportError("Pandas or polars is not available. Please install pandas to use this feature.")
 
-    def save(self, output_file: Union[str, pathlib.Path], options: Optional[DataObject] = None):
+    def save(self, output_file: Union[str, pathlib.Path], options: Optional[Union[dict, Value, DataObject]] = None):
         output_file = str(output_file)
         _err = Error()
-        options_handler = options.handler() if options is not None else None
+        options_value = _get_arg_object(options)
         factorylib.lib.psrd_table_save(self._hdr, _c_str(output_file),
                                        _bytes(output_file),
-                                       options_handler,
+                                       options_value.handler(),
                                        _err.handler())
         if _err.code != 0:
             raise FactoryException(_err.what)
@@ -2235,7 +2292,15 @@ def create_study(*args, **kwargs) -> Study:
 def load_study(study_path: Union[str, pathlib.Path],
                profile_or_context: Union[str, Context, None] = None,
                options: Optional[DataObject] = None) -> Study:
-    return Study.load(study_path, profile_or_context, options)
+    settings_only = False
+    return Study.load(study_path, profile_or_context, settings_only, options)
+
+
+def load_study_settings(study_path: Union[str, pathlib.Path],
+               profile_or_context: Union[str, Context, None] = None,
+               options: Optional[DataObject] = None) -> Study:
+    settings_only = True
+    return Study.load(study_path, profile_or_context, settings_only, options)
 
 
 def create(class_name: str,