Change the import to avoid importing by the folder

pyproject.toml

@@ -2,8 +2,9 @@
     requires = ["hatchling"]
     build-backend = "hatchling.build"
 
+
     [project]
-name = "pilgrim"
+    name = "Pilgrim"
     version = "0.0.4"
     authors = [
       { name="Gustavo Henrique Santos Souza de Miranda", email="gustavohssmiranda@gmail.com" }
@@ -21,11 +22,15 @@ dependencies = [
         "textual",
         "tomli",
         "tomli_w"
-]
 
+
+    ]
+    [template.plugins.default]
+    src-layout = true
     [project.urls]
     Homepage = "https://github.com/gmbrax/Pilgrim/"
     Issues = "https://github.com/gmbrax/Pilgrim/issues"
-
+    [tool.hatch.build.targets.wheel]
+    packages = ["src/pilgrim"]
     [project.scripts]
-pilgrim = "pilgrim.command:main"
+    pilgrim = "pilgrim:main"

src/pilgrim/database.py

@@ -1,5 +1,5 @@
 from sqlalchemy import create_engine
-from sqlalchemy.orm import declarative_base
+from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
 from pathlib import Path
 import os

src/pilgrim/models/entry.py

@@ -4,16 +4,15 @@ from pilgrim.models.photo_in_entry import photo_entry_association
 from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
 from sqlalchemy.orm import relationship
 
-from pilgrim.database import Base
+from ..database import Base
-
 
 
 class Entry(Base):
     __tablename__ = "entries"
     id = Column(Integer, primary_key=True)
-    title = Column(String,nullable=False)
+    title = Column(String)
     text = Column(String)
