111 lines
3.6 KiB
Python
111 lines
3.6 KiB
Python
# Importa a biblioteca nativa 'zlib' usada para compressão/descompressão de dados binários.
|
|
import zlib
|
|
|
|
# Importa a função 'rtf_to_text' da biblioteca 'striprtf',
|
|
# responsável por converter documentos RTF em texto plano legível.
|
|
from striprtf.striprtf import rtf_to_text
|
|
|
|
|
|
# Define uma classe utilitária chamada 'Text', contendo apenas métodos estáticos.
|
|
# Essa abordagem permite o uso direto sem necessidade de instanciar a classe.
|
|
class Text:
|
|
@staticmethod
|
|
def decompress(vf_string):
|
|
"""
|
|
Descomprime e decodifica texto de origem WPTools/Firebird.
|
|
|
|
Finalidade:
|
|
Converter o conteúdo de campos BLOB ou strings compactadas (como no Delphi)
|
|
em texto legível, detectando automaticamente se o conteúdo está:
|
|
- Compactado com zlib
|
|
- Codificado em ISO-8859-1 (padrão ANSI)
|
|
- Representado como bytes puros
|
|
"""
|
|
# Verifica se o valor recebido é nulo, vazio ou None.
|
|
if not vf_string:
|
|
return ""
|
|
|
|
# Caso seja um objeto tipo stream (ex: campo BLOB do Firebird)
|
|
if hasattr(vf_string, "read"):
|
|
vf_string = vf_string.read()
|
|
|
|
# Garante que o valor trabalhado é uma sequência de bytes
|
|
if isinstance(vf_string, str):
|
|
vf_bytes = vf_string.encode("latin1", errors="ignore")
|
|
else:
|
|
vf_bytes = vf_string
|
|
|
|
# Detecta assinatura zlib (0x78 0x9C ou 0x78 0xDA)
|
|
is_zlib = (
|
|
len(vf_bytes) > 2 and vf_bytes[0] == 0x78 and vf_bytes[1] in (0x9C, 0xDA)
|
|
)
|
|
|
|
# Se for zlib, tenta descompactar
|
|
if is_zlib:
|
|
try:
|
|
return zlib.decompress(vf_bytes).decode("iso-8859-1", errors="ignore")
|
|
except Exception:
|
|
pass
|
|
|
|
# Caso não seja zlib, trata como texto puro
|
|
try:
|
|
return vf_bytes.decode("iso-8859-1", errors="ignore")
|
|
except Exception:
|
|
return str(vf_string)
|
|
|
|
@staticmethod
|
|
def compress(text, *, encoding: str = "iso-8859-1"):
|
|
"""
|
|
Comprime texto/dados com zlib SEM Base64.
|
|
|
|
Parâmetros:
|
|
text: str | bytes | stream (com .read())
|
|
encoding: encoding usado quando 'text' for str (padrão: ISO-8859-1)
|
|
|
|
Retorno:
|
|
- bytes comprimidos (zlib)
|
|
|
|
Observações:
|
|
- Ideal para armazenamento direto em BLOB (Firebird, PostgreSQL, etc.)
|
|
- Evita overhead e custo do Base64
|
|
- Totalmente compatível com 'decompress'
|
|
"""
|
|
if text is None or text == "":
|
|
return b""
|
|
|
|
# Se for stream (ex.: BLOB do Firebird)
|
|
if hasattr(text, "read"):
|
|
raw = text.read()
|
|
else:
|
|
raw = text
|
|
|
|
# Garante bytes
|
|
if isinstance(raw, str):
|
|
raw_bytes = raw.encode(encoding, errors="ignore")
|
|
else:
|
|
raw_bytes = bytes(raw)
|
|
|
|
# Comprime com zlib e retorna bytes
|
|
return zlib.compress(raw_bytes)
|
|
|
|
@staticmethod
|
|
def to_text(raw_text: str) -> str:
|
|
"""
|
|
Converte o conteúdo RTF em texto simples e retorna como string.
|
|
|
|
Finalidade:
|
|
- Detectar automaticamente se o conteúdo está em formato RTF.
|
|
- Converter para texto plano usando a função 'rtf_to_text'.
|
|
- Retornar uma string limpa e pronta para uso.
|
|
"""
|
|
if not raw_text:
|
|
return ""
|
|
|
|
# Detecta cabeçalho RTF
|
|
if raw_text.strip().startswith("{\\rtf"):
|
|
try:
|
|
return rtf_to_text(raw_text).strip()
|
|
except Exception:
|
|
return raw_text
|
|
|
|
return raw_text.strip()
|