iatoolkit 0.8.1__py3-none-any.whl → 0.63.4__py3-none-any.whl

tests/repositories/test_tasks_repo.py

@@ -1,76 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from iatoolkit.repositories.tasks_repo import TaskRepo
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.models import Task, TaskType, Company, TaskStatus
-from iatoolkit.repositories.database_manager import DatabaseManager
-
-
-class TestTaskRepo:
-    def setup_method(self):
-        self.db_manager = DatabaseManager('sqlite:///:memory:')
-        self.db_manager.create_all()
-        self.session = self.db_manager.get_session()
-        self.profile_repo = ProfileRepo(self.db_manager)
-
-
-        self.company = Company(name='opensoft', short_name='open')
-        self.profile_repo.create_company(self.company)
-
-        self.task_type = TaskType(name="dummy_type")
-        self.task = Task(id=1, task_type_id=1, company_id=self.company.id)
-
-        self.repo = TaskRepo(self.db_manager)
-
-
-    def test_create_task(self):
-        result = self.repo.create_task(self.task)
-
-        task_in_db = self.session.query(Task).filter_by(id=self.task.id).first()
-
-        assert task_in_db is not None
-        assert task_in_db.id == self.task.id
-        assert task_in_db.task_type_id == self.task.task_type_id
-        assert task_in_db.company_id == self.task.company_id
-        assert result == task_in_db
-
-    def test_update_task(self):
-        self.repo.create_task(self.task)
-
-        # update value
-        self.task.client_data = {'key': 'value'}
-        result = self.repo.update_task(self.task)
-
-        task_in_db = self.session.query(Task).filter_by(id=self.task.id).first()
-        assert task_in_db.client_data == self.task.client_data
-
-    def test_create_or_update_task_type_creates_new(self):
-        result = self.repo.create_or_update_task_type(self.task_type)
-        assert result == self.task_type
-
-    def test_create_or_update_task_type_updates_existing(self):
-        existing_type = TaskType(name="dummy_type", prompt_template="old_template", template_args="old_args")
-        self.repo.create_or_update_task_type(existing_type)
-
-
-        new_type = TaskType(name="dummy_type", prompt_template="new_template", template_args="new_args")
-        result = self.repo.create_or_update_task_type(new_type)
-
-        assert existing_type.prompt_template == "new_template"
-        assert existing_type.template_args == "new_args"
-        assert result == existing_type
-
-    def test_get_task_type_when_found(self):
-        result = self.repo.get_task_type("dummy_type")
-        assert result == None
-
-    def test_get_pending_tasks(self):
-        self.task.status = TaskStatus.pendiente
-        self.repo.create_task(self.task)
-
-        result = self.repo.get_pending_tasks(self.company.id)
-        assert len(result) == 1
-

tests/repositories/test_vs_repo.py

