responds-forms 0.4__py3-none-any.whl

cartas/origin.py

@@ -0,0 +1,1196 @@
+# arquivo cartas/__init__.py
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+from enum import StrEnum
+from typing import Any
+from abc import ABC, abstractmethod
+from os import rename as rename_file
+from datetime import datetime
+
+import pandas as pd
+
+from table_stream import (
+    # Array
+    HashMapDict,
+    HashMap,
+    ArrayList,
+    Set,
+    # Tabelas
+    TableData,
+    ArrayTables,
+    ColumnV,
+    RowH,
+    HeadersSizeNotIqualError,
+    # Arquivos.
+    HeaderMetaData,
+    hashFile,
+    File,
+    Directory,
+    ContentFiles,
+    load_file_hash,
+)
+
+from ocr_stream import HeaderOcr, BuilderConfigOcr, CreateRelatorioOcr
+
+from whatsapp_files import (
+    RowWhatsApp,
+    TableWhatsApp,
+    HeaderWhatsApp,
+    BuilderTableWhatsApp,
+    ControllerWhatsApp,
+    move_path,
+)
+
+__version__ = "0.1"
+
+
+@dataclass
+class ConfigTOI:
+
+    file_relatorio_toi: File
+    file_relatorio_forms: File
+    file_table_toi: File
+    file_master_forms: File  # NOVO
+    dir_base_toi: Directory
+    dir_log_excel: Directory
+    dir_relatorios: Directory
+    work_dir: Directory
+
+
+class BuilderConfigTOI(object):
+
+    _instance = None  # Atributo de classe para armazenar a instância singleton
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(BuilderConfigTOI, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+
+        # Garante que __init__ não será executado mais de uma vez
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+
+        super().__init__()
+        self._initialized: bool = True
+        self._builder_ocr = BuilderConfigOcr.get_instance()
+        self._config = self._create()
+
+    @property
+    def dir_base_work(self) -> Directory:
+        return self._builder_ocr.builder().dir_base_work
+
+    @property
+    def dir_retorno_de_campo(self) -> Directory:
+        return self.dir_base_work.concat("Cartas-TOI", True).concat(
+            "Retorno-de-campo", True
+        )
+
+    @property
+    def dir_log_excel(self) -> Directory:
+        return self.dir_base_work.concat("Cartas-TOI", True).concat("Logs", True)
+
+    @property
+    def dir_relatorios(self) -> Directory:
+        return self.dir_base_work.concat("Cartas-TOI", True).concat(
+            "Relatorios-toi", True
+        )
+
+    @property
+    def file_relatorio_toi(self) -> File:
+        d = self._builder_ocr.builder().dir_table
+        return d.join_file("Relatorio-tois.xlsx")
+
+    @property
+    def file_relatorio_forms(self) -> File:
+        d = self._builder_ocr.builder().dir_table
+        return d.join_file("cartas-toi-lancadas.xlsx")
+
+    @property
+    def file_master_forms(self) -> File:
+        d = self._builder_ocr.builder().dir_table
+        return d.join_file("master-forms-toi.xlsx")
+
+    @property
+    def file_table_toi(self) -> File:
+        d = self._builder_ocr.builder().dir_table
+        return d.join_file("tabela-entregas-tois.xlsx")
+
+    def _create(self) -> ConfigTOI:
+        return ConfigTOI(
+            work_dir=self.dir_base_work,
+            dir_base_toi=self.dir_retorno_de_campo,
+            file_relatorio_toi=self.file_relatorio_toi,
+            file_table_toi=self.file_table_toi,
+            file_relatorio_forms=self.file_relatorio_forms,
+            dir_log_excel=self.dir_log_excel,
+            dir_relatorios=self.dir_relatorios,
+            file_master_forms=self.file_master_forms,
+        )
+
+    def builder(self) -> ConfigTOI:
+        if self._config is None:
+            self._config = self._create()
+        return self._config
+
+
+# ============================================================#
+# Extração de UC/TOI tolerante a falhas de OCR
+# ============================================================#
+#
+# UC: 1305934 TOI: 193166923 ...
+# UC: 1305934 TO! 193166923 ...   (TOI virou TO!, ":" some)
+# UC| 1305934 T0I: 193166923 ...  (0 no lugar do O)
+#
+
+UC_TOI_PATTERN = re.compile(
+    r"U[C0]\s*[:;|!]?\s*(\d{4,10})" r".{0,60}?" r"T[O0][I1L!l]?\s*[:;|!]?\s*(\d{4,10})",
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+def extrair_uc_toi(texto: str) -> tuple[str, str] | None:
+    """
+        Retorna (uc, toi) a partir do texto OCR completo de um arquivo,
+    ou None se o padrão não for encontrado.
+    """
+    m = UC_TOI_PATTERN.search(texto)
+    if not m:
+        return None
+    return m.group(1), m.group(2)
+
+
+# ========================================================#
+# Tabelas TOI.
+# ========================================================#
+
+
+class HeaderEntregaTOI(StrEnum):
+    """
+    Enumerador que representa a relação entre um documento e os dados
+    de entrega:
+        UC, TOI, DAY, MON, YEAR, DATE E HASH_FILE.
+
+    a relação/key de uma entrega e a hash do documento.
+    """
+
+    UC = "uc"
+    TOI = "toi"
+    DAY = "day"
+    MON = "mon"
+    YEAR = "year"
+    DATE = "data_entrega"
+    HASH_FILE = HeaderMetaData.HASH_FILE.value
+
+
+class HeaderFilesTOI(StrEnum):
+    """
+    Dados completos de um arquivo TOI, incluindo os metadados e
+    caminho absoluto.
+    """
+
+    UC = HeaderEntregaTOI.UC
+    TOI = HeaderEntregaTOI.TOI
+    DAY = HeaderEntregaTOI.DAY
+    MON = HeaderEntregaTOI.MON
+    YEAR = HeaderEntregaTOI.YEAR
+    DATE = HeaderEntregaTOI.DATE
+    HASH_FILE = HeaderEntregaTOI.HASH_FILE
+
+    LOCAL_ENTREGA = "local_entrega"
+    TIPO_DOC = "tipo_carta"
+
+    IS_FILE = "arquivo?"
+    FULL_PATH = HeaderMetaData.FILE_PATH.value
+    SRC = HeaderMetaData.PARENT_DIR.value
+    FILE_EXTENSION = HeaderMetaData.FILE_EXTENSION.value
+    FILE_BASENAME = "basename"
+
+
+class TipoCarta(StrEnum):
+
+    CARTA_CALCULO = "CARTA-CALCULO"
+
+
+class LocalEntregaCarta(StrEnum):
+
+    OUTRO = "OUTRO"
+    MAOS = "MÃOS"
+    CORREIOS = "CORREIOS"
+    PORTAO = "PORTÃO"
+
+
+# ========================================================#
+# Criar Tabelas.
+# ========================================================#
+
+
+class BuilderTOI(ABC):
+    """
+        Criar dados de uma entrega TOI apartir de um arquivo ou do texto
+    de um documento.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @abstractmethod
+    def create_void(self) -> TableData[Any]:
+        pass
+
+    @abstractmethod
+    def from_data(self, df: pd.DataFrame) -> TableData[Any]:
+        pass
+
+    @abstractmethod
+    def from_path_name(self, path: File, md5: hashFile = None) -> TableData[Any] | None:
+        pass
+
+    @abstractmethod
+    def from_hash_files(
+        self, data: HashMap[hashFile, File], *, ignore_null: bool = True
+    ) -> TableData[Any] | None:
+        pass
+
+
+class BuilderEntregaTOI(BuilderTOI):
+    """
+        Criar dados de uma entrega TOI apartir de um arquivo ou do texto
+    de um documento.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.relatorio_ocr = CreateRelatorioOcr()
+        self.relatorio_wp = ControllerWhatsApp()
+
+        self.default_cols_toi = ArrayList[HeaderEntregaTOI].from_list(
+            [
+                HeaderEntregaTOI.UC,
+                HeaderEntregaTOI.TOI,
+                HeaderEntregaTOI.DATE,
+                HeaderEntregaTOI.YEAR,
+                HeaderEntregaTOI.MON,
+                HeaderEntregaTOI.DAY,
+                HeaderEntregaTOI.HASH_FILE,
+            ]
+        )
+
+    def create_void(self) -> TableData[HeaderEntregaTOI]:
+        """
+        Cria uma tabela TOI vazia com todos os itens do cabeçalho HeaderTOI
+        """
+        tb = TableData[HeaderEntregaTOI]()
+        self.default_cols_toi.for_each(lambda c: tb.add(ColumnV(c)))
+        return tb
+
+    def from_data(self, df: pd.DataFrame) -> TableData[HeaderEntregaTOI]:
+        """
+        Criar tabela TOI apartir de um DataFrame().
+        """
+        df = df.astype(str)
+        df_cols = ArrayList(df.columns.tolist())
+        tb = TableData[HeaderEntregaTOI]()
+
+        c: HeaderEntregaTOI
+        for c in self.default_cols_toi:
+            if df_cols.contains(c.value):
+                tb.add(
+                    ColumnV.create_from_list(c, df[c.value].astype(str).values.tolist())
+                )
+
+        if tb.header().size() != self.default_cols_toi.size():
+            raise HeadersSizeNotIqualError(
+                f"DataFrame() de entrega toi com colunas diferente do padrão: \n{tb.header()}"
+            )
+        return tb
+
+    def from_path_name(
+        self, path: File, md5: hashFile = None
+    ) -> TableData[HeaderEntregaTOI] | None:
+        """
+        Criar tabela apartir do nome de uma arquivo que esteja no padrão TOI.
+        """
+
+        if not path.exists():
+            return None
+
+        mp = self.create_map_from_filename(path.name())
+        if mp is None:
+            return None
+        if md5 is None:
+            md5 = load_file_hash(path)
+
+        mp.set_value(HeaderEntregaTOI.HASH_FILE, md5)
+        tb = TableData[HeaderEntregaTOI]()
+        c: HeaderEntregaTOI
+
+        for c in self.default_cols_toi:
+            tb.add(ColumnV.create_from_list(c, [mp.get_value(c)]))
+        return tb
+
+    def create_map_from_filename(
+        self,
+        filename: str,
+    ) -> HashMapDict[HeaderEntregaTOI, str] | None:
+        """
+        Retorna um Map de chave/valor com as seguintes chaves:
+
+        UC, TOI, DAY, MON, YEAR e DATE.
+        """
+
+        try:
+            values = filename.split(" ")
+            if len(values) < 5:
+                # Nome incompleto ou inválido.
+                return None
+        except:
+            return None
+        else:
+            for x in values:
+                if not x.isnumeric():
+                    return None
+
+            data = HashMapDict()
+            data[HeaderEntregaTOI.UC] = values[0]  # UC
+            data[HeaderEntregaTOI.TOI] = values[1]  # TOI
+            data[HeaderEntregaTOI.DAY] = values[2]  # DIA
+            data[HeaderEntregaTOI.MON] = values[3]  # MÊS
+            data[HeaderEntregaTOI.YEAR] = values[4]  # ANO
+            data[HeaderEntregaTOI.DATE] = f"{values[2]}/{values[3]}/{values[4]}"
+            return data
+
+    def from_hash_files(
+        self, data: HashMap[hashFile, File], *, ignore_null: bool = True
+    ) -> TableData[HeaderEntregaTOI] | None:
+
+        if data.is_empty():
+            return None
+
+        header_hashs = data.header().to_set()
+        table_ocr: TableData[HeaderOcr] | None = self.relatorio_ocr.create_from_hashs(
+            header_hashs
+        )
+
+        if table_ocr is None:
+            return None
+        if table_ocr.is_empty():
+            return None
+
+        # builder_wp = BuilderTableWhatsApp()
+
+        table_whatsapp: TableData[HeaderWhatsApp] = self.relatorio_wp.load_cache_table()
+        if table_whatsapp.is_empty():
+            if ignore_null:
+                return None
+
+        key_hash: hashFile
+        sequence_tables = ArrayTables[TableData[HeaderEntregaTOI]]()
+
+        for key_hash in header_hashs:
+            date_chat_file: str = TableData.NULL_STRING
+            day = TableData.NULL_STRING
+            mon = TableData.NULL_STRING
+            year = TableData.NULL_STRING
+            uc = TableData.NULL_STRING
+            toi = TableData.NULL_STRING
+
+            # =========================================================#
+            # Data de envio do arquivo no chat
+            # =========================================================#
+            if not table_whatsapp.is_empty():
+                tb_chat = table_whatsapp.search(HeaderWhatsApp.hash_md5, key_hash)
+
+                if tb_chat.is_empty() and ignore_null:
+                    continue
+
+                if not tb_chat.is_empty():
+                    # date_chat_file: datetime = tb_chat.get_row_at(0).get_date_hour()
+                    # day = str(date_chat_file.day)
+                    # mon = str(date_chat_file.month)
+                    # year = str(date_chat_file.year)
+                    date_chat_file: str = tb_chat.get_row_at(0).get_date().get_first()
+                    day = date_chat_file.split(" ")[0]
+                    mon = date_chat_file.split(" ")[1]
+                    year = date_chat_file.split(" ")[2]
+
+            # =========================================================#
+            # Extrair UC e TOI
+            # =========================================================#
+            tb_ocr = table_ocr.search(HeaderOcr.HASH_FILE, key_hash)
+            if tb_ocr.is_empty() and ignore_null:
+                continue
+
+            if not tb_ocr.is_empty():
+                txt_ocr: str = tb_ocr.to_string(HeaderOcr.TEXT)
+                value_uc_toi: tuple[str, str] | None = extrair_uc_toi(txt_ocr)
+
+                if value_uc_toi is None and ignore_null:
+                    continue
+
+                if value_uc_toi is not None:
+                    uc = value_uc_toi[0]
+                    toi = value_uc_toi[1]
+
+            row_toi = RowH[HeaderEntregaTOI, Any](0)
+            row_toi.set(HeaderEntregaTOI.UC, uc)
+            row_toi.set(HeaderEntregaTOI.TOI, toi)
+            row_toi.set(HeaderEntregaTOI.DAY, day)
+            row_toi.set(HeaderEntregaTOI.MON, mon)
+            row_toi.set(HeaderEntregaTOI.YEAR, year)
+            row_toi.set(HeaderEntregaTOI.HASH_FILE, key_hash)
+            row_toi.set(HeaderEntregaTOI.DATE, date_chat_file)
+
+            t = self.create_void()
+            t.add_row(row_toi)
+            sequence_tables.add(t)
+
+        if sequence_tables.empty():
+            return None
+
+        return sequence_tables.concat(TableData).drop_duplicates()
+
+
+class BuilderTableFilesTOI(BuilderTOI):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.default_cols_cartas = ArrayList[HeaderFilesTOI].from_list(
+            [
+                HeaderFilesTOI.UC,
+                HeaderFilesTOI.TOI,
+                HeaderFilesTOI.DATE,
+                HeaderFilesTOI.YEAR,
+                HeaderFilesTOI.MON,
+                HeaderFilesTOI.DAY,
+                HeaderFilesTOI.LOCAL_ENTREGA,
+                HeaderFilesTOI.TIPO_DOC,
+                HeaderFilesTOI.HASH_FILE,
+                HeaderFilesTOI.IS_FILE,
+                HeaderFilesTOI.FILE_BASENAME,
+                HeaderFilesTOI.FILE_EXTENSION,
+                HeaderFilesTOI.FULL_PATH,
+                HeaderFilesTOI.SRC,
+            ]
+        )
+
+        self.factory_toi: BuilderEntregaTOI = BuilderEntregaTOI()
+
+    def get_factory_toi(self) -> BuilderEntregaTOI:
+        return self.factory_toi
+
+    def create_void(self) -> TableData[HeaderFilesTOI]:
+        """
+        Cria uma tabela com os cabeçalhos de HeaderFilesTOI.
+        """
+        tb = TableData()
+        self.default_cols_cartas.for_each(lambda c: tb.add(ColumnV(c)))
+        return tb
+
+    def from_data(self, df: pd.DataFrame) -> TableData[HeaderFilesTOI]:
+        df = df.astype(str)
+        df_cols = ArrayList(df.columns.tolist())
+        final_table = TableData()
+
+        c: HeaderFilesTOI
+        for c in self.default_cols_cartas:
+
+            if df_cols.contains(c.value):
+                final_table.add(
+                    ColumnV.create_from_list(c, df[c.value].astype(str).values.tolist())
+                )
+
+        if final_table.header().size() != self.default_cols_cartas.size():
+            msg = "DataFrame() FORMS toi com colunas diferente do padrão:"
+            msg_header = f"Cabeçalho FORMS {final_table.header()}"
+            raise HeadersSizeNotIqualError(
+                f"{msg} \n\n{msg_header}\nCabeçalho externo {df.columns}"
+            )
+        return final_table
+
+    def decode_table_toi(
+        self, tb: TableData[HeaderEntregaTOI], data: HashMap[hashFile, File]
+    ) -> TableData[HeaderFilesTOI] | None:
+
+        if data.is_empty():
+            return None
+        if tb.is_empty():
+            return None
+
+        _df_toi = tb.to_dataframe().drop_duplicates(
+            subset=[HeaderEntregaTOI.HASH_FILE.value]
+        )
+
+        tb = self.get_factory_toi().from_data(_df_toi)
+        final_tb = TableData[HeaderFilesTOI].create_void(self.default_cols_cartas)
+
+        rows = tb.rows()
+        r: RowH[HeaderEntregaTOI, Any]
+        row_tb: RowH[HeaderFilesTOI, Any]
+
+        for r in rows:
+            row_tb = RowH(0)
+
+            row_tb.set(HeaderFilesTOI.UC, r.get(HeaderEntregaTOI.UC))
+            row_tb.set(HeaderFilesTOI.TOI, r.get(HeaderEntregaTOI.TOI))
+            row_tb.set(HeaderFilesTOI.DATE, r.get(HeaderEntregaTOI.DATE))
+            row_tb.set(HeaderFilesTOI.DAY, r.get(HeaderEntregaTOI.DAY))
+            row_tb.set(HeaderFilesTOI.MON, r.get(HeaderEntregaTOI.MON))
+            row_tb.set(HeaderFilesTOI.YEAR, r.get(HeaderEntregaTOI.YEAR))
+            row_tb.set(HeaderFilesTOI.HASH_FILE, r.get(HeaderEntregaTOI.HASH_FILE))
+
+            row_tb.set(HeaderFilesTOI.LOCAL_ENTREGA, LocalEntregaCarta.OUTRO)
+            row_tb.set(HeaderFilesTOI.TIPO_DOC, TipoCarta.CARTA_CALCULO)
+
+            # Incluir colunas adicionais.
+            _hash_file = r.get(HeaderEntregaTOI.HASH_FILE)
+            path = data.get_value(_hash_file)
+
+            row_tb.set(HeaderFilesTOI.FILE_BASENAME, path.basename())
+            row_tb.set(
+                HeaderFilesTOI.FILE_EXTENSION,
+                path.extension() or ".nan",
+            )
+            row_tb.set(HeaderFilesTOI.FULL_PATH, path.absolute())
+
+            row_tb.set(HeaderFilesTOI.SRC, path.parent().absolute())
+            row_tb.set(HeaderFilesTOI.IS_FILE, "S" if path.is_file() else "N")
+
+            final_tb.add_row(row_tb)
+
+        if final_tb.is_empty():
+            return None
+
+        _final_df = final_tb.to_dataframe().drop_duplicates(
+            subset=[HeaderFilesTOI.HASH_FILE.value]
+        )
+        return self.from_data(_final_df)
+
+    def from_path_name(
+        self, path: File, md5: hashFile = None
+    ) -> TableData[HeaderFilesTOI] | None:
+
+        if md5 is None:
+            md5 = load_file_hash(path)
+
+        tb_toi = self.get_factory_toi().from_path_name(path, md5)
+        if tb_toi is None:
+            return None
+
+        return self.decode_table_toi(tb_toi, HashMapDict({md5: path}))
+
+    def from_hash_files(
+        self, data: HashMap[hashFile, File], *, ignore_null: bool = True
+    ) -> TableData[HeaderFilesTOI] | None:
+        tb_toi = self.get_factory_toi().from_hash_files(data, ignore_null=ignore_null)
+        if tb_toi is None:
+            return None
+
+        return self.decode_table_toi(tb_toi, data)
+
+
+@dataclass
+class IdNames:
+    """
+    Identificar os índices de cada elemento do nome de uma carta.
+
+    2026 3 03 1488594 193258476 e 1488594 193258476 03 03 2026 são
+
+    a mesma coisa porém nomeado com datas diferentes.
+    """
+
+    year: int = 0
+    mon: int = 1
+    day: int = 2
+    uc: int = 3
+    toi: int = 4
+
+
+def create_table_from_ids(
+    filename: str, md5: hashFile, *, ids: IdNames = IdNames()
+) -> TableData[HeaderEntregaTOI]:
+
+    # Separar os nomes em uma lista
+    list_name: list[str] = filename.split(" ")
+
+    # Gerar a data no formato dia mês ano.
+    dt = f"{list_name[ids.day]} {list_name[ids.mon]} {list_name[ids.year]}"
+
+    row = RowH[HeaderEntregaTOI, str](0)
+    row.set(HeaderEntregaTOI.HASH_FILE, md5)
+    row.set(HeaderEntregaTOI.UC, list_name[ids.uc])
+    row.set(HeaderEntregaTOI.TOI, list_name[ids.toi])
+    row.set(HeaderEntregaTOI.YEAR, list_name[ids.year])
+    row.set(HeaderEntregaTOI.MON, list_name[ids.mon])
+    row.set(HeaderEntregaTOI.DAY, list_name[ids.day])
+    row.set(HeaderEntregaTOI.DATE, dt)
+    tb = BuilderEntregaTOI().create_void()
+    tb.add_row(row)
+    return tb
+
+
+# ========================================================#
+# Relatórios TOI.
+# ========================================================#
+
+
+class ReadWriteTableTOI(object):
+    """
+    Leitura e escrita de dados na TOI em cache. A tabela em cache contém
+    o cabeçalho HeaderEntregaTOI:
+        UC, TOI, DAY, MON, YEAR, DATE E HASH_FILE.
+
+    """
+
+    _instance = None  # Atributo de classe para armazenar a instância singleton
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(ReadWriteTableTOI, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+
+        # Garante que __init__ não será executado mais de uma vez
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        super().__init__()
+
+        self._initialized: bool = True
+        self.builder: BuilderConfigTOI = BuilderConfigTOI()
+        self._tb_toi: TableData[HeaderEntregaTOI] = None
+
+    @property
+    def file_table_toi(self) -> File:
+        return BuilderConfigTOI().builder().file_table_toi
+
+    def set_table_toi(self, tb: TableData[HeaderEntregaTOI]):
+        self._tb_toi = tb
+
+    def get_table_toi(self) -> TableData[HeaderEntregaTOI]:
+        if self._tb_toi is not None:
+            return self._tb_toi
+
+        f = self.file_table_toi
+        if not f.exists():
+            self._tb_toi = BuilderTableFilesTOI().get_factory_toi().create_void()
+            return self._tb_toi
+
+        print(f"Lendo tabela TOI em cache ... {f.absolute()}")
+        data = pd.read_excel(f.absolute())
+        data = data.drop_duplicates(subset=[HeaderFilesTOI.HASH_FILE.value])
+
+        # self._tb_toi = TableTOI.create_from_data(data)
+        self._tb_toi = BuilderEntregaTOI().from_data(data)
+        return self._tb_toi
+
+    def merge(self, tb: TableData[HeaderEntregaTOI]) -> None:
+        if tb.is_empty():
+            return None
+
+        print(f"Mergeando tabela TOI ... {self.file_table_toi.absolute()}")
+        tb_data = tb.to_dataframe().drop_duplicates(subset=[HeaderEntregaTOI.HASH_FILE])
+
+        content_data = (
+            self.get_table_toi()
+            .to_dataframe()
+            .drop_duplicates(subset=[HeaderEntregaTOI.HASH_FILE])
+        )
+
+        final = list()
+        if not tb_data.empty:
+            final.append(tb_data)
+        if not content_data.empty:
+            final.append(content_data)
+
+        if len(final) > 0:
+            df: pd.DataFrame = pd.concat(final)
+            self._tb_toi = BuilderTableFilesTOI().get_factory_toi().from_data(df)
+            self.save()
+
+    def save(self) -> None:
+        data = self.get_table_toi().to_dataframe()
+        path = self.file_table_toi.absolute()
+        tmp_file = f"{path}-tmp.xlsx"
+
+        print(f"Salvando tabela TOI ... {path}")
+        data.to_excel(tmp_file, index=False)
+        rename_file(tmp_file, path)
+
+
+class ControllerTOI(object):
+    """
+        Cria uma tabela de Cartas TOI apartir dos chats do WhatsApp.
+    Conectando os arquivos das conversas aos textos extraídos via OCR.
+
+    TableWhatsApp() é usado para obter DATA e HORA do envio de um arquivo
+    no chat, pois a data de envio no chat e a data de entrega de uma carta em campo.
+    """
+
+    def __init__(self) -> None:
+        self.builder_toi_files: BuilderTableFilesTOI = BuilderTableFilesTOI()
+        self.builder_config: BuilderConfigTOI = BuilderConfigTOI()
+        self.rw: ReadWriteTableTOI = ReadWriteTableTOI()
+
+    @property
+    def relatorio_whatsapp(self) -> ControllerWhatsApp:
+        return self.get_factory_toi().relatorio_wp
+
+    @property
+    def relatorio_ocr(self) -> CreateRelatorioOcr:
+        return self.get_factory_toi().relatorio_ocr
+
+    def get_factory_toi(self) -> BuilderEntregaTOI:
+        return self.builder_toi_files.get_factory_toi()
+
+    # --------------------------------------------------#
+    # Consultar dados - READ
+    # --------------------------------------------------#
+    def load_table_whatsapp(self) -> TableWhatsApp:
+        return self.relatorio_whatsapp.load_cache_table()
+
+    def load_table_toi(self) -> TableData[HeaderEntregaTOI]:
+        return self.rw.get_table_toi()
+
+    def find_on_cache(self, data: HashMap[hashFile, File]) -> TableData[HeaderFilesTOI]:
+        """
+        Procura os textos de cada arquivo na tabela OCR apartir da hash e retorna
+        os dados no formato TableData()
+        """
+
+        if data.is_empty():
+            return self.builder_toi_files.create_void()
+
+        tb_cache: TableData[HeaderEntregaTOI] = self.load_table_toi()
+        if tb_cache.is_empty():
+            return self.builder_toi_files.create_void()
+
+        content_cache: TableData | None = tb_cache.search_all(
+            HeaderEntregaTOI.HASH_FILE, data.header()
+        )
+
+        if content_cache is None:
+            return self.builder_toi_files.create_void()
+
+        df_cache = content_cache.to_dataframe()
+        builder = BuilderEntregaTOI()
+
+        final = self.builder_toi_files.decode_table_toi(
+            builder.from_data(df_cache), data
+        )
+
+        if final is None:
+            return self.builder_toi_files.create_void()
+        return final
+
+    def load_from_map(
+        self, data_map: HashMapDict[hashFile, File], *, ignore_null: bool = True
+    ) -> TableData[HeaderFilesTOI] | None:
+        """
+        I) Usa a HASH MD5 dos arquivos para buscar a data de envio do arquivo na
+        tabela whatsapp;
+
+        II) Gera um relatório OCR com os metadados básicos
+        de cada arquivo;
+
+        III) Obtem a UC e TOI de cada arquivo.
+
+        IV) Retorna uma tabela apartir dos dados gerados.
+
+        Observação:
+            Se o parametro ignore_null for True as linhas que contém UC e TOI inválidos
+        serão ignorados.
+        """
+
+        if data_map.is_empty():
+            return None
+
+        final_table: TableData[HeaderFilesTOI] | None = (
+            self.builder_toi_files.from_hash_files(data_map, ignore_null=ignore_null)
+        )
+        if final_table is None:
+            return None
+
+        df = final_table.to_dataframe().drop_duplicates(
+            subset=[HeaderFilesTOI.HASH_FILE.value]
+        )
+
+        if ignore_null:
+            df = df[df[HeaderFilesTOI.UC] != TableData.NULL_STRING]
+
+        return self.builder_toi_files.from_data(df)
+
+    # --------------------------------------------------#
+    # Criar dados - CREATE
+    # --------------------------------------------------#
+    def add_hashs_on_table(
+        self, hash_files: Set[hashFile], *, ignore_null: bool = True
+    ) -> None:
+        """
+        I) Analisa arquivos TOI apartir da HASH MD5, pesquisa o texto de cada
+        hash na tabela OCR e extrai UC e TOI;
+
+        II) Na sequência, usa a hash para encontrar a data de envio do arquivo no chat
+        do whatsapp;
+
+        III) Inclui os dados TOI de cada arquivo na tabela TOI em cache.
+        """
+        if hash_files.empty():
+            print("Lista de arquivos vazia, nada a fazer!")
+            return None
+
+        # Filtrar
+        tb_cache_ocr: TableData[HeaderOcr] = self.relatorio_ocr.load_table_image()
+        tb_cache_ocr.merge(self.relatorio_ocr.load_table_pdf())
+
+        cache_ocr: TableData[HeaderOcr] | None = tb_cache_ocr.search_all(
+            HeaderOcr.HASH_FILE, hash_files.tolist()
+        )
+
+        if cache_ocr is None:
+            return None
+
+        # cache_ocr = cache_ocr.drop_duplicates()
+        table_whatsapp: TableWhatsApp = self.load_table_whatsapp()
+
+        # Cada arquivo gera/extrai a sua própria tabela, ao final essa
+        # lista de tabelas serão concatenadas em uma tabela única.
+        list_tables_toi = ArrayTables[TableData[HeaderEntregaTOI]]()
+        total = hash_files.size()
+        k: hashFile
+
+        print(f"[Pesquisando texto OCR] em {total} arquivos")
+        for n, k in enumerate(hash_files):
+
+            current_table_ocr: TableData[HeaderOcr] = cache_ocr.search(
+                HeaderOcr.HASH_FILE, k
+            )
+
+            text_ocr: str = None
+
+            if not current_table_ocr.is_empty():
+                text_ocr = current_table_ocr.to_string(HeaderOcr.TEXT)
+
+            txt_uc_toi: tuple | None = (
+                extrair_uc_toi(text_ocr) if text_ocr is not None else None
+            )
+
+            if txt_uc_toi is None:
+                if ignore_null:
+                    continue
+
+            uc = TableData.NULL_STRING
+            toi = TableData.NULL_STRING
+            year = TableData.NULL_STRING
+            mon = TableData.NULL_STRING
+            day = TableData.NULL_STRING
+            dt: str = TableData.NULL_STRING
+
+            if txt_uc_toi is not None:
+                uc = txt_uc_toi[0]
+                toi = txt_uc_toi[1]
+
+            # Obter os dados no arquivo no chat whatsapp apartir da hash md5
+            current_table_whatsapp = table_whatsapp.search(HeaderWhatsApp.hash_md5, k)
+
+            if not current_table_whatsapp.is_empty():
+                # Arquivo encontrado no chat. Extrair dados da data de envio.
+                dt = current_table_whatsapp.get_row_at(0).get_date().get_first()
+                day = dt.split(" ")[0]
+                mon = dt.split(" ")[1]
+                year = dt.split(" ")[2]
+
+            if ignore_null:
+                if dt == TableData.NULL_STRING:
+                    continue
+
+            tb_toi: TableData[HeaderEntregaTOI] = self.get_factory_toi().create_void()
+            row_forms = RowH[HeaderEntregaTOI, Any](0)
+
+            row_forms.set(HeaderEntregaTOI.UC, uc)
+            row_forms.set(HeaderEntregaTOI.TOI, toi)
+            row_forms.set(HeaderEntregaTOI.YEAR, year)
+            row_forms.set(HeaderEntregaTOI.MON, mon)
+            row_forms.set(HeaderEntregaTOI.DAY, day)
+            row_forms.set(HeaderEntregaTOI.DATE, dt)
+            row_forms.set(HeaderEntregaTOI.HASH_FILE, k)
+
+            tb_toi.add_row(row_forms)
+            list_tables_toi.add(tb_toi)
+
+        if list_tables_toi.empty():
+            return None
+
+        final = list_tables_toi.concat(TableData).drop_duplicates()
+        self.rw.merge(final)
+
+    @staticmethod
+    def filter_uc_toi(
+        hf: hashFile, table_ocr_file: TableData[HeaderOcr]
+    ) -> tuple[str, str] | None:
+        """
+        Filtra UC e TOI de uma carta apartir do texto OCR extraído.
+        """
+        tb_current_hash = table_ocr_file.search(HeaderOcr.HASH_FILE, hf)
+        if tb_current_hash.is_empty():
+            return None
+
+        values = tb_current_hash.get(HeaderOcr.TEXT)._elements
+
+        for v in values:
+            txt = extrair_uc_toi(v)
+            if txt is not None:
+                return txt
+        return None
+
+
+def load_files_toi(files: Set[File]) -> TableData[HeaderFilesTOI] | None:
+    """
+    I) Analisa arquivos TOI apartir da HASH MD5;
+    II) Compara o texto na tabela OCR e inclui, UC e TOI na tabela TOI principal;
+    III) Retorna os dados no formato de tabela TOI.
+    """
+
+    if files.empty():
+        print(f"[DEBUG]: load_files_toi() lista de arquivos vazia!")
+        return None
+
+    f: File
+    for f in files:
+        if (not f.is_image()) and (not f.is_pdf()):
+            raise ValueError(
+                f"Tipo de documento TOI inválido, use PDF ou Imagem não: {f.extension()}"
+            )
+
+    data_map = HashMapDict[hashFile, File]()
+    files.for_each(lambda f: data_map.set_value(load_file_hash(f), f))
+
+    controller = ControllerTOI()
+    heder_hash = data_map.header()
+    controller.add_hashs_on_table(heder_hash.to_set())
+    return controller.find_on_cache(data_map)
+
+
+def get_file_log(base_dir: Directory) -> File:
+    _dt = datetime.now()
+    y = str(_dt.year)
+    m = str(_dt.month)
+    day = str(_dt.day)
+    current_date = f"{y}-{m}-{day}"
+    dir_log: Directory = base_dir.concat(y, True).concat(f"{y}-{m}", True)
+    return dir_log.join_file(f"{current_date}.xlsx")
+
+
+def get_date_from_row(r: RowH[HeaderFilesTOI, Any]) -> tuple[str, str, str] | None:
+    """
+    Retorna uma tupla de data no formato (ANO, MÊS, DIA)
+    """
+
+    y = r.get(HeaderFilesTOI.YEAR)
+    m = r.get(HeaderFilesTOI.MON)
+    d = r.get(HeaderFilesTOI.DAY)
+
+    if len(m) > 1:
+        if m[0] == "0":
+            m = m[1]
+
+    values = (y, m, d)
+    i: str
+    for i in values:
+        if not i.isnumeric():
+            return None
+    return values
+
+
+class RenameFilesTOI:
+    """Organiza cartas TOI e registra o resultado de cada movimentação."""
+
+    def __init__(self, files: Set[File]) -> None:
+        self.config: ConfigTOI = BuilderConfigTOI().builder()
+        self.files = files
+        self.file_log: File = get_file_log(self.config.dir_log_excel)
+
+        self.base_cartas: Directory = self.config.dir_base_toi
+        self.error_uc_dir: Directory = self.base_cartas.concat(
+            "CARTAS_UC_NAO_IDENTIFICADAS", True
+        )
+        self.error_date_dir: Directory = self.base_cartas.concat(
+            "CARTAS_DATA_NAO_ENCONTRADA", True
+        )
+
+        self.map_files: HashMapDict[hashFile, File] = HashMapDict()
+        self.table_status = TableData.create_void(
+            [HeaderFilesTOI.HASH_FILE.value, "src", "dest", "status", "exception"]
+        )
+
+    def process_error_ucs(self):
+        tb_wp = ControllerWhatsApp().load_cache_table()
+        content = ContentFiles(self.error_uc_dir)
+        files = content.get_files()
+
+        content_map = HashMapDict[hashFile, File]()
+        files.for_each(lambda f: content_map.set_value(load_file_hash(f), f))
+
+        content_chat = tb_wp.search_all(HeaderWhatsApp.hash_md5, content_map.header())
+
+        if content_chat is None:
+            return
+        if content_chat.is_empty():
+            return
+
+        rows = (
+            BuilderTableWhatsApp().create_from_data(content_chat.to_dataframe()).rows()
+        )
+
+        r: RowWhatsApp
+        for r in rows:
+            h = r.get(HeaderWhatsApp.hash_md5)
+            file_path: File = content_map.get_value(h)
+
+            dt: datetime = r.get_date_hour()
+            y = str(dt.year)
+            m = str(dt.month)
+            d = str(dt.day)
+            _date = f"{y}-{m}-{d}"
+
+            current_dir = self.error_uc_dir.concat(y).concat(m).concat(_date, True)
+            final_path: File = current_dir.join_file(file_path.basename())
+
+            try:
+                move_path(file_path, final_path)
+            except Exception as e:
+                print(f"{__class__.__name__}(): {e}")
+
+    def _index_files(self) -> None:
+        """Indexa os arquivos originais por hash."""
+        for file in self.files:
+            self.map_files.set_value(load_file_hash(file), file)
+
+    def _create_status_row(self, file_hash: hashFile, src: File, dest: File) -> RowH:
+        row = RowH(0)
+        row.set(HeaderFilesTOI.HASH_FILE.value, file_hash)
+        row.set("src", src.absolute())
+        row.set("dest", dest.absolute())
+        return row
+
+    def _move(self, file_hash: hashFile, src: File, dest: File) -> bool:
+        """Move o arquivo e registra o resultado real da operação."""
+        row = self._create_status_row(file_hash, src, dest)
+
+        try:
+            if not move_path(src, dest):
+                raise OSError(
+                    f"move_path retornou False: {src.absolute()} -> {dest.absolute()}"
+                )
+        except Exception as exc:
+            row.set("status", "FALHA")
+            row.set("exception", str(exc))
+            success = False
+        else:
+            row.set("status", "SUCESSO")
+            row.set("exception", "")
+            success = True
+
+        self.table_status.add_row(row)
+        return success
+
+    @staticmethod
+    def _is_missing(value: Any) -> bool:
+        return (
+            value is None
+            or pd.isna(value)
+            or value == TableData.NULL_STRING
+            or str(value).strip() == ""
+        )
+
+    def _get_destination(self, row: RowH) -> tuple[Directory, str]:
+        """Define o destino com prioridade para a ausência de UC."""
+        uc = row.get(HeaderFilesTOI.UC)
+        toi = row.get(HeaderFilesTOI.TOI)
+        date = get_date_from_row(row)
+
+        if self._is_missing(uc):
+            return self.error_uc_dir, str(row.get(HeaderFilesTOI.HASH_FILE))
+
+        if date is None:
+            return self.error_date_dir, f"{uc} {toi}"
+
+        year, month, day = date
+        dest_dir = (
+            self.base_cartas.concat(year)
+            .concat(f"{year}-{month}")
+            .concat(f"{year}-{month}-{day}", True)
+        )
+        return dest_dir, f"{year} {month} {day} {uc} {toi}"
+
+    def _process_identified_files(self) -> Set[hashFile]:
+        """Processa os arquivos que possuem registro na tabela TOI."""
+        controller = ControllerTOI()
+        controller.add_hashs_on_table(self.map_files.header().to_set())
+        table_files = controller.find_on_cache(self.map_files)
+
+        processed = Set[hashFile]()
+
+        for row in table_files.rows():
+            file_hash: hashFile = row.get(HeaderFilesTOI.HASH_FILE)
+            src: File = self.map_files.get_value(file_hash)
+
+            if src is None:
+                continue
+
+            processed.add(file_hash)
+            dest_dir, output_name = self._get_destination(row)
+            dest = dest_dir.join_file(f"{output_name}{src.extension()}")
+
+            self._move(file_hash, src, dest)
+
+        return processed
+
+    def _process_unidentified_files(self, processed: Set[hashFile]) -> None:
+        """Encaminha para a pasta de UC os arquivos sem registro TOI."""
+        for file_hash in self.map_files.header():
+            if processed.contains(file_hash):
+                continue
+
+            src: File = self.map_files.get_value(file_hash)
+            extension = src.extension() or ".nan"
+            dest = self.error_uc_dir.join_file(f"{file_hash}{extension}")
+
+            self._move(file_hash, src, dest)
+
+    def _save_log(self) -> pd.DataFrame:
+        """Acumula os resultados no relatório existente."""
+        sequence = ArrayTables[TableData]()
+        sequence.add(self.table_status)
+
+        if self.file_log.exists():
+            df_previous = pd.read_excel(self.file_log.absolute())
+            sequence.add(TableData(df_previous))
+
+        df_final = sequence.concat(TableData).to_dataframe()
+        df_final.drop_duplicates(inplace=True)
+
+        print(f"Salvando: {self.file_log}")
+        df_final.to_excel(self.file_log.absolute(), index=False)
+        return df_final
+
+    def execute(self) -> pd.DataFrame:
+        if self.files.empty():
+            return self.table_status.to_dataframe()
+
+        self._index_files()
+        processed = self._process_identified_files()
+        self._process_unidentified_files(processed)
+        return self._save_log()
+
+
+def rename_files_toi(files: Set[File]) -> RenameFilesTOI:
+    """Renomear arquivos TOI"""
+
+    rn = RenameFilesTOI(files)
+    rn.execute()
+    rn.process_error_ucs()
+    return rn