Corrige/Melhora PidProviderXML devido a um bug e uma melhoria packtools 4.16.11 (#1469)

* Corrigir extração de dados do XML para tolerar mudanças de versão do packtools

Adiciona fix_get_article_data() e fix_get_data_to_compare() como camadas de compatibilidade em torno de xml_with_pre.get_article_data() e xml_adapter.get_data_to_compare(), já que o formato retornado por esses métodos mudou entre versões do packtools (partial_body -> body_fragment; z_partial_body -> body_fragment_fingerprint).

fix_get_article_data() remove a chave legada 'partial_body' do dict retornado.
fix_get_data_to_compare() força a chave 'z_partial_body' a vir de xml_with_pre.body_fragment_fingerprint, independente do que get_data_to_compare() retornar.

Em QueryBuilderPidProviderXML:
- z_partial_body agora é lido diretamente de xml_adapter.xml_with_pre.z_partial_body (hash legado), não mais de xml_adapter.data.
- z_body (body_fingerprint, hash do corpo inteiro) deixou de ser usado — removido de __init__ e de partial_body_query.
- partial_body_query agora combina apenas z_partial_body (legado) e z_body_fragment (body_fragment_fingerprint), como set, caindo em isnull=True quando nenhum dos dois existe.
- validate_input_data passa a checar a chave 'body_fragment' (novo nome) em vez de 'partial_body'.

* Usar as funções de compatibilidade do packtools em PidProviderXML

Substitui as chamadas diretas a xml_with_pre.get_article_data() e xml_adapter.get_data_to_compare() por fix_get_article_data() e fix_get_data_to_compare(), garantindo que os dados usados em readable_data, no diff de conflito de pid v3 e nas comparações de registro fiquem normalizados entre versões do packtools.

Também corrige get_registered_versions() para usar body_fragment_fingerprint (novo fingerprint) em vez do atributo antigo z_partial_body diretamente no dict de readable_data.

* Realinhar testes de QueryBuilderPidProviderXML com o comportamento real do código

O arquivo de testes anterior descrevia um refactor que não estava implementado no código-fonte atual, fazendo 13 de 55 testes falharem. Principais ajustes:

- make_xml_adapter() passa a configurar z_partial_body diretamente em xml_with_pre (não mais em adapter.data), e usa 'body_fragment' como chave do dict de get_article_data(), incluindo uma chave 'partial_body' só para exercitar o pop feito por fix_get_article_data().
- Remove body_fingerprint (corpo inteiro) das comparações de partial_body_query e article_data_query, já que esse fingerprint não é mais usado.
- Adiciona testes cobrindo validate_input_data com a chave 'body_fragment' e o caso de branco.
- Ajusta CompareTests para refletir que compare() usa input_data.get(label) e não pula labels ausentes, incluindo o caso de ZeroDivisionError quando registered_items é vazio.

* Ajustar asserção de select_record para o novo formato de dados de comparação

get_best_match() agora recebe um dict de comparação que inclui a chave 'z_partial_body' (adicionada por fix_get_data_to_compare), então a asserção passa a usar ANY para esse valor em vez de comparar apenas por {'title': 'Foo'}.

* Documentar funções e atributos de query_params.py

Adiciona docstrings que faltavam (compare, compare_lists, compare_items, get_score, zero_to_none, fix_get_article_data) e corrige documentação desatualizada:

- __init__ de QueryBuilderPidProviderXML: o comentário ainda descrevia um atributo z_body/body_fingerprint (fingerprint do corpo INTEIRO do artigo) que não é mais atribuído no código atual; substituído por uma docstring listando os atributos realmente definidos (z_body_fragment, z_partial_body, adapter_data, xml_with_pre_data).
- partial_body_query: corrige a referência de onde vem o hash legado, que dizia vir de xml_adapter.z_partial_body mas na verdade é lido de xml_adapter.xml_with_pre.z_partial_body (via self.z_partial_body).
- validate_input_data, pkg_name_list, article_data_query e get_article_data_query passam a ter docstrings explicando o comportamento.
- Remove comentários de linha redundantes em pkg_name_list e identifier_queries que só repetiam o que o código já deixa claro, agora que a lógica está descrita na docstring do método.

* Corrige o acesso a z_partial_body

* Ajusta comparação de dados para maior precisão no pareamento de XML

- Renomeia a chave 'z_partial_body' para 'body_fragment_fingerprint' em fix_get_data_to_compare, alinhando o nome ao valor efetivamente comparado.
- fix_get_article_data passa a priorizar xml_with_pre.readable_data quando disponível, caindo para get_article_data(max_length=300) como fallback.
- compare_items passa a incluir 'input_data' na resposta quando o score não é 1, permitindo rastrear o valor comparado em caso de divergência.

* Aprimora rastreabilidade e robustez do processo de pareamento de PidProviderXML

- Substitui os campos 'created'/'updated'/'record_status' fixos por uma property record_status, que calcula o estado do registro ('created' ou 'updated') com base na diferença de tempo entre criação e atualização.
- Adiciona 'ppx_id' ao dicionário de dados retornado.
- get_readable_data remove 'partial_body' do dado armazenado antes de retorná-lo.
- data_to_compare passa a incluir article_titles e body_fragment apenas quando presentes, e usa body_fragment_fingerprint no lugar de z_partial_body.
- get_best_match passa a usar um limiar de aceitação dinâmico (min_rate), reduzido para 0.49 quando há poucos dados disponíveis para comparação, e retorna também a resposta detalhada de cada comparação junto ao dado do candidato.
- Evita processar atualização quando o registro correspondente não possui readable_data.
- is_equal_to é considerado falso quando o registro não possui readable_data, evitando falso positivo de igualdade.
- Melhora a mensagem de erro de PidProviderXMLPidV3ConflictError, tornando-a mais informativa sobre o resultado do pareamento.

* Adiciona testes de configuração do Pid Provider

Cobre PidProviderSetting (ex.: record_all_registration_events e
demais opções configuráveis via Wagtail Admin). Mensagem gerada a
partir do nome do arquivo — ajustar detalhes de implementação após
revisão do conteúdo.

* Adiciona testes de XMLVersion

Cobre o modelo XMLVersion (versionamento de XML associado a
PidProviderXML). Mensagem gerada a partir do nome do arquivo —
ajustar detalhes de implementação após revisão do conteúdo.

* Adiciona testes de URL de XML no Pid Provider

Cobre geração/resolução de URLs associadas ao XML registrado.
Mensagem gerada a partir do nome do arquivo — ajustar detalhes de
implementação após revisão do conteúdo.

* Adiciona testes de PIDs alternativos (other_pid)

Cobre o relacionamento OtherPid/InlinePanel 'Other PID' em
PidProviderXML. Mensagem gerada a partir do nome do arquivo — ajustar
detalhes de implementação após revisão do conteúdo.

* Adiciona testes de correção do pid v2

Cobre lógica de fix/normalização do PID v2 (ex.: CollectionPidV2 ou
rotina de correção equivalente). Mensagem gerada a partir do nome do
arquivo — ajustar detalhes de implementação após revisão do
conteúdo.

* Adiciona testes de funções auxiliares do PidProviderXML

Cobre funções utilitárias usadas por PidProviderXML (possivelmente
os wrappers fix_get_article_data/fix_get_data_to_compare ou
equivalentes). Mensagem gerada a partir do nome do arquivo — ajustar
detalhes de implementação após revisão do conteúdo.

* Adiciona testes de manutenção de registros PidProviderXML

Cobre rotinas de manutenção/limpeza sobre registros existentes de
PidProviderXML. Mensagem gerada a partir do nome do arquivo — ajustar
detalhes de implementação após revisão do conteúdo.

* Adiciona testes de auditoria de registro (PidProviderXMLRegistration)

Cobre o modelo PidProviderXMLRegistration e a lógica de quando
gravar eventos de auditoria (erro, ambiguidade ou
record_all_registration_events). Mensagem gerada a partir do nome do
arquivo — ajustar detalhes de implementação após revisão do
conteúdo.

* Atualiza testes de query_params para tratamento de labels ausentes e z_partial_body

Ajusta make_xml_adapter() para configurar explicitamente
adapter.z_partial_body (agora lido como atributo direto pelo
QueryBuilderPidProviderXML, não mais via xml_adapter.data.get()),
evitando MagicMock não configurado no teste.

CompareItemsTests: passa a esperar também a chave 'input_data' no
retorno de compare_items() quando o score é != 1, além de
'registered'.

CompareTests, reescrito para refletir que compare() NÃO pula mais
labels ausentes em input_data (usa .get(label), tratando ausência
como None):
- test_missing_input_key_is_treated_as_none_not_skipped (renomeado de
  ...is_skipped_not_treated_as_none): label ausente com valor
  registrado falsy agora ENTRA em items com score 1, em vez de ser
  descartado.
- test_missing_input_key_with_truthy_registered_value_lowers_score
  (novo): label ausente com valor registrado truthy cai no ramo
  how_similar (score < 1).
- test_empty_registered_items_raises_zero_division_error (renomeado
  de test_all_labels_missing_raises_zero_division_error): único
  cenário que ainda levanta ZeroDivisionError é registered_items
  vazio, não mais 'todos os labels ausentes em input_data'.

* Atualiza testes de get_best_match para novo formato de item com data/response

get_best_match() passou a envolver cada candidato em
{'data': ..., 'response': ...} nas listas 'matched'/'unmatched', em
vez do dict .data cru. Ajusta as asserções de
result['unmatched'][0]['id'] e result['matched'][N]['id'] para
result[...][N]['data']['id'] nos quatro testes afetados.

* Atualiza testes de select_record para uso de fix_get_data_to_compare

select_record() não usa mais xml_adapter.get_data_to_compare() puro:
passa a chamar fix_get_data_to_compare(xml_adapter), que acrescenta a
chave 'body_fragment_fingerprint' (lida de
xml_adapter.xml_with_pre.body_fragment_fingerprint) ao dict retornado
por get_data_to_compare().

_make_xml_adapter() passa a aceitar body_fragment_fingerprint e
configurá-lo no mock, para não ficar um MagicMock não configurado.

test_select_record_passes_candidates_and_comparison_data_to_get_best_match
atualizado para esperar que get_best_match seja chamado com o dict
já acrescido de 'body_fragment_fingerprint', não mais o retorno cru
de get_data_to_compare().

* Atualiza testes de register() para a migração readable_data

Alinha os testes à mudança de register(), que agora faz
input_data.update(xml_with_pre.readable_data) em vez de usar
get_article_data(). O helper make_xml_with_pre() passa a
configurar readable_data como um dict de verdade (com surnames,
collab, links, article_titles, body_fragment) e
body_fragment_fingerprint, já que um MagicMock não configurado
quebra dict.update() com TypeError — erro que era silenciosamente
capturado pelo except Exception de register() e mascarado como
event_status='error'.

Adiciona patch de PidProviderSetting.load no setUp da classe base
(RegisterTestBase), desativado por padrão, para desacoplar os
testes da configuração persistida e permitir reuso em
RecordAllEventsSettingTest sem duplicar o patch.

Adiciona RegisterResponseSchemaTest como teste de contrato: valida
apenas as chaves presentes em cada nível do response de register()
(sucesso limpo, erro, conflito, skipped), incluindo verificação
explícita de que as chaves de readable_data substituem as antigas
(ex.: ausência de 'partial_body'). Funciona como sentinela contra
mudanças silenciosas de schema que testes anteriores, focados
apenas em event_status/v3, não detectavam.

* Corrige estrutura dos dados legíveis no dict de registro do PID

Remove a chave 'finger_print' solta em record_data() e passa a
aninhar o retorno de get_readable_data() sob a chave
'registered_data', em vez de mesclá-lo (update) diretamente no
nível superior do dict. Isso evita colisão de chaves entre os
dados legíveis e os demais campos do registro.

* Adiciona pid_provider/tests/test_models.py

Author: robertatakenaka

pid_provider/models.py

@@ -37,6 +37,8 @@
     zero_to_none,
     compare,
     QueryBuilderPidProviderXML,
+    fix_get_article_data,
+    fix_get_data_to_compare,
 )
 from tracker.models import BaseEvent, UnexpectedEvent
 