@@ -1,107 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock, patch
-from iatoolkit.common.exceptions import IAToolkitException
-from iatoolkit.repositories.vs_repo import VSRepo
-from iatoolkit.repositories.models import VSDoc, Document
-
-
-class TestVSRepo:
-    @pytest.fixture
-    def mock_db_manager(self):
-        """Fixture para mockear el DatabaseManager."""
-        mock_manager = MagicMock()
-        mock_session = MagicMock()
-        mock_manager.get_session.return_value = mock_session
-        return mock_manager
-
-    @pytest.fixture
-    def mock_embedder(self):
-        """Fixture para mockear el modelo de SentenceTransformer."""
-        with patch('iatoolkit.repositories.vs_repo.InferenceClient') as MockEmbedder:
-            mock_instance = MockEmbedder.return_value
-            mock_instance.feature_extraction.return_value = [0.1, 0.2, 0.3]  # Retorna un embedding simulado
-            yield mock_instance
-
-    @pytest.fixture
-    def vs_repo(self, mock_db_manager, mock_embedder):
-        """Fixture para inicializar el repositorio VSRepo con dependencias mockeadas."""
-        return VSRepo(mock_db_manager)
-
-    def test_add_document_rollback_on_error(self, vs_repo, mock_db_manager, mock_embedder):
-        """Prueba que verifica el rollback cuando ocurre un error en add_document."""
-        mock_session = mock_db_manager.get_session.return_value
-
-        mock_embedder.feature_extraction.side_effect = Exception("Error al generar embeddings")
-        vs_chunk_list = [VSDoc(id=1, text="Documento con error")]
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            vs_repo.add_document(vs_chunk_list)
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.VECTOR_STORE_ERROR
-        assert "Error insertando documentos en PostgreSQL" in str(excinfo.value)
-        mock_session.rollback.assert_called_once()
-
-    def test_add_document_success(self, vs_repo, mock_db_manager, mock_embedder):
-        mock_session = mock_db_manager.get_session.return_value
-
-        vs_chunk_list = [
-            VSDoc(id=1, text="Documento de prueba 1"),
-            VSDoc(id=2, text="Documento de prueba 2")
-        ]
-
-        vs_repo.add_document(vs_chunk_list)
-
-        # Verificar que las embeddings se generaron y los documentos fueron añadidos
-        assert mock_embedder.feature_extraction.call_count == len(vs_chunk_list)
-        assert mock_session.add.call_count == len(vs_chunk_list)
-        mock_session.commit.assert_called_once()
-
-
-    def test_query_raises_exception_on_error(self, vs_repo, mock_db_manager, mock_embedder):
-        mock_session = mock_db_manager.get_session.return_value
-        mock_session.execute.side_effect = Exception("Error en la base de datos")
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            vs_repo.query(company_id=123, query_text="texto de prueba", n_results=3)
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.VECTOR_STORE_ERROR
-        assert "Error en la consulta" in str(excinfo.value)
-
-    def test_query_success(self, vs_repo, mock_db_manager, mock_embedder):
-        mock_session = mock_db_manager.get_session.return_value
-
-        # Simular resultados de la consulta en la base de datos
-        mock_session.execute.return_value.fetchall.return_value = [
-            (1, "filename1.txt", "contenido1", 'conb64'),
-            (2, "filename2.txt", "contenido2", 'conb64')
-        ]
-
-        result = vs_repo.query(company_id=123, query_text="prompt_llm.txt de prueba", n_results=2)
-
-        # Verificar resultados
-        assert len(result) == 2
-        assert result[0].id == 1
-        assert result[0].filename == "filename1.txt"
-        assert result[0].content == "contenido1"
-        mock_embedder.feature_extraction.assert_called_once_with(["prompt_llm.txt de prueba"])
-
-
-    def test_remove_duplicates_by_id(self, vs_repo):
-        """Prueba para verificar la eliminación de duplicados por ID."""
-        documents = [
-            Document(id=1, company_id=123, filename="doc1.txt", content="contenido1", content_b64=''),
-            Document(id=2, company_id=123, filename="doc2.txt", content="contenido2", content_b64=''),
-            Document(id=1, company_id=123, filename="doc1.txt", content="contenido1", content_b64=''),  # Duplicado
-        ]
-
-        result = vs_repo.remove_duplicates_by_id(documents)
-
-        # Verificar que solo queden 2 documentos
-        assert len(result) == 2
-        assert result[0].id == 1
-        assert result[1].id == 2

tests/services/__init__.py

@@ -1,5 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-

tests/services/test_dispatcher_service.py