-    date = Column(DateTime,nullable=False)
+    date = Column(DateTime)
     photos = relationship(
         "Photo",
         secondary=photo_entry_association,

src/pilgrim/models/photo.py

@@ -7,8 +7,7 @@ from sqlalchemy.orm import relationship
 from sqlalchemy.sql.schema import Index
 
 from pilgrim.models.photo_in_entry import photo_entry_association
-from pilgrim.database import Base
+from ..database import Base
-
 
 
 class Photo(Base):

src/pilgrim/models/photo_in_entry.py

@@ -1,6 +1,6 @@
 from sqlalchemy import Table, Column, Integer, ForeignKey
 
-from pilgrim.database import Base
+from ..database import Base
 
 photo_entry_association = Table('photo_entry_association', Base.metadata,
 Column('id', Integer, primary_key=True, autoincrement=True),

src/pilgrim/models/travel_diary.py

@@ -3,11 +3,10 @@ from typing import Any
 from sqlalchemy import Column, Integer, String, UniqueConstraint
 from sqlalchemy.orm import relationship
 
-from pilgrim.database import Base
+from .. import database
 
 
-
+class TravelDiary(database.Base):
-class TravelDiary(Base):
     __tablename__ = "travel_diaries"
     id = Column(Integer, primary_key=True)
     name = Column(String, nullable=False)

src/pilgrim/service/entry_service.py

@@ -1,9 +1,9 @@
 from datetime import datetime
 from typing import List
 
-from pilgrim.models.entry import Entry
+from ..models.entry import Entry
-from pilgrim.models.travel_diary import TravelDiary
+from ..models.travel_diary import TravelDiary
-from pilgrim.models.photo import Photo  # ✨ Importe o modelo Photo
+from ..models.photo import Photo  # ✨ Importe o modelo Photo
 
 
 class EntryService:

src/pilgrim/service/travel_diary_service.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from pilgrim.utils import DirectoryManager
 from sqlalchemy.exc import IntegrityError
 
-from pilgrim.models.travel_diary import TravelDiary
+from ..models.travel_diary import TravelDiary
 
 
 class TravelDiaryService:

tests/conftest.py

@@ -1,28 +0,0 @@
-import pytest
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from pilgrim.database import Base
-from pilgrim.models.travel_diary import TravelDiary
-
-# Todos os imports necessários para as fixtures devem estar aqui
-# ...
-
-@pytest.fixture(scope="function")
-def db_session():
-    """Esta fixture agora está disponível para TODOS os testes."""
-    engine = create_engine("sqlite:///:memory:")
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    yield session
-    session.close()
-    Base.metadata.drop_all(engine)
-
-@pytest.fixture
-def populated_db_session(db_session):
-    """Esta também fica disponível para todos."""
-    travel_diary = TravelDiary(name="My Travel Diary", directory_name="viagem-teste")
-    db_session.add(travel_diary)
-    db_session.commit()
-    return db_session

tests/service/test_entry_service.py

@@ -1,269 +0,0 @@
-from re import search
-
-import pytest
-from datetime import datetime
-from unittest.mock import Mock
-from sqlalchemy import create_engine
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.orm import sessionmaker
-
-from pilgrim.database import Base
-from pilgrim.models.travel_diary import TravelDiary
-from pilgrim.models.entry import Entry
-from pilgrim.models.photo import Photo
-
-from pilgrim.service.entry_service import EntryService
-
-
-
-@pytest.fixture
-def session_with_an_entry(populated_db_session):
-    session = populated_db_session
-    initial_entry = Entry(
-        title="Título Original",
-        text="Texto original.",
-        date=datetime(2025, 1, 1),
-        travel_diary_id=1
-    )
-    session.add(initial_entry)
-    session.commit()
-    return session, initial_entry.id
-
-@pytest.fixture
-def session_with_multiple_entries(populated_db_session):
-    """Fixture que cria um diário e duas entradas para ele."""
-    session = populated_db_session
-
-    entry1 = Entry(title="Entrada 1", text="Texto 1", date=datetime(2025, 1, 1), travel_diary_id=1)
-    entry2 = Entry(title="Entrada 2", text="Texto 2", date=datetime(2025, 1, 2), travel_diary_id=1)
-
-    session.add_all([entry1, entry2])
-    session.commit()
-
-    return session
-
-def test_create_entry_successfully(populated_db_session):
-    session = populated_db_session
-    service = EntryService(session)
-    diary_id = 1  # Sabemos que o ID é 1 por causa da nossa fixture
-    title = "Primeiro Dia na Praia"
-    text = "O dia foi ensolarado e o mar estava ótimo."
-    date = datetime(2025, 7, 20)
-    photos = [Photo(filepath="/path/to/photo1.jpg",name="Photo 1",photo_hash="hash_12345678",fk_travel_diary_id=diary_id), Photo(filepath="/path/to/photo2.jpg",name="Photo 1",photo_hash="hash_87654321",fk_travel_diary_id=diary_id)]
-    created_entry = service.create(
-        travel_diary_id=diary_id,
-        title=title,
-        text=text,
-        date=date,
-        photos=photos
-    )
-    assert created_entry is not None
-    assert created_entry.id is not None  # Garante que foi salvo no BD e tem um ID
-    assert created_entry.title == title
-    assert created_entry.text == text
-    assert len(created_entry.photos) == 2
-    assert created_entry.photos[0].filepath == "/path/to/photo1.jpg"
-
-    entry_in_db = session.query(Entry).filter_by(id=created_entry.id).one()
-    assert entry_in_db.title == "Primeiro Dia na Praia"
-
-def test_create_entry_fails_when_diary_id_is_invalid(db_session):
-    session = db_session
-    service = EntryService(session)
-    invalid_id = 666
-
-    result = service.create(
-        travel_diary_id=invalid_id,
-        title="Título de Teste",
-        text="Texto de Teste",
-        date=datetime(2025, 7, 20),
-        photos=[]
-    )
-
-    assert result is None
-
-def test_create_entry_successfully_without_photo(populated_db_session):
-    session = populated_db_session
-    service = EntryService(session)
-    diary_id = 1  # Sabemos que o ID é 1 por causa da nossa fixture
-    title = "Primeiro Dia na Praia"
-    text = "O dia foi ensolarado e o mar estava ótimo."
-    date = datetime(2025, 7, 20)
-    photos = []
-    created_entry = service.create(
-        travel_diary_id=diary_id,
-        title=title,
-        text=text,
-        date=date,
-        photos=photos
-    )
-    assert created_entry is not None
-    assert created_entry.id is not None  # Garante que foi salvo no BD e tem um ID
-    assert created_entry.title == title
-    assert created_entry.text == text
-    assert len(created_entry.photos) == 0
-    entry_in_db = session.query(Entry).filter_by(id=created_entry.id).one()
-    assert entry_in_db.title == "Primeiro Dia na Praia"
-
-def test_create_entry_fails_with_null_title(populated_db_session):
-    session = populated_db_session
-    service = EntryService(session)
-    diary_id = 1
-    with pytest.raises(IntegrityError):
-        service.create(
-            travel_diary_id=diary_id,
-            title=None,
-            text="Um texto qualquer.",
-            date=datetime.now(),
-            photos=[]
-        )
-
-def test_create_entry_fails_with_null_date(populated_db_session):
-    session = populated_db_session
-    service = EntryService(session)
-    diary_id = 1
-    with pytest.raises(IntegrityError):
-        service.create(
-            travel_diary_id=diary_id,
-            title="Sabado de sol",
-            text="Um texto qualquer.",
-            date=None,
-            photos=[]
-        )
-
-def test_create_entry_fails_with_null_diary_id(populated_db_session):
-    session = populated_db_session
-    service = EntryService(session)
-    diary_id = 1
-    result = service.create(
-            travel_diary_id=None,
-            title="Sabado de sol",
-            text="Um texto qualquer.",
-            date=datetime.now(),
-            photos=[]
-        )
-    assert result is None
-def test_ready_by_id_successfully(session_with_an_entry):
-    session,_ = session_with_an_entry
-    service = EntryService(session)
-    search_id = 1
-    result = service.read_by_id(search_id)
-    assert result is not None
-def test_ready_by_id_fails_when_id_is_invalid(db_session):
-    session = db_session
-    service = EntryService(session)
-    invalid_id = 666
-    result = service.read_by_id(invalid_id)
-    assert result is None
-
-def test_read_all_returns_all_entries(session_with_multiple_entries):
-    session = session_with_multiple_entries
-    service = EntryService(session)
-    all_entries = service.read_all()
-    assert isinstance(all_entries, list)
-    assert len(all_entries) == 2
-    assert all_entries[0].title == "Entrada 1"
-    assert all_entries[1].title == "Entrada 2"
-
-def test_read_all_returns_empty_list_on_empty_db(db_session):
-    session = db_session
-    service = EntryService(session)
-    all_entries = service.read_all()
-    assert isinstance(all_entries, list)
-    assert len(all_entries) == 0
-
-def test_update_entry_successfully(session_with_an_entry):
-    session, entry_id = session_with_an_entry
-    service = EntryService(session)
-    entry_src = session.query(Entry).filter_by(id=entry_id).one()
-    new_date = datetime(2025, 1, 2)
-    entry_dst = Entry(
-        title="Título Atualizado",
-        text="Texto atualizado.",
-        date=new_date,
-        travel_diary_id=1,  # Mantemos o mesmo travel_diary_id
-        photos=[]
-    )
-    updated_entry = service.update(entry_src, entry_dst)
-    assert updated_entry is not None
-    assert updated_entry.id == entry_id
-    assert updated_entry.title == "Título Atualizado"
-    assert updated_entry.text == "Texto atualizado."
-    entry_in_db = session.query(Entry).filter_by(id=entry_id).one()
-    assert entry_in_db.title == "Título Atualizado"
-
-def test_update_entry_fails_if_entry_does_not_exist(db_session):
-    service = EntryService(db_session)
-    non_existent_entry = Entry(
-        title="dummy",
-        text="dummy",
-        date=datetime.now(),
-        travel_diary_id=1)
-    non_existent_entry.id = 999
-    entry_with_new_data = Entry(title="Novo Título", text="Novo Texto", date=datetime.now(), travel_diary_id=1)
-    result = service.update(non_existent_entry, entry_with_new_data)
-    assert result is None
-
-def test_update_fails_with_null_title(session_with_an_entry):
-    session, entry_id = session_with_an_entry
-    service = EntryService(session)
-    entry_src = session.query(Entry).filter_by(id=entry_id).one()
-    entry_dst = Entry(
-        title=None,
-        text="Texto atualizado.",
-        date=datetime.now(),
-        travel_diary_id=1,
-        photos=[]
-    )
-    with pytest.raises(IntegrityError):
-        service.update(entry_src, entry_dst)
-
-def test_update_fails_with_null_date(session_with_an_entry):
-    session, entry_id = session_with_an_entry
-    service = EntryService(session)
-    entry_src = session.query(Entry).filter_by(id=entry_id).one()
-    entry_dst = Entry(
-        title=entry_src.title,
-        text="Texto atualizado.",
-        date=None,
-        travel_diary_id=1,
-        photos=[]
-    )
-    with pytest.raises(IntegrityError):
-        service.update(entry_src, entry_dst)
-
-def test_update_fails_with_null_diary_id(session_with_an_entry):
-    session, entry_id = session_with_an_entry
-    service = EntryService(session)
-    entry_src = session.query(Entry).filter_by(id=entry_id).one()
-    entry_dst = Entry(
-        title=entry_src.title,
-        text="Texto atualizado.",
-        date=datetime.now(),
-        travel_diary_id=None,
-        photos=[]
-    )
-    with pytest.raises(IntegrityError):
-        service.update(entry_src, entry_dst)
-
-def test_delete_successfully_removes_entry(session_with_an_entry):
-    session, entry_id = session_with_an_entry
-    service = EntryService(session)
-    entry_to_delete = service.read_by_id(entry_id)
-    assert entry_to_delete is not None
-    deleted_entry = service.delete(entry_to_delete)
-    assert deleted_entry is not None
-    assert deleted_entry.id == entry_id
-    entry_in_db = service.read_by_id(entry_id)
-    assert entry_in_db is None
-
-def test_delete_returns_none_if_entry_does_not_exist(db_session):
-    service = EntryService(db_session)
-    non_existent_entry = Entry(
-        title="dummy",
-        text="dummy",
-        date=datetime.now(),
-        travel_diary_id=1)
-    non_existent_entry.id = 999
-    result = service.delete(non_existent_entry)
-    assert result is None

tests/test_database.py

@@ -0,0 +1,40 @@
+import pytest
+from unittest.mock import Mock  # A ferramenta para criar nosso "dublê"
+from pathlib import Path
+from sqlalchemy import inspect, Column, Integer, String
+from sqlalchemy.orm import Session
+
+from pilgrim.database import Database,Base
+
+class MockUser(Base):
+    __tablename__ = 'mock_users'
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+
+@pytest.fixture
+def db_instance(tmp_path: Path):
+    fake_db_path = tmp_path / "test_pilgrim.db"
+    mock_config_manager = Mock()
+    mock_config_manager.database_url = str(fake_db_path)
+    db = Database(mock_config_manager)
+    return db, fake_db_path
+
+def test_create_database(db_instance):
+    db, fake_db_path = db_instance
+    db.create()
+    assert fake_db_path.exists()
+
+def test_table_creation(db_instance):
+    db, _ = db_instance
+    db.create()
+    inspector = inspect(db.engine)
+    assert "mock_users" in inspector.get_table_names()
+
+def test_session_returned_corectly(db_instance):
+    db, _ = db_instance
+    session = db.session()
+    assert isinstance(session, Session)
+    session.close()
+
+
+