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

tests/repositories/test_database_manager.py

@@ -1,87 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from unittest.mock import patch, MagicMock
-from iatoolkit.repositories.database_manager import DatabaseManager
-import pytest
-
-class TestDatabaseManager:
-    def setup_method(self):
-        self.mock_engine = MagicMock()
-        self.mock_sessionmaker = MagicMock()
-        self.mock_scoped_session = MagicMock()
-        self.mock_base_metadata = MagicMock()
-        self.mock_inspect = MagicMock()
-
-        self.database_url = "sqlite:///:memory:"
-
-        # Lista para almacenar todos los patches
-        self.patchers = []
-
-        # Crear y agregar patches a la lista
-        patcher_engine = patch('iatoolkit.repositories.database_manager.create_engine', return_value=self.mock_engine)
-        patcher_sessionmaker = patch('iatoolkit.repositories.database_manager.sessionmaker', return_value=self.mock_sessionmaker)
-        patcher_scoped_session = patch('iatoolkit.repositories.database_manager.scoped_session',
-                                       return_value=self.mock_scoped_session)
-        patcher_metadata = patch('iatoolkit.repositories.database_manager.Base.metadata', self.mock_base_metadata)
-        patcher_inspect = patch('iatoolkit.repositories.database_manager.inspect', self.mock_inspect)
-
-        self.patchers.extend(
-            [patcher_engine, patcher_sessionmaker, patcher_scoped_session, patcher_metadata, patcher_inspect])
-
-        # Inicia todos los patches y almacena los mocks retornados si es necesario
-        self.mock_create_engine = patcher_engine.start()
-        self.mock_sessionmaker_function = patcher_sessionmaker.start()
-        self.mock_scoped_session_function = patcher_scoped_session.start()
-        self.mock_inspect = patcher_inspect.start()
-        patcher_metadata.start()
-
-        self.db_manager = DatabaseManager(self.database_url)
-
-    def teardown_method(self):
-        for patcher in self.patchers:
-            patcher.stop()
-
-    def test_init_initializes_engine_and_session_factory(self):
-        self.mock_create_engine.assert_called_once_with(self.database_url, echo=False)
-        self.mock_sessionmaker_function.assert_called_once_with(bind=self.mock_engine)
-
-    def test_get_session_returns_scoped_session(self):
-        session = self.db_manager.get_session()
-        assert session == self.mock_scoped_session()
-
-    def test_create_all_calls_metadata_create_all(self):
-        self.db_manager.create_all()
-        assert self.mock_base_metadata.create_all.call_count == 1
-
-    def test_drop_all_calls_metadata_drop_all(self):
-        self.db_manager.drop_all()
-        self.mock_base_metadata.drop_all.assert_called_once_with(self.mock_engine)
-
-    def test_remove_session_calls_scoped_session_remove(self):
-        self.db_manager.remove_session()
-        self.mock_scoped_session.remove.assert_called_once()
-
-    def test_get_table_schema_table_exists(self):
-        """Prueba get_table_schema cuando la tabla existe"""
-        self.mock_inspect.return_value.get_table_names.return_value = ['test_table']
-        self.mock_inspect.return_value.get_columns.return_value = [
-            {"name": "id", "type": "INTEGER"},
-            {"name": "name", "type": "VARCHAR"}
-        ]
-
-        result = self.db_manager.get_table_schema('test_table')
-
-        # Verificar que el resultado contiene la información esperada
-        assert "{'table': 'test_table', 'description': 'Definición de la tabla test_table.', 'fields': [{'name': 'id', 'type': 'INTEGER'}, {'name': 'name', 'type': 'VARCHAR'}]}" == result.strip()
-
-    def test_get_table_schema_table_not_exists(self):
-        """Prueba get_table_schema cuando la tabla no existe"""
-        self.mock_inspect.return_value.get_table_names.return_value = []
-
-        with pytest.raises(RuntimeError) as exc_info:
-            self.db_manager.get_table_schema('non_existent_table')
-
-        assert "La tabla 'non_existent_table' no existe en la BD" in str(exc_info.value)