@@ -1,274 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-
-import pytest
-from unittest.mock import MagicMock, patch
-from injector import Injector
-from iatoolkit.base_company import BaseCompany
-from iatoolkit.company_registry import get_company_registry, register_company
-from iatoolkit.services.dispatcher_service import Dispatcher
-from iatoolkit.common.exceptions import IAToolkitException
-from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.models import Company, Function
-from iatoolkit.services.excel_service import ExcelService
-from iatoolkit.services.prompt_manager_service import PromptService
-from iatoolkit.services.mail_service import MailService
-from iatoolkit.common.util import Utility
-
-
-# A mock company class for testing purposes
-class MockSampleCompany(BaseCompany):
-    def register_company(self): pass
-
-    def get_company_context(self, **kwargs) -> str: return "Company Context for Sample"
-
-    def handle_request(self, tag: str, params: dict) -> dict: return {"result": "sample_company_response"}
-
-    def start_execution(self): pass
-
-    def get_user_info(self, user_identifier: str): pass
-
-    def get_metadata_from_filename(self, filename: str) -> dict: return {}
-
-
-class TestDispatcher:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """Set up mocks, registry, and the Dispatcher for tests."""
-        # Clean up the registry before each test to prevent interference
-        registry = get_company_registry()
-        registry.clear()
-
-        # Mocks for services that are injected into the Dispatcher
-        self.mock_prompt_manager = MagicMock()
-        self.mock_llm_query_repo = MagicMock(spec=LLMQueryRepo)
-        self.excel_service = MagicMock(spec=ExcelService)
-        self.mail_service = MagicMock(spec=MailService)
-        self.util = MagicMock(spec=Utility)
-        self.mock_profile_repo = MagicMock(spec=ProfileRepo)
-
-
-        # Create a mock injector that will be used for instantiation.
-        mock_injector = Injector()
-        mock_injector.binder.bind(ProfileRepo, to=self.mock_profile_repo)
-        mock_injector.binder.bind(LLMQueryRepo, to=self.mock_llm_query_repo)
-        mock_injector.binder.bind(PromptService, to=self.mock_prompt_manager)
-
-        # Create a mock IAToolkit instance that returns our injector.
-        self.toolkit_mock = MagicMock()
-        self.toolkit_mock.get_injector.return_value = mock_injector
-
-        # Patch IAToolkit.get_instance() to return our mock toolkit. This must be active
-        # BEFORE any code that depends on the IAToolkit singleton is run.
-        self.get_instance_patcher = patch('iatoolkit.iatoolkit.IAToolkit.get_instance',
-                                          return_value=self.toolkit_mock)
-        self.get_instance_patcher.start()
-
-        # Now we can safely instantiate our mock company.
-        self.mock_sample_company_instance = MockSampleCompany()
-
-        # Mock methods that will be called
-        self.mock_sample_company_instance.register_company = MagicMock()
-        self.mock_sample_company_instance.handle_request = MagicMock(return_value={"result": "sample_company_response"})
-        self.mock_sample_company_instance.get_company_context = MagicMock(return_value="Company Context for Sample")
-        self.mock_sample_company_instance.start_execution = MagicMock(return_value=True)
-        self.mock_sample_company_instance.get_user_info = MagicMock(return_value={"email": "test@user.com"})
-        self.mock_sample_company_instance.get_metadata_from_filename = MagicMock(return_value={"meta": "data"})
-
-        # Register the mock company class
-        register_company("sample", MockSampleCompany)
-
-        # Bind the mock instance in our injector. When the registry asks for an instance of
-        # MockSampleCompany, the injector will return our pre-configured mock instance.
-        mock_injector.binder.bind(MockSampleCompany, to=self.mock_sample_company_instance)
-
-        # Instantiate all registered companies. The registry will use our mock_injector.
-        registry.instantiate_companies(mock_injector)
-
-        # Initialize the Dispatcher within the patched context
-        self.dispatcher = Dispatcher(
-            prompt_service=self.mock_prompt_manager,
-            llmquery_repo=self.mock_llm_query_repo,
-            util=self.util,
-            excel_service=self.excel_service,
-            mail_service=self.mail_service,
-        )
-
-
-    def teardown_method(self, method):
-        """Clean up patches after each test."""
-        if hasattr(self, 'get_instance_patcher'):
-            self.get_instance_patcher.stop()
-
-        # Clean up the registry
-        registry = get_company_registry()
-        registry.clear()
-
-    def test_dispatch_sample_company(self):
-        """Tests that dispatch works correctly for a valid company."""
-        result = self.dispatcher.dispatch("sample", "some_data", key='a value')
-        self.mock_sample_company_instance.handle_request.assert_called_once_with("some_data", key='a value')
-        assert result == {"result": "sample_company_response"}
-
-    def test_dispatch_invalid_company(self):
-        """Tests that dispatch raises an exception for an unconfigured company."""
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.dispatcher.dispatch("invalid_company", "some_tag")
-        assert "Empresa 'invalid_company' no configurada" in str(excinfo.value)
-
-    def test_dispatch_method_exception(self):
-        """Validates that the dispatcher handles exceptions thrown by companies."""
-        self.mock_sample_company_instance.handle_request.side_effect = Exception("Method error")
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.dispatcher.dispatch("sample", "some_data")
-
-        assert "Error en function call 'some_data'" in str(excinfo.value)
-        assert "Method error" in str(excinfo.value)
-
-    def test_dispatch_system_function(self):
-        """Tests that dispatch correctly handles system functions."""
-        self.excel_service.excel_generator.return_value = {"file": "test.xlsx"}
-
-        result = self.dispatcher.dispatch("sample", "iat_generate_excel", filename="test.xlsx")
-
-        self.excel_service.excel_generator.assert_called_once_with(filename="test.xlsx")
-        self.mock_sample_company_instance.handle_request.assert_not_called()
-        assert result == {"file": "test.xlsx"}
-
-    def test_get_company_context(self):
-        """Tests that get_company_context works correctly."""
-        # Simulate no context files to simplify
-        self.util.get_files_by_extension.return_value = []
-
-        params = {"param1": "value1"}
-        result = self.dispatcher.get_company_context("sample", **params)
-
-        self.mock_sample_company_instance.get_company_context.assert_called_once_with(**params)
-        assert "Company Context for Sample" in result
-
-    def test_get_company_instance(self):
-        """Tests that get_company_instance returns the correct company instance."""
-        instance = self.dispatcher.get_company_instance("sample")
-        assert instance == self.mock_sample_company_instance
-
-        instance_none = self.dispatcher.get_company_instance("non_existent")
-        assert instance_none is None
-
-    def test_get_metadata_from_filename_success(self):
-        """Tests that get_metadata_from_filename successfully calls the company's method."""
-        filename = "test.txt"
-        expected_metadata = {"meta": "data"}
-        self.mock_sample_company_instance.get_metadata_from_filename.return_value = expected_metadata
-
-        result = self.dispatcher.get_metadata_from_filename("sample", filename)
-
-        self.mock_sample_company_instance.get_metadata_from_filename.assert_called_once_with(filename)
-        assert result == expected_metadata
-
-    def test_get_metadata_from_filename_invalid_company(self):
-        """Tests get_metadata_from_filename with an invalid company."""
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.dispatcher.get_metadata_from_filename("invalid_company", "test.txt")
-        assert "Empresa no configurada: invalid_company" in str(excinfo.value)
-
-    def test_get_metadata_from_filename_company_exception(self):
-        """Tests get_metadata_from_filename when the company method raises an exception."""
-        self.mock_sample_company_instance.get_metadata_from_filename.side_effect = Exception("Company error")
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.dispatcher.get_metadata_from_filename("sample", "test.txt")
-        assert "Error en get_metadata_from_filename de sample" in str(excinfo.value)
-
-
-    def test_get_user_info_external_user(self):
-        """Tests get_user_info for an external user."""
-        user_identifier = "ext_user_123"
-        expected_user_data = {"email": "external@example.com"}
-        self.mock_sample_company_instance.get_user_info.return_value = expected_user_data
-
-        result = self.dispatcher.get_user_info("sample", user_identifier, is_local_user=False)
-
-        self.mock_sample_company_instance.get_user_info.assert_called_once_with(user_identifier)
-        assert result["user_email"] == "external@example.com"
-        assert not result["is_local"]
-
-    def test_get_user_info_external_user_company_exception(self):
-        """Tests get_user_info for an external user when the company method fails."""
-        self.mock_sample_company_instance.get_user_info.side_effect = Exception("DB error")
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.dispatcher.get_user_info("sample", "ext_user_123", is_local_user=False)
-        assert "Error en get_user_info de sample" in str(excinfo.value)
-
-    @patch('iatoolkit.services.dispatcher_service.SessionManager')
-    def test_get_user_info_local_user(self, mock_session_manager):
-        """Tests get_user_info for a local user from session."""
-        user_identifier = "local_user_1"
-        session_data = {"email": "local@iatoolkit.com", "user_fullname": "Local User"}
-        mock_session_manager.get.return_value = session_data
-
-        result = self.dispatcher.get_user_info("sample", user_identifier, is_local_user=True)
-
-        mock_session_manager.get.assert_called_once_with('user', {})
-        self.mock_sample_company_instance.get_user_info.assert_not_called()
-        assert result["user_email"] == "local@iatoolkit.com"
-        assert result["user_fullname"] == "Local User"
-        assert result["is_local"]
-
-    def test_get_user_info_invalid_company(self):
-        """Tests get_user_info with an invalid company."""
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.dispatcher.get_user_info("invalid_company", "any_user", is_local_user=False)
-        assert "Empresa no configurada: invalid_company" in str(excinfo.value)
-
-    def test_get_company_services(self):
-        """Tests that get_company_services returns a correctly formatted list of tools."""
-        # Mock Company and Function objects
-        mock_company = MagicMock(spec=Company)
-        mock_function = MagicMock(spec=Function)
-        mock_function.name = "test_function"
-        mock_function.description = "A test function"
-        mock_function.parameters = {"type": "object", "properties": {}}
-
-        self.mock_llm_query_repo.get_company_functions.return_value = [mock_function]
-
-        tools = self.dispatcher.get_company_services(mock_company)
-
-        self.mock_llm_query_repo.get_company_functions.assert_called_once_with(mock_company)
-        assert len(tools) == 1
-        tool = tools[0]
-        assert tool["type"] == "function"
-        assert tool["name"] == "test_function"
-        assert tool["description"] == "A test function"
-        assert tool["parameters"]["additionalProperties"] is False
-        assert tool["strict"] is True
-
-    def test_dispatcher_with_no_companies_registered(self):
-        """Tests that the dispatcher works if no company is registered."""
-        # Stop the current patch first
-        self.get_instance_patcher.stop()
-
-        # Clean registry
-        get_company_registry().clear()
-
-        toolkit_mock = MagicMock()
-        toolkit_mock.get_injector.return_value = Injector()  # Empty injector
-
-        # Start a new patch for this specific test
-        with patch('iatoolkit.iatoolkit.IAToolkit.get_instance', return_value=toolkit_mock):
-            dispatcher = Dispatcher(
-                prompt_service=self.mock_prompt_manager,
-                llmquery_repo=self.mock_llm_query_repo,
-                util=self.util,
-                excel_service=self.excel_service,
-                mail_service=self.mail_service,
-            )
-
-            assert len(dispatcher.company_instances) == 0
-
-            with pytest.raises(IAToolkitException) as excinfo:
-                dispatcher.dispatch("any_company", "some_action")
-            assert "Empresa 'any_company' no configurada" in str(excinfo.value)
-
-        # Restart the main patch for subsequent tests
-        self.get_instance_patcher.start()

