positiva-consultas-python-sdk 1.0.0__py3-none-any.whl

positiva/consultas/dtos/juridico360.py

@@ -0,0 +1,676 @@
+# -*- coding: utf-8 -*-
+"""DTOs Positiva Juridico 360.
+
+POST /api/client/provider/juridico360
+POST /api/client/provider/juridico360/pdf
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from positiva.consultas.dtos.enums import Juridico360ProductCode, MpKind
+from positiva.consultas.dtos.serde import (
+  as_wire_dict,
+  digits_only,
+  from_dataclass,
+  omit_none,
+  to_wire,
+)
+
+
+# ---------------------------------------------------------------------------
+# Request
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Juridico360Options:
+  """Opcoes opcionais: paginacao (processos) ou ``kind`` (MP/BNMP)."""
+
+  cursor: str | None = None
+  page_size: int | None = None
+  kind: str | MpKind | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'cursor': self.cursor,
+      'page_size': self.page_size,
+      'kind': to_wire(self.kind),
+    })
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | Juridico360Options | None
+  ) -> Juridico360Options | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class Juridico360Request:
+  document: str
+  product_code: list[str | Juridico360ProductCode]
+  options: Juridico360Options | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'document': digits_only(self.document),
+      'product_code': [to_wire(p) for p in self.product_code],
+      'options': to_wire(self.options),
+    })
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | Juridico360Request | None
+  ) -> Juridico360Request | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(
+        f'Juridico360Request.from_dict espera dict, recebeu {type(data)!r}'
+      )
+    codes = data.get('product_code') or []
+    return cls(
+      document=str(data.get('document') or ''),
+      product_code=list(codes),
+      options=Juridico360Options.from_dict(data.get('options')),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Shared nested models
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Identificacao:
+  valor: str | None = None
+  tipo: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict | Identificacao | None) -> Identificacao | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class Parte:
+  papel: str | None = None
+  nome: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict | Parte | None) -> Parte | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class Advogado:
+  nome: str | None = None
+  oab: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict | Advogado | None) -> Advogado | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class ProcessoStatus:
+  inferido: str | None = None
+  normalizado: str | None = None
+  tribunal: str | None = None
+  data: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | ProcessoStatus | None
+  ) -> ProcessoStatus | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class PenaPrevista:
+  """Detalhe de pena quando a API devolve objeto (comum em MP); pode ser null."""
+
+  raw: str | None = None
+  tipo_pena: str | None = None
+  min_periodo_pena_mes: int | None = None
+  max_periodo_pena_mes: int | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict | PenaPrevista | None) -> PenaPrevista | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class Legislacao:
+  lei: str | None = None
+  # Homolog/docs às vezes sugerem string; retorno real usa objeto ou null.
+  pena_prevista: PenaPrevista | str | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'lei': self.lei,
+      'pena_prevista': to_wire(self.pena_prevista),
+    })
+
+  @classmethod
+  def from_dict(cls, data: dict | Legislacao | None) -> Legislacao | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(f'Legislacao.from_dict espera dict, recebeu {type(data)!r}')
+    pena = data.get('pena_prevista')
+    if isinstance(pena, dict):
+      pena_parsed: PenaPrevista | str | None = PenaPrevista.from_dict(pena)
+    else:
+      pena_parsed = pena
+    return cls(lei=data.get('lei'), pena_prevista=pena_parsed)
+
+
+@dataclass
+class Tipificacao:
+  codigo_ocorrencia: str | None = None
+  tipo_de_ocorrencia: str | None = None
+  descricao_ocorrencia: str | None = None
+  legislacao: list[Legislacao] | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'codigo_ocorrencia': self.codigo_ocorrencia,
+      'tipo_de_ocorrencia': self.tipo_de_ocorrencia,
+      'descricao_ocorrencia': self.descricao_ocorrencia,
+      'legislacao': to_wire(self.legislacao),
+    })
+
+  @classmethod
+  def from_dict(cls, data: dict | Tipificacao | None) -> Tipificacao | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(f'Tipificacao.from_dict espera dict, recebeu {type(data)!r}')
+    rows = data.get('legislacao')
+    return cls(
+      codigo_ocorrencia=data.get('codigo_ocorrencia'),
+      tipo_de_ocorrencia=data.get('tipo_de_ocorrencia'),
+      descricao_ocorrencia=data.get('descricao_ocorrencia'),
+      legislacao=[Legislacao.from_dict(i) for i in rows] if rows else None,
+    )
+
+
+@dataclass
+class ProcessoRelacionado:
+  numero_processo: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | ProcessoRelacionado | None
+  ) -> ProcessoRelacionado | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class Pagination:
+  endCursor: str | None = None
+  hasNextPage: bool | None = None
+  total: int | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict | Pagination | None) -> Pagination | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class Processo:
+  tipo_processo: str | None = None
+  processo_principal: bool | None = None
+  data_ultima_atualizacao: str | None = None
+  data_andamento_mais_recente: str | None = None
+  confianca_associacao: str | None = None
+  partes: list[Parte] | None = None
+  advogados: list[Advogado] | None = None
+  valor_causa: int | float | None = None
+  status: ProcessoStatus | None = None
+  tipificacao_identificada: bool | None = None
+  tipificacao: list[Tipificacao] | None = None
+  natureza: str | None = None
+  classe_processual: str | None = None
+  assunto: str | None = None
+  ano_do_processo: str | None = None
+  ano_distribuicao: str | None = None
+  polo_passivo: bool | None = None
+  tribunal: str | None = None
+  UF: str | None = None
+  comarca: str | None = None
+  papel: str | None = None
+  forum: str | None = None
+  nome_na_capa: str | None = None
+  numero_processo: str | None = None
+  processos_relacionados: list[ProcessoRelacionado] | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'tipo_processo': self.tipo_processo,
+      'processo_principal': self.processo_principal,
+      'data_ultima_atualizacao': self.data_ultima_atualizacao,
+      'data_andamento_mais_recente': self.data_andamento_mais_recente,
+      'confianca_associacao': self.confianca_associacao,
+      'partes': to_wire(self.partes),
+      'advogados': to_wire(self.advogados),
+      'valor_causa': self.valor_causa,
+      'status': to_wire(self.status),
+      'tipificacao_identificada': self.tipificacao_identificada,
+      'tipificacao': to_wire(self.tipificacao),
+      'natureza': self.natureza,
+      'classe_processual': self.classe_processual,
+      'assunto': self.assunto,
+      'ano_do_processo': self.ano_do_processo,
+      'ano_distribuicao': self.ano_distribuicao,
+      'polo_passivo': self.polo_passivo,
+      'tribunal': self.tribunal,
+      'UF': self.UF,
+      'comarca': self.comarca,
+      'papel': self.papel,
+      'forum': self.forum,
+      'nome_na_capa': self.nome_na_capa,
+      'numero_processo': self.numero_processo,
+      'processos_relacionados': to_wire(self.processos_relacionados),
+    })
+
+  @classmethod
+  def from_dict(cls, data: dict | Processo | None) -> Processo | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(f'Processo.from_dict espera dict, recebeu {type(data)!r}')
+    partes = data.get('partes')
+    advogados = data.get('advogados')
+    tipificacao = data.get('tipificacao')
+    relacionados = data.get('processos_relacionados')
+    return cls(
+      tipo_processo=data.get('tipo_processo'),
+      processo_principal=data.get('processo_principal'),
+      data_ultima_atualizacao=data.get('data_ultima_atualizacao'),
+      data_andamento_mais_recente=data.get('data_andamento_mais_recente'),
+      confianca_associacao=data.get('confianca_associacao'),
+      partes=[Parte.from_dict(i) for i in partes] if partes else None,
+      advogados=[Advogado.from_dict(i) for i in advogados] if advogados else None,
+      valor_causa=data.get('valor_causa'),
+      status=ProcessoStatus.from_dict(data.get('status')),
+      tipificacao_identificada=data.get('tipificacao_identificada'),
+      tipificacao=[Tipificacao.from_dict(i) for i in tipificacao] if tipificacao else None,
+      natureza=data.get('natureza'),
+      classe_processual=data.get('classe_processual'),
+      assunto=data.get('assunto'),
+      ano_do_processo=data.get('ano_do_processo'),
+      ano_distribuicao=data.get('ano_distribuicao'),
+      polo_passivo=data.get('polo_passivo'),
+      tribunal=data.get('tribunal'),
+      UF=data.get('UF'),
+      comarca=data.get('comarca'),
+      papel=data.get('papel'),
+      forum=data.get('forum'),
+      nome_na_capa=data.get('nome_na_capa'),
+      numero_processo=data.get('numero_processo'),
+      processos_relacionados=[
+        ProcessoRelacionado.from_dict(i) for i in relacionados
+      ]
+      if relacionados
+      else None,
+    )
+
+
+@dataclass
+class MovimentacaoMp:
+  url: str | None = None
+  data: str | None = None
+  detalhe: str | None = None
+  movimento: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | MovimentacaoMp | None
+  ) -> MovimentacaoMp | None:
+    return from_dataclass(cls, data)
+
+
+@dataclass
+class RegistroMp:
+  sigla: str | None = None
+  confianca_associacao: str | None = None
+  papel: str | None = None
+  assunto: str | None = None
+  unidade_mp: str | None = None
+  numero_mp: str | None = None
+  numero_processo: str | None = None
+  tipo_procedimento: str | None = None
+  situacao: str | None = None
+  ano_do_inquerito: str | None = None
+  uf: str | None = None
+  autos: str | None = None
+  tipificacao: list[Tipificacao] | None = None
+  tipificacao_identificada: bool | None = None
+  movimentacoes: list[MovimentacaoMp] | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'sigla': self.sigla,
+      'confianca_associacao': self.confianca_associacao,
+      'papel': self.papel,
+      'assunto': self.assunto,
+      'unidade_mp': self.unidade_mp,
+      'numero_mp': self.numero_mp,
+      'numero_processo': self.numero_processo,
+      'tipo_procedimento': self.tipo_procedimento,
+      'situacao': self.situacao,
+      'ano_do_inquerito': self.ano_do_inquerito,
+      'uf': self.uf,
+      'autos': self.autos,
+      'tipificacao': to_wire(self.tipificacao),
+      'tipificacao_identificada': self.tipificacao_identificada,
+      'movimentacoes': to_wire(self.movimentacoes),
+    })
+
+  @classmethod
+  def from_dict(cls, data: dict | RegistroMp | None) -> RegistroMp | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(f'RegistroMp.from_dict espera dict, recebeu {type(data)!r}')
+    tipificacao = data.get('tipificacao')
+    movimentacoes = data.get('movimentacoes')
+    return cls(
+      sigla=data.get('sigla'),
+      confianca_associacao=data.get('confianca_associacao'),
+      papel=data.get('papel'),
+      assunto=data.get('assunto'),
+      unidade_mp=data.get('unidade_mp'),
+      numero_mp=data.get('numero_mp'),
+      numero_processo=data.get('numero_processo'),
+      tipo_procedimento=data.get('tipo_procedimento'),
+      situacao=data.get('situacao'),
+      ano_do_inquerito=data.get('ano_do_inquerito'),
+      uf=data.get('uf'),
+      autos=data.get('autos'),
+      tipificacao=[Tipificacao.from_dict(i) for i in tipificacao] if tipificacao else None,
+      tipificacao_identificada=data.get('tipificacao_identificada'),
+      movimentacoes=[MovimentacaoMp.from_dict(i) for i in movimentacoes]
+      if movimentacoes
+      else None,
+    )
+
+
+@dataclass
+class MandadoBnmp:
+  confianca_associacao: str | None = None
+  situacao: str | None = None
+  especie_prisao: str | None = None
+  data_expedicao: str | None = None
+  data_validade: str | None = None
+  tipificacao: list[Tipificacao] | None = None
+  tipificacao_identificada: bool | None = None
+  numero_bnmp: str | None = None
+  numero_processo: str | None = None
+  local_processo: str | None = None
+  tipo_processo: str | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'confianca_associacao': self.confianca_associacao,
+      'situacao': self.situacao,
+      'especie_prisao': self.especie_prisao,
+      'data_expedicao': self.data_expedicao,
+      'data_validade': self.data_validade,
+      'tipificacao': to_wire(self.tipificacao),
+      'tipificacao_identificada': self.tipificacao_identificada,
+      'numero_bnmp': self.numero_bnmp,
+      'numero_processo': self.numero_processo,
+      'local_processo': self.local_processo,
+      'tipo_processo': self.tipo_processo,
+    })
+
+  @classmethod
+  def from_dict(cls, data: dict | MandadoBnmp | None) -> MandadoBnmp | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(f'MandadoBnmp.from_dict espera dict, recebeu {type(data)!r}')
+    tipificacao = data.get('tipificacao')
+    return cls(
+      confianca_associacao=data.get('confianca_associacao'),
+      situacao=data.get('situacao'),
+      especie_prisao=data.get('especie_prisao'),
+      data_expedicao=data.get('data_expedicao'),
+      data_validade=data.get('data_validade'),
+      tipificacao=[Tipificacao.from_dict(i) for i in tipificacao] if tipificacao else None,
+      tipificacao_identificada=data.get('tipificacao_identificada'),
+      numero_bnmp=data.get('numero_bnmp'),
+      numero_processo=data.get('numero_processo'),
+      local_processo=data.get('local_processo'),
+      tipo_processo=data.get('tipo_processo'),
+    )
+
+
+@dataclass
+class EmpregadorIrregular:
+  confianca_associacao: str | None = None
+  sigla: str | None = None
+  uf: str | None = None
+  estabelecimento: str | None = None
+  cnae: str | None = None
+  ano_acao_fiscal: str | None = None
+  data_decisao_administrativa: str | None = None
+  data_inclusao: str | None = None
+  data_publicacao: str | None = None
+  quantidade_trabalhadores_envolvidos: int | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | EmpregadorIrregular | None
+  ) -> EmpregadorIrregular | None:
+    return from_dataclass(cls, data)
+
+
+# ---------------------------------------------------------------------------
+# Product data envelopes
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Juridico360ProductData:
+  """Payload tipado de ``results.<PRODUTO>.data`` (campos conforme produto)."""
+
+  nome: str | None = None
+  identificacao: Identificacao | None = None
+  processos: list[Processo] | None = None
+  pagination: Pagination | None = None
+  mp: list[RegistroMp] | None = None
+  mandados: list[MandadoBnmp] | None = None
+  empregadores: list[EmpregadorIrregular] | None = None
+  raw: dict[str, Any] | None = field(default=None, repr=False)
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'nome': self.nome,
+      'identificacao': to_wire(self.identificacao),
+      'processos': to_wire(self.processos),
+      'pagination': to_wire(self.pagination),
+      'mp': to_wire(self.mp),
+      'mandados': to_wire(self.mandados),
+      'empregadores': to_wire(self.empregadores),
+    })
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | Juridico360ProductData | None
+  ) -> Juridico360ProductData | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(
+        f'Juridico360ProductData.from_dict espera dict, recebeu {type(data)!r}'
+      )
+    processos = data.get('processos')
+    mp = data.get('mp')
+    mandados = data.get('mandados')
+    empregadores = data.get('empregadores')
+    return cls(
+      nome=data.get('nome'),
+      identificacao=Identificacao.from_dict(data.get('identificacao')),
+      processos=[Processo.from_dict(i) for i in processos] if processos else None,
+      pagination=Pagination.from_dict(data.get('pagination')),
+      mp=[RegistroMp.from_dict(i) for i in mp] if mp else None,
+      mandados=[MandadoBnmp.from_dict(i) for i in mandados] if mandados else None,
+      empregadores=[EmpregadorIrregular.from_dict(i) for i in empregadores]
+      if empregadores
+      else None,
+      raw=dict(data),
+    )
+
+
+@dataclass
+class Juridico360ProductResult:
+  success: bool | None = None
+  data: Juridico360ProductData | None = None
+  error: str | None = None
+  message: str | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'success': self.success,
+      'data': to_wire(self.data),
+      'error': self.error,
+      'message': self.message,
+    })
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | Juridico360ProductResult | None
+  ) -> Juridico360ProductResult | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(
+        f'Juridico360ProductResult.from_dict espera dict, recebeu {type(data)!r}'
+      )
+    return cls(
+      success=data.get('success'),
+      data=Juridico360ProductData.from_dict(data.get('data')),
+      error=data.get('error'),
+      message=data.get('message'),
+    )
+
+
+@dataclass
+class Juridico360Response:
+  success: bool | None = None
+  document: str | None = None
+  provider: str | None = None
+  query_date: str | None = None
+  results: dict[str, Juridico360ProductResult] | None = None
+
+  def to_dict(self) -> dict:
+    return omit_none({
+      'success': self.success,
+      'document': self.document,
+      'provider': self.provider,
+      'query_date': self.query_date,
+      'results': {
+        key: to_wire(value) for key, value in (self.results or {}).items()
+      }
+      if self.results is not None
+      else None,
+    })
+
+  def get_product(
+    self, code: str | Juridico360ProductCode
+  ) -> Juridico360ProductResult | None:
+    if not self.results:
+      return None
+    return self.results.get(to_wire(code))
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | Juridico360Response | None
+  ) -> Juridico360Response | None:
+    if data is None:
+      return None
+    if isinstance(data, cls):
+      return data
+    if not isinstance(data, dict):
+      raise TypeError(
+        f'Juridico360Response.from_dict espera dict, recebeu {type(data)!r}'
+      )
+    raw_results = data.get('results') or {}
+    results = {
+      key: Juridico360ProductResult.from_dict(value)
+      for key, value in raw_results.items()
+      if isinstance(value, dict)
+    }
+    return cls(
+      success=data.get('success'),
+      document=data.get('document'),
+      provider=data.get('provider'),
+      query_date=data.get('query_date'),
+      results=results,
+    )
+
+
+@dataclass
+class Juridico360PdfResponse:
+  success: bool | None = None
+  document: str | None = None
+  provider: str | None = None
+  query_date: str | None = None
+  mime_type: str | None = None
+  pdf_base64: str | None = None
+
+  def to_dict(self) -> dict:
+    return as_wire_dict(self)
+
+  @classmethod
+  def from_dict(
+    cls, data: dict | Juridico360PdfResponse | None
+  ) -> Juridico360PdfResponse | None:
+    return from_dataclass(cls, data)