tests/repositories/test_document_repo.py

@@ -1,76 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock
-from iatoolkit.repositories.models import Document, Company
-from iatoolkit.repositories.document_repo import DocumentRepo
-from iatoolkit.common.exceptions import IAToolkitException
-import base64
-
-
-class TestDocumentRepo:
-    def setup_method(self):
-        # Mock the DatabaseManager
-        self.mock_db_manager = MagicMock()
-        self.session = self.mock_db_manager.get_session()
-
-        # Initialize DocumentRepo with the mocked DatabaseManager
-        self.repo = DocumentRepo(self.mock_db_manager)
-        self.mock_document = Document(company_id=1,
-                                 filename='test.txt',
-                                 content='123',
-                                 content_b64=base64.b64encode('123'.encode('utf-8')).decode('utf-8'),
-                                 meta={'repertorio_id': 10})
-        self.mock_company = Company(name='company')
-
-
-    def test_insert_when_ok(self):
-        self.repo.insert(self.mock_document)
-
-        # Assert
-        self.session.add.assert_called()
-        self.session.commit.assert_called()
-
-    def test_get_missing_company(self):
-        # Act & Assert
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.repo.get(None, filename="test_file.txt")
-
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.PARAM_NOT_FILLED
-
-    def test_get_document_by_filename(self):
-        self.session.query.return_value.filter_by.return_value.first.return_value = self.mock_document
-
-        # Act
-        result = self.repo.get(self.mock_company, filename="test_file.txt")
-
-        # Assert
-        assert result == self.mock_document
-        self.session.query.assert_called()
-
-    def test_get_by_id_when_id_is_none(self):
-        result = self.repo.get_by_id(0)
-
-        assert result is None
-        self.session.query.assert_not_called()
-
-    def test_get_by_id_when_document_not_found(self):
-        self.session.query.return_value.filter_by.return_value.first.return_value = None
-
-        result = self.repo.get_by_id(999)
-
-        assert result is None
-        self.session.query.assert_called()
-
-    def test_get_by_id_when_document_exists(self):
-        self.session.query.return_value.filter_by.return_value.first.return_value = self.mock_document
-
-        result = self.repo.get_by_id(1)
-
-        assert result == self.mock_document
-        self.session.query.assert_called()
-
-

tests/repositories/test_llm_query_repo.py