@@ -615,15 +617,33 @@ def data(self):
             "v2": self.v2,
             "aop_pid": self.aop_pid,
             "pkg_name": self.pkg_name,
-            "finger_print": self.current_version and self.current_version.finger_print,
-            "created": self.created and self.created.isoformat(),
-            "updated": self.updated and self.updated.isoformat(),
-            "record_status": "updated" if self.updated else "created",
             "registered_in_core": self.registered_in_core,
+            "ppx_id": self.id
         }
-        _data.update(self.get_readable_data())
+        _data["registered_data"] = self.get_readable_data()
+        _data.update(self.record_status)
         return _data
 
+    @property
+    def record_status(self):
+        """Retorna os timestamps e o estado do registro ('created' ou 'updated').
+        Calcula a variação entre `created` e `updated` para definir o estado de
+        persistência. Utilizado para direcionar o código HTTP de resposta:
+        - 'created' -> 201 Created
+        - 'updated' -> 200 OK ou 204 No Content
+        Returns:
+            dict: Dicionário com `created`, `updated` em ISO 8601 e `record_status`.
+        """
+        d = {}
+        if self.created:
+            d["created"] = self.created.isoformat()
+            d["record_status"] = "created"
+            if self.updated:
+                d["updated"] = self.updated.isoformat()
+                if (self.updated - self.created).total_seconds() > 1:
+                    d["record_status"] = "updated"
+        return d
+
     @classmethod
     @profile_classmethod
     def get_xml_with_pre(cls, v3):