tests/services/test_document_service.py

@@ -1,181 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import patch, MagicMock
-from iatoolkit.services.document_service import DocumentService
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestDocumentService:
-
-    @pytest.fixture(autouse=True)
-    def setup_env_vars(self, monkeypatch):
-        """
-        Configura las variables de entorno necesarias para DocumentService
-        antes de cada test.
-        """
-        monkeypatch.setenv("MAX_DOC_PAGES", "10")
-
-    def test_initialization(self):
-        """Prueba la inicialización de DocumentService con configuración correcta."""
-        service = DocumentService()
-        assert service.max_doc_pages == 10
-
-    def test_file_txt_when_binary_content(self):
-        service = DocumentService()
-        result = service.file_to_txt("test.txt", b"dummy_content")
-        assert result == "dummy_content"
-
-    def test_file_txt_when_binary_content_and_error_decoding(self):
-        service = DocumentService()
-        with pytest.raises(IAToolkitException) as excinfo:
-            result = service.file_to_txt("test.txt", b'\xff\xfe\xff'
-)
-        assert "FILE_FORMAT_ERROR" == excinfo.value.error_type.name
-
-    def test_file_txt_when_txt_content(self):
-        service = DocumentService()
-        result = service.file_to_txt("test.txt", "dummy_content")
-        assert result == "dummy_content"
-
-    @patch("iatoolkit.services.document_service.DocumentService.is_scanned_pdf")
-    @patch("iatoolkit.services.document_service.DocumentService.read_scanned_pdf", return_value="Scanned text")
-    @patch("iatoolkit.services.document_service.DocumentService.read_pdf", return_value="PDF text")
-    def test_extension_file_detection(
-            self, mock_read_pdf, mock_read_scanned_pdf, mock_is_scanned_pdf):
-
-        mock_is_scanned_pdf.return_value = True
-        service = DocumentService()
-        result = service.file_to_txt("test.pdf", "dummy_content")
-
-        assert result == "Scanned text"
-
-        mock_is_scanned_pdf.return_value = False
-        result = service.file_to_txt("test.pdf", "dummy_content")
-        assert result == "PDF text"
-
-
-    @patch("iatoolkit.services.document_service.io")
-    @patch("iatoolkit.services.document_service.Document")
-    def test_read_docx_successful(self, mock_document, mock_io):
-        """Prueba que un archivo .docx se lea correctamente."""
-        mock_io.BytesIO.return_value = b'a file'
-        mock_doc = MagicMock()
-        mock_doc.paragraphs = [
-            MagicMock(text="First paragraph"),
-            MagicMock(text="Second paragraph"),
-        ]
-        mock_document.return_value = mock_doc
-
-        service = DocumentService()
-        content = service.read_docx("dummy_docx_content")
-        assert content == "# First paragraph\n\n# Second paragraph\n\n"
-
-    @patch("iatoolkit.services.document_service.fitz.open")
-    def test_read_pdf_successful(self, mock_fitz_open):
-        """Prueba que un archivo PDF con prompt_llm.txt se lea correctamente."""
-        mock_pdf = MagicMock()
-        mock_pdf.__enter__.return_value = mock_pdf
-        mock_pdf.__iter__.return_value = [
-            MagicMock(get_text=MagicMock(return_value="Page 1 text")),
-            MagicMock(get_text=MagicMock(return_value="Page 2 text")),
-        ]
-        mock_fitz_open.return_value = mock_pdf
-
-        service = DocumentService()
-        content = service.read_pdf("dummy_pdf_content")
-        assert content == "Page 1 textPage 2 text"
-
-    @patch("iatoolkit.services.document_service.pytesseract.image_to_string", return_value="Scanned text")
-    @patch("iatoolkit.services.document_service.Image.frombytes")
-    @patch("iatoolkit.services.document_service.fitz.Pixmap")
-    @patch("iatoolkit.services.document_service.fitz.open")
-    def test_read_scanned_pdf(self, mock_fitz_open, mock_pixmap, mock_frombytes, mock_tesseract):
-        """Prueba que un PDF escaneado convierta imágenes en prompt_llm.txt correctamente."""
-        mock_pdf = MagicMock()
-        mock_pdf.page_count = 2
-        mock_pdf.__len__.return_value = 1
-        mock_fitz_open.return_value = mock_pdf
-
-        mock_pdf.__iter__.return_value = [
-            MagicMock(get_images=MagicMock(return_value=[(1,)]))
-        ]
-        mock_pdf.__getitem__.return_value = MagicMock(get_images=MagicMock(return_value=[(1,)]))
-
-        mock_pixmap_obj = MagicMock()
-        mock_pixmap.return_value = mock_pixmap_obj
-
-        # Simular retorno de atributos del Pixmap
-        mock_pixmap_obj.n = 3
-        mock_pixmap_obj.width = 100
-        mock_pixmap_obj.height = 100
-        mock_pixmap_obj.samples = b"dummy_pixels"
-
-        mock_fitz_open.return_value[0].get_images.return_value = [(1,)]
-        mock_fitz_open.return_value[0].__getitem__ = MagicMock(return_value=mock_pixmap)
-
-        service = DocumentService()
-        content = service.read_scanned_pdf(b"dummy_scanned_pdf_content")
-        assert content == "Scanned text"
-
-    @patch("iatoolkit.services.document_service.fitz.open")  # Parcheamos fitz.open
-    def test_is_scanned_pdf_with_selectable_text(self, mock_fitz_open):
-        """Prueba que un PDF con prompt_llm.txt seleccionable retorne False."""
-        # Mock del documento PDF con prompt_llm.txt seleccionable
-        mock_pdf = MagicMock()
-        mock_pdf.__len__.return_value = 1  # Simula 1 página
-        mock_page = MagicMock()
-        mock_page.get_text.return_value = "This is some selectable text"
-        mock_pdf.__getitem__.return_value = mock_page
-        mock_fitz_open.return_value = mock_pdf
-
-        service = DocumentService()
-        result = service.is_scanned_pdf(b"dummy_pdf_content")
-        assert result is False  # Tiene prompt_llm.txt seleccionable, no es escaneado
-
-    @patch("iatoolkit.services.document_service.fitz.open")  # Parcheamos fitz.open
-    def test_is_scanned_pdf_with_scanned_images(self, mock_fitz_open):
-        """Prueba que un PDF con imágenes (escaneado) retorne True."""
-        # Mock del documento PDF con imágenes
-        mock_pdf = MagicMock()
-        mock_pdf.__len__.return_value = 1  # Simula 1 página
-        mock_page = MagicMock()
-        mock_page.get_text.return_value = ""  # No hay prompt_llm.txt
-        mock_page.get_images.return_value = [(1,)]  # Hay imágenes
-        mock_pdf.__getitem__.return_value = mock_page
-        mock_fitz_open.return_value = mock_pdf
-
-        service = DocumentService()
-        result = service.is_scanned_pdf(b"dummy_pdf_content")
-        assert result is True  # Escaneado, tiene imágenes pero no prompt_llm.txt
-
-    @patch("iatoolkit.services.document_service.fitz.open")  # Parcheamos fitz.open
-    def test_is_scanned_pdf_without_text_or_images(self, mock_fitz_open):
-        """Prueba que un PDF sin prompt_llm.txt y sin imágenes retorne True."""
-        # Mock del documento PDF vacío (no tiene prompt_llm.txt ni imágenes)
-        mock_pdf = MagicMock()
-        mock_pdf.__len__.return_value = 1  # Simula 1 página
-        mock_page = MagicMock()
-        mock_page.get_text.return_value = ""  # No hay prompt_llm.txt
-        mock_page.get_images.return_value = []  # No hay imágenes
-        mock_pdf.__getitem__.return_value = mock_page
-        mock_fitz_open.return_value = mock_pdf
-
-        service = DocumentService()
-        result = service.is_scanned_pdf(b"dummy_pdf_content")
-        assert result is True  # No tiene prompt_llm.txt ni imágenes, probablemente escaneado
-
-    @patch("iatoolkit.services.document_service.fitz.open")  # Parcheamos fitz.open
-    def test_is_scanned_pdf_with_empty_pdf(self, mock_fitz_open):
-        """Prueba que un PDF vacío (sin páginas) retorne True."""
-        # Mock del documento PDF vacío (sin páginas)
-        mock_pdf = MagicMock()
-        mock_pdf.__len__.return_value = 0  # Sin páginas
-        mock_fitz_open.return_value = mock_pdf
-
-        service = DocumentService()
-        result = service.is_scanned_pdf(b"dummy_pdf_content")
-        assert result is True  # Al no tener páginas, se considera escaneado