@@ -1,340 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from iatoolkit.repositories.database_manager import DatabaseManager
-from iatoolkit.repositories.models import LLMQuery, Function, Company, Prompt, PromptCategory
-from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-from datetime import datetime, timedelta
-
-
-class TestLLMQueryRepo:
-    def setup_method(self):
-        self.db_manager = DatabaseManager('sqlite:///:memory:')
-        self.db_manager.create_all()
-        self.session = self.db_manager.get_session()
-        self.repo = LLMQueryRepo(self.db_manager)
-        self.query = LLMQuery(id=1, company_id=2,
-                              user_identifier='user_1',
-                              query="test query",
-                              output='an output',
-                              response={'answer': 'an answer'},
-                              answer_time=3)
-        self.function = Function(name="function1",
-                                company_id=1,
-                                description="A description",
-                                parameters={'name': 'value'})
-        self.company = Company(name='test_company',
-                               short_name='test')
-        self.session.add(self.company)
-        self.session.commit()
-
-
-    def test_add_query_when_success(self):
-        new_query = self.repo.add_query(self.query)
-        assert new_query.id == 1
-
-    def test_get_company_functions_when_ok(self):
-        self.function.company_id = self.company.id
-
-        self.session.add(self.function)
-        self.session.commit()
-        assert len(self.repo.get_company_functions(self.company)) == 1
-
-    def test_create_or_update_function_when_new_function(self):
-        new_function = Function(name="function1",
-                                company_id=1,
-                                description="A description",
-                                parameters={'name': 'value'})
-        result = self.repo.create_or_update_function(new_function=new_function)
-        assert result.id is not None
-        assert result.name == "function1"
-        assert result.description == "A description"
-
-    def test_create_or_update_function_when_updating_function(self):
-        # Add an initial function
-        function = Function(name="function1",
-                                company_id=self.company.id,
-                                description="A description",
-                                parameters={'name': 'value'})
-        self.session.add(function)
-        self.session.commit()
-
-        # Update the description
-        upd_function = Function(name="function1",
-                            company_id=self.company.id,
-                            description="New description",
-                            parameters={'name': 'value 2'})
-        result = self.repo.create_or_update_function(new_function=upd_function)
-        assert result.id == function.id
-        assert result.description == "New description"
-        assert result.parameters['name'] == 'value 2'
-
-    def test_create_or_update_prompt_when_new_prompt(self):
-        new_prompt = Prompt(name="prompt1",
-                                company_id=self.company.id,
-                                description="an intelligent prompt",
-                                filename='')
-        result = self.repo.create_or_update_prompt(new_prompt=new_prompt)
-        assert result.id is not None
-        assert result.name == "prompt1"
-        assert result.description == "an intelligent prompt"
-        assert result.active is True
-
-    def test_create_or_update_prompt_when_updating_prompt(self):
-
-        category = self.repo.create_or_update_prompt_category(PromptCategory(name='Cobranzas', order=6,
-                             company_id=self.company.id))
-        prompt = Prompt(name="prompt1",
-                        company_id=self.company.id,
-                        category_id=category.id,
-                        active=True,
-                        order=1,
-                        description="an intelligent prompt",
-                        filename='')
-        self.session.add(prompt)
-        self.session.commit()
-
-        # Update the description
-        upd_prompt = Prompt(name="prompt1",
-                            company_id=self.company.id,
-                            category_id=category.id,
-                            active=True,
-                            order=3,
-                            description="a super intelligent prompt",
-                            filename='')
-        result = self.repo.create_or_update_prompt(new_prompt=upd_prompt)
-        assert result.description == "a super intelligent prompt"
-        assert result.id == prompt.id
-
-    def test_get_history_empty_result(self):
-        """Test get_history when no queries exist for the user"""
-        # Get history for non-existent user
-        history = self.repo.get_history(self.company, 'nonexistent_user')
-
-        # Should return empty list
-        assert len(history) == 0
-        assert history == []
-
-    def test_get_history_different_company(self):
-        """Test get_history filters by company_id correctly"""
-        # Add two companies
-        company1 = Company(name='company1', short_name='comp1')
-        company2 = Company(name='company2', short_name='comp2')
-        self.session.add(company1)
-        self.session.add(company2)
-        self.session.commit()
-
-        # Create queries for different companies
-        query1 = LLMQuery(
-            company_id=company1.id,
-            user_identifier='user123',
-            query="Company 1 query",
-            output='Company 1 output',
-            response={'answer': 'Company 1 answer'},
-            answer_time=3
-        )
-        query2 = LLMQuery(
-            company_id=company2.id,
-            user_identifier='user123',
-            query="Company 2 query",
-            output='Company 2 output',
-            response={'answer': 'Company 2 answer'},
-            answer_time=3
-        )
-
-        # Add queries to database
-        self.session.add(query1)
-        self.session.add(query2)
-        self.session.commit()
-
-        # Get history for company1
-        history1 = self.repo.get_history(company1, 'user123')
-        assert len(history1) == 1
-        assert history1[0].query == "Company 1 query"
-
-        # Get history for company2
-        history2 = self.repo.get_history(company2, 'user123')
-        assert len(history2) == 1
-        assert history2[0].query == "Company 2 query"
-
-    def test_get_history_limit_100(self):
-        """Test get_history respects the limit of 100 queries"""
-        # Create 110 queries
-        queries = []
-        base_time = datetime(2024, 1, 15, 10, 30, 0)
-        for i in range(110):
-            # Use timedelta to create unique timestamps
-            query = LLMQuery(
-                company_id=self.company.id,
-                user_identifier='user123',
-                query=f"Query {i}",
-                output=f'Output {i}',
-                response={'answer': f'Answer {i}'},
-                answer_time=3,
-                created_at=base_time + timedelta(seconds=i)  # Different timestamps
-            )
-            queries.append(query)
-
-        # Add all queries to database
-        for query in queries:
-            self.session.add(query)
-        self.session.commit()
-
-        # Get history
-        history = self.repo.get_history(self.company, 'user123')
-
-        # Should return only 100 queries (limit)
-        assert len(history) == 100
-        # Should be ordered by created_at desc (newest first)
-        assert history[0].query == "Query 109"  # Newest
-        assert history[99].query == "Query 10"   # 100th newest
-
-    def test_get_history_mixed_user_types(self):
-        """Test get_history correctly filters by user type"""
-        # Create queries for different user types
-        external_query = LLMQuery(
-            company_id=self.company.id,
-            user_identifier='external_user',
-            query="External user query",
-            output='External output',
-            response={'answer': 'External answer'},
-            answer_time=3
-        )
-        local_query = LLMQuery(
-            company_id=self.company.id,
-            user_identifier='user_456',
-            query="Local user query",
-            output='Local output',
-            response={'answer': 'Local answer'},
-            answer_time=3
-        )
-
-        # Add queries to database
-        self.session.add(external_query)
-        self.session.add(local_query)
-        self.session.commit()
-
-        # Get history for external user
-        external_history = self.repo.get_history(self.company, 'external_user')
-        assert len(external_history) == 1
-        assert external_history[0].query == "External user query"
-
-        # Get history for local user
-        local_history = self.repo.get_history(self.company, 'user_456')
-        assert len(local_history) == 1
-        assert local_history[0].query == "Local user query"
-
-    def test_get_history_ordering(self):
-        """Test get_history orders by created_at desc correctly"""
-
-        # Create queries with different timestamps
-        old_query = LLMQuery(
-            company_id=self.company.id,
-            user_identifier='user123',
-            query="Old query",
-            output='Old output',
-            response={'answer': 'Old answer'},
-            answer_time=3,
-            created_at=datetime(2024, 1, 15, 10, 30, 0)
-        )
-        new_query = LLMQuery(
-            company_id=self.company.id,
-            user_identifier='user123',
-            query="New query",
-            output='New output',
-            response={'answer': 'New answer'},
-            answer_time=3,
-            created_at=datetime(2024, 1, 15, 11, 30, 0)
-        )
-
-        # Add queries to database
-        self.session.add(old_query)
-        self.session.add(new_query)
-        self.session.commit()
-
-        # Get history
-        history = self.repo.get_history(self.company, 'user123')
-
-        # Should be ordered by created_at desc (newest first)
-        assert len(history) == 2
-        assert history[0].query == "New query"  # Newest first
-        assert history[1].query == "Old query"  # Oldest last
-
-    def test_get_history_no_company_queries(self):
-        """Test get_history when company exists but has no queries"""
-
-        # Get history for company with no queries
-        history = self.repo.get_history(self.company, 'user123')
-
-        # Should return empty list
-        assert len(history) == 0
-        assert history == []
-
-    def test_get_prompts_when_prompts_exist(self):
-        """Test get_prompts returns all prompts for a company."""
-        # Create active and inactive prompts for the same company
-        prompt1 = Prompt(name="active_prompt",
-                         company_id=self.company.id,
-                         description="An active prompt",
-                         active=True,
-                         filename='')
-        prompt2 = Prompt(name="inactive_prompt",
-                         company_id=self.company.id,
-                         description="An inactive prompt",
-                         active=False,
-                         filename='')
-
-        self.session.add_all([prompt1, prompt2])
-        self.session.commit()
-
-        # Get prompts for the company
-        prompts = self.repo.get_prompts(self.company)
-
-        # Should return both prompts
-        assert len(prompts) == 2
-        prompt_names = {p.name for p in prompts}
-        assert "active_prompt" in prompt_names
-        assert "inactive_prompt" in prompt_names
-
-    def test_get_prompts_when_no_prompts_exist(self):
-        """Test get_prompts returns an empty list when a company has no prompts."""
-        # Get prompts for a company with no prompts
-        prompts = self.repo.get_prompts(self.company)
-
-        # Should return an empty list
-        assert len(prompts) == 0
-        assert prompts == []
-
-    def test_get_prompts_filters_by_company(self):
-        """Test get_prompts only returns prompts for the specified company."""
-        # Create another company
-        other_company = Company(name='other_company', short_name='other')
-        self.session.add(other_company)
-        self.session.commit()
-
-        # Create a prompt for the main company
-        prompt1 = Prompt(name="main_company_prompt",
-                         company_id=self.company.id,
-                         description="Prompt for the main company",
-                         filename='')
-
-        # Create a prompt for the other company
-        prompt2 = Prompt(name="other_company_prompt",
-                         company_id=other_company.id,
-                         description="Prompt for the other company",
-                         filename='')
-
-        self.session.add_all([prompt1, prompt2])
-        self.session.commit()
-
-        # Get prompts for the main company
-        prompts = self.repo.get_prompts(self.company)
-
-        # Should only return the prompt for the main company
-        assert len(prompts) == 1
-        assert prompts[0].name == "main_company_prompt"
-        assert prompts[0].company_id == self.company.id
-
-