@@ -657,25 +677,35 @@ def is_aop(self):
         return True
 
     def get_readable_data(self):
-        if self.readable_data:
-            return self.readable_data
+        readable_data = self.readable_data or {}
+        if readable_data:
+            try:
+                readable_data.pop("partial_body")
+            except KeyError:
+                pass
+            return readable_data
         if self.xml_with_pre:
-            return self.xml_with_pre.get_article_data()
+            return fix_get_article_data(self.xml_with_pre)
         return {}
 
     @property
     def data_to_compare(self):
+        data = {}
         readable = self.get_readable_data()
-        titles = readable.get("article_titles")
-        body_fragment = readable.get("body_fragment")
-        return {
-            "article_titles": titles or self.xml_with_pre.article_titles_texts,
+        if readable:
+            titles = readable.get("article_titles")
+            body_fragment = readable.get("body_fragment")
+            if titles:
+                data["article_titles"] = titles
+            if body_fragment:
+                data["body_fragment"] = body_fragment
+        data.update({
             "z_surnames": self.z_surnames,
             "z_collab": self.z_collab,
             "z_links": self.z_links,
-            "z_partial_body": self.z_partial_body,
-            "body_fragment": body_fragment or self.xml_with_pre.get_body_fragment(PARTIAL_BODY_MAX),
-        }
+            "body_fragment_fingerprint": self.z_partial_body,
+        })
+        return data
 
     @classmethod
     @profile_classmethod