tests/repositories/test_models.py

@@ -1,38 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from unittest.mock import patch, MagicMock
-from iatoolkit.repositories.models import Company, Function, Document, User, LLMQuery, VSDoc
-from sqlalchemy.orm import relationship
-
-
-class TestModels:
-    def setup_method(self):
-        self.mock_base = MagicMock()
-
-        # Aquí almacenamos las referencias de los objetos mock retornados
-        self.mock_relationship = patch('sqlalchemy.orm.relationship', MagicMock(return_value=relationship)).start()
-        self.mock_column = patch('sqlalchemy.Column', MagicMock()).start()
-        self.mock_integer = patch('sqlalchemy.Integer', MagicMock()).start()
-        self.mock_string = patch('sqlalchemy.String', MagicMock()).start()
-        self.mock_float = patch('sqlalchemy.Float', MagicMock()).start()
-        self.mock_date_time = patch('sqlalchemy.DateTime', MagicMock()).start()
-        self.mock_json = patch('sqlalchemy.JSON', MagicMock()).start()
-        self.mock_foreign_key = patch('sqlalchemy.ForeignKey', MagicMock()).start()
-
-        self.model_classes = [Company, Function, Document, User, LLMQuery, VSDoc]
-
-    def teardown_method(self):
-        patch.stopall()
-
-    def test_model_definitions(self):
-        for model_class in self.model_classes:
-            instance = model_class()  # Asegurarse de que se puedan instanciar correctamente
-            instance.to_dict()
-            assert instance is not None
-
-    def test_relationship_calls(self):
-        # Ahora usamos call_count en el mock generado
-        assert self.mock_relationship.call_count == 0

tests/repositories/test_profile_repo.py

@@ -1,142 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from iatoolkit.repositories.database_manager import DatabaseManager
-from iatoolkit.repositories.models import User, Company, UserFeedback
-from iatoolkit.repositories.profile_repo import ProfileRepo
-
-
-class TestProfileRepo:
-    def setup_method(self):
-        self.db_manager = DatabaseManager('sqlite:///:memory:')
-        self.db_manager.create_all()
-        self.session = self.db_manager.get_session()
-        self.repo = ProfileRepo(self.db_manager)
-
-        self.user = User(email='fernando@opensoft.cl',
-                         first_name='Fernando',
-                         last_name='Libedinsky',
-                         password='123')
-
-        self.company = Company(name='opensoft', short_name='open')
-
-    def test_get_user_by_id_when_not_found(self):
-        result = self.repo.get_user_by_id(2)
-        assert result is None
-
-    def test_get_user_by_id_when_success(self):
-        self.session.add(self.user)
-        result = self.repo.get_user_by_id(1)
-        assert result == self.user
-
-    def test_get_user_by_email_when_not_found(self):
-        result = self.repo.get_user_by_email('fl@opensoft')
-        assert result is None
-
-    def test_get_user_by_email_when_success(self):
-        self.session.add(self.user)
-        result = self.repo.get_user_by_email('fernando@opensoft.cl')
-        assert result == self.user
-
-    def test_create_user_when_ok(self):
-        new_user = self.repo.create_user(self.user)
-        assert new_user.id == 1
-
-    def test_save_and_update_user_when_ok(self):
-        new_user = self.repo.create_user(self.user)
-        new_user.first_name = 'fernando'
-
-        updated_user = self.repo.save_user(new_user)
-        assert updated_user.id == 1
-
-    def test_update_user_when_not_exist(self):
-        user = self.repo.update_user(self.user.email, first_name='Fernando')
-        assert user == None
-
-    def test_verify_user_when_ok(self):
-        self.session.add(self.user)
-        user = self.repo.verify_user(self.user.email)
-        assert user.verified == True
-
-    def test_set_temp_code_when_ok(self):
-        self.session.add(self.user)
-        temp_code = 'CCGT'
-        user = self.repo.set_temp_code(self.user.email,temp_code)
-
-        assert user.temp_code == temp_code
-
-    def test_reset_temp_code_when_ok(self):
-        self.session.add(self.user)
-        user = self.repo.reset_temp_code(self.user.email)
-
-        assert user.temp_code == None
-
-    def test_update_password_when_ok(self):
-        self.session.add(self.user)
-        hashed_password = 'ggdvXz'
-        user = self.repo.update_password(self.user.email, hashed_password)
-
-        assert user.password == hashed_password
-
-    def test_get_company_when_no_exist(self):
-        assert self.repo.get_company('opensoft') == None
-
-    def test_get_company_when_ok(self):
-        self.session.add(self.company)
-        assert self.repo.get_company('opensoft') == self.company
-        assert self.repo.get_company_by_short_name('open') == self.company
-
-    def test_get_company_by_id_when_not_found(self):
-        result = self.repo.get_company_by_id(999)
-
-        assert result is None
-
-    def test_get_company_by_id_when_success(self):
-        self.session.add(self.company)
-
-        result = self.repo.get_company_by_id(1)
-        assert result == self.company
-
-    def test_get_companies_when_no_companies_exist(self):
-        result = self.repo.get_companies()
-        assert result == []
-
-    def test_get_companies_when_companies_exist(self):
-        company_opensoft = Company(name='Opensoft', short_name='open')
-        company_testlabs = Company(name='TestLabs', short_name='test')
-        self.session.add(company_opensoft)
-        self.session.add(company_testlabs)
-        self.session.commit()
-
-        result = self.repo.get_companies()
-
-        assert len(result) == 2
-        assert result[0].name == 'Opensoft'
-        assert result[1].name == 'TestLabs'
-
-    def test_create_company_when_company_exists(self):
-        self.session.add(self.company)
-
-        result = self.repo.create_company(Company(name='opensoft'))
-
-        assert result.id == self.company.id
-        assert result.name == self.company.name
-
-    def test_create_company_when_new_company(self):
-        result = self.repo.create_company(Company(name='NewCompany', short_name='new'))
-
-        assert result.id is not None
-        assert result.name == 'NewCompany'
-
-    def test_save_feedback_when_ok(self):
-        company = self.repo.create_company(Company(name='my_company', short_name='my_company'))
-        feedback = UserFeedback(company_id=company.id,
-                                external_user_id='flibe',
-                                message='feedback message',
-                                rating=4)
-        new_feed = self.repo.save_feedback(feedback)
-        assert new_feed.message == 'feedback message'
-        assert new_feed.rating == 4
-