@@ -758,7 +788,7 @@ def register(
 
             input_data = {}
             input_data.update(xml_with_pre.data)
-            input_data.update(xml_with_pre.get_article_data())
+            input_data.update(fix_get_article_data(xml_with_pre))
             input_data["origin"] = origin
             response["input_data"] = input_data
 
@@ -997,6 +1027,9 @@ def is_updated(
             )
             return
 
+        if not registered.readable_data:
+            return
+
         # verifica se é necessário atualizar
         if registered.is_equal_to(xml_with_pre):
             # XML fornecido é igual ao registrado, não precisa continuar
@@ -1074,12 +1107,12 @@ def select_record(xml_adapter, selection_results):
         checamos truthiness (nunca .exists()/.count() sobre queryset).
         """
         unmatched_items = {}
-        xml_adapter_data_to_compare = xml_adapter.get_data_to_compare()
+        xml_adapter_data_to_compare = fix_get_data_to_compare(xml_adapter)
         for label, results in selection_results:
             if not results:
                 continue
 
-            result = PidProviderXML.get_best_match(results, xml_adapter_data_to_compare)
+            result = PidProviderXML.get_best_match(results, xml_adapter_data_to_compare)            
 
             matched = result.get("matched")
             unmatched = result.get("unmatched")
@@ -1117,14 +1150,15 @@ def get_record_by_pid_v3(cls, xml_adapter):
             # pid v3 é inédito
             raise cls.DoesNotExist
 
-        xml_adapter_data_to_compare = xml_adapter.get_data_to_compare()
+        xml_adapter_data_to_compare = fix_get_data_to_compare(xml_adapter)
         result = PidProviderXML.get_best_match(results, xml_adapter_data_to_compare)
+
         registered = result.get("registered")
         if not registered:
-            xml_data = xml_adapter.xml_with_pre.get_article_data(PARTIAL_BODY_MAX)
-            items = [item.data for item in results]
             raise PidProviderXMLPidV3ConflictError(
-                _(f"{xml_pid_v3} belongs to {items}, not to {xml_data}")
+                _("{} do not belong to {}. Result: {}").format(
+                    xml_pid_v3, xml_adapter_data_to_compare, result,
+                )
             )
         return registered
 
@@ -1150,10 +1184,10 @@ def get_best_match(results, xml_adapter_data):
             ao consumir o retorno, nunca acesso direto.
 
             - ``"unmatched"``: presente apenas se houver ao menos 1
-            candidato com ``percentual_score`` <= 0.6. Lista de
+            candidato com ``percentual_score`` <= min_rate. Lista de
             ``item.data`` desses candidatos.
             - ``"registered"``: presente apenas se houver ao menos 1
-            candidato aprovado (score > 0.6). Contém o OBJETO
+            candidato aprovado (score > min_rate). Contém o OBJETO
             ``PidProviderXML`` (não o dict ``.data``) do candidato com
             maior score — em caso de empate, o critério de desempate é
             ``updated`` mais recente e, em seguida, maior ``id``.
@@ -1166,20 +1200,26 @@ def get_best_match(results, xml_adapter_data):
         detail = {}
         found = []
         items = {}
+        responses = {}
+        min_rate = 0.6
+        if len(xml_adapter_data) <= 4:
+            min_rate = 0.49
         for item in results:
             item_data = item.data_to_compare
             response = compare(item_data, xml_adapter_data)
             items[item.id] = item
+            responses[item.id] = response
             found.append((response["percentual_score"], item.updated.isoformat(), item.id))
 
         found = sorted(found, reverse=True)
         matched = []
         unmatched = []
         for percentual_score, updated, item_id in found:
-            if percentual_score > 0.6:
-                matched.append(items[item_id].data)
+            data = {"data": items[item_id].data, "response": responses[item_id]}
+            if percentual_score > min_rate:
+                matched.append(data)
             else:
-                unmatched.append(items[item_id].data)
+                unmatched.append(data)
         if matched:
             detail["registered"] = items[found[0][-1]]
             if len(matched) > 1:
@@ -1210,7 +1250,7 @@ def _add_data(self, xml_adapter, registered_in_core):
         self.z_links = xml_adapter.z_links
         self.z_partial_body = xml_adapter.xml_with_pre.body_fragment_fingerprint
 
-        self.readable_data = xml_adapter.xml_with_pre.get_article_data()
+        self.readable_data = fix_get_article_data(xml_adapter.xml_with_pre)
 
     @profile_method
     def _add_dates(self, xml_adapter, origin_date, available_since):
@@ -1382,6 +1422,8 @@ def is_registered(
             response["registered"] = True
             response.update(registered.data)
             response["is_equal"] = registered.is_equal_to(xml_with_pre)
+            if not registered.readable_data:
+                response["is_equal"] = False
             return response
         except Exception as e:
             exc_type, exc_value, exc_traceback = sys.exc_info()