litepolis-database-default 0.0.1__tar.gz

litepolis_database_default-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David H.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

litepolis_database_default-0.0.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: litepolis-database-default
+Version: 0.0.1
+Summary: The default database module for LitePolis that compatible with Polis
+Author: Your name
+License: file: LICENSE
+Project-URL: Homepage, https://github.com/NewJerseyStyle/LitePolis-database-default
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: sqlmodel
+Dynamic: license-file
+
+# LitePolis Database Default
+
+This is the default database module that compatible with [Polis](https://github.com/CivicTechTO/polis/).
+
+## Quick Start
+
+1. Install the module:
+```bash
+litepolis-cli add-deps litepolis-database-default
+```
+
+2. Configure database connection:
+```yaml
+# ~/.litepolis/litepolis.config
+[litepolis_database_default]
+database_url: "postgresql://user:pass@localhost:5432/litepolis"
+# database_url: "starrocks://<User>:<Password>@<Host>:<Port>/<Catalog>.<Database>"
+```
+
+3. Basic usage:
+```python
+from litepolis_database_default import DatabaseActor
+
+user = DatabaseActor.create_user({
+    "email": "test@example.com",
+    "auth_token": "auth_token",
+})
+
+conv = DatabaseActor.create_conversation({
+    "title": "Test Conversation",
+    "description": "This is a test conversation."
+})
+```
+
+## Data Schema
+
+### Users (`users`)
+```sql
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    auth_token TEXT NOT NULL,
+    is_admin BOOLEAN DEFAULT false,
+    created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    modified TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### Conversations (`conversations`)
+```sql
+CREATE TABLE conversations (
+    id SERIAL PRIMARY KEY,
+    title TEXT NOT NULL,
+    description TEXT,
+    is_archived BOOLEAN DEFAULT false,
+    created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    modified TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+## License
+MIT Licensed. See [LICENSE](LICENSE) for details.

litepolis_database_default-0.0.1/README.md

@@ -0,0 +1,62 @@
+# LitePolis Database Default
+
+This is the default database module that compatible with [Polis](https://github.com/CivicTechTO/polis/).
+
+## Quick Start
+
+1. Install the module:
+```bash
+litepolis-cli add-deps litepolis-database-default
+```
+
+2. Configure database connection:
+```yaml
+# ~/.litepolis/litepolis.config
+[litepolis_database_default]
+database_url: "postgresql://user:pass@localhost:5432/litepolis"
+# database_url: "starrocks://<User>:<Password>@<Host>:<Port>/<Catalog>.<Database>"
+```
+
+3. Basic usage:
+```python
+from litepolis_database_default import DatabaseActor
+
+user = DatabaseActor.create_user({
+    "email": "test@example.com",
+    "auth_token": "auth_token",
+})
+
+conv = DatabaseActor.create_conversation({
+    "title": "Test Conversation",
+    "description": "This is a test conversation."
+})
+```
+
+## Data Schema
+
+### Users (`users`)
+```sql
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    auth_token TEXT NOT NULL,
+    is_admin BOOLEAN DEFAULT false,
+    created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    modified TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### Conversations (`conversations`)
+```sql
+CREATE TABLE conversations (
+    id SERIAL PRIMARY KEY,
+    title TEXT NOT NULL,
+    description TEXT,
+    is_archived BOOLEAN DEFAULT false,
+    created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    modified TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+## License
+MIT Licensed. See [LICENSE](LICENSE) for details.

litepolis_database_default-0.0.1/litepolis_database_default/Actor.py

@@ -0,0 +1,30 @@
+from typing import Dict, Any, List
+
+from .Users import UserManager
+from .Conversations import ConversationManager
+from .Comments import CommentManager
+from .Vote import VoteManager
+from .Report import ReportManager
+from .MigrationRecord import MigrationRecordManager
+
+
+class DatabaseActor(
+    UserManager, 
+    ConversationManager, 
+    CommentManager, 
+    VoteManager, 
+    ReportManager,
+    MigrationRecordManager
+):
+    """
+    DatabaseActor class for LitePolis.
+
+    This class serves as the central point of interaction between the LitePolis system
+    and the database module. It aggregates operations from various manager classes,
+    such as UserManager and ConversationManager, providing a unified interface
+    for database interactions.
+
+    LitePolis system is designed to interact with a class named "DatabaseActor",
+    so ensure this class name is maintained.
+    """
+    pass

litepolis_database_default-0.0.1/litepolis_database_default/Comments.py

@@ -0,0 +1,75 @@
+from sqlmodel import SQLModel, Field, Relationship
+from typing import Optional, List, Type, Any, Dict
+from datetime import datetime, UTC
+
+# Removed BaseManager import
+from .utils import create_db_and_tables, get_session # Import get_session
+from sqlmodel import Session, select # Import Session and select
+
+class BaseModel(SQLModel):
+    id: int = Field(primary_key=True)
+    created: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class Comment(BaseModel, table=True):
+    __tablename__ = "comments"
+    text: str
+    user_id: int = Field(foreign_key="users.id")
+    conversation_id: int = Field(foreign_key="conversations.id")
+    parent_comment_id: Optional[int] = Field(foreign_key="comments.id")
+    # Relationships
+    user: "User" = Relationship(back_populates="comments")
+    conversation: "Conversation" = Relationship(back_populates="comments")
+    votes: List["Vote"] = Relationship(back_populates="comment")
+
+class CommentManager:
+    @staticmethod
+    def create_comment(data: Dict[str, Any]) -> Comment:
+        """Creates a new Comment record."""
+        with get_session() as session:
+            comment_instance = Comment(**data)
+            session.add(comment_instance)
+            session.commit()
+            session.refresh(comment_instance)
+            return comment_instance
+
+    @staticmethod
+    def read_comment(comment_id: int) -> Optional[Comment]:
+        """Reads a Comment record by ID."""
+        with get_session() as session:
+            comment_instance = session.get(Comment, comment_id)
+            return comment_instance
+
+    @staticmethod
+    def update_comment(comment_id: int, data: Dict[str, Any]) -> Optional[Comment]:
+        """Updates a Comment record by ID."""
+        with get_session() as session:
+            comment_instance = session.get(Comment, comment_id)
+            if not comment_instance:
+                return None
+            for key, value in data.items():
+                setattr(comment_instance, key, value)
+            session.add(comment_instance)
+            session.commit()
+            session.refresh(comment_instance)
+            return comment_instance
+
+    @staticmethod
+    def delete_comment(comment_id: int) -> bool:
+        """Deletes a Comment record by ID."""
+        with get_session() as session:
+            comment_instance = session.get(Comment, comment_id)
+            if not comment_instance:
+                return False
+            session.delete(comment_instance)
+            session.commit()
+            return True
+
+    @staticmethod
+    def list_comments() -> List[Comment]:
+        """Lists all Comment records."""
+        with get_session() as session:
+            comment_instances = session.exec(select(Comment)).all()
+            return comment_instances
+
+create_db_and_tables()

litepolis_database_default-0.0.1/litepolis_database_default/Conversations.py

@@ -0,0 +1,72 @@
+from sqlmodel import SQLModel, Field, Relationship
+from typing import Optional, List, Type, Any, Dict
+from datetime import datetime, UTC
+
+# Removed BaseManager import
+from .utils import create_db_and_tables, get_session # Import get_session
+from sqlmodel import Session, select # Import Session and select
+
+class BaseModel(SQLModel):
+    id: int = Field(primary_key=True)
+    created: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class Conversation(BaseModel, table=True):
+    __tablename__ = "conversations"
+    title: str
+    description: str
+    is_archived: bool = Field(default=False)
+    # Relationships
+    comments: List["Comment"] = Relationship(back_populates="conversation")
+
+class ConversationManager:
+    @staticmethod
+    def create_conversation(data: Dict[str, Any]) -> Conversation:
+        """Creates a new Conversation record."""
+        with get_session() as session:
+            conversation_instance = Conversation(**data)
+            session.add(conversation_instance)
+            session.commit()
+            session.refresh(conversation_instance)
+            return conversation_instance
+
+    @staticmethod
+    def read_conversation(conversation_id: int) -> Optional[Conversation]:
+        """Reads a Conversation record by ID."""
+        with get_session() as session:
+            conversation_instance = session.get(Conversation, conversation_id)
+            return conversation_instance
+
+    @staticmethod
+    def update_conversation(conversation_id: int, data: Dict[str, Any]) -> Optional[Conversation]:
+        """Updates a Conversation record by ID."""
+        with get_session() as session:
+            conversation_instance = session.get(Conversation, conversation_id)
+            if not conversation_instance:
+                return None
+            for key, value in data.items():
+                setattr(conversation_instance, key, value)
+            session.add(conversation_instance)
+            session.commit()
+            session.refresh(conversation_instance)
+            return conversation_instance
+
+    @staticmethod
+    def delete_conversation(conversation_id: int) -> bool:
+        """Deletes a Conversation record by ID."""
+        with get_session() as session:
+            conversation_instance = session.get(Conversation, conversation_id)
+            if not conversation_instance:
+                return False
+            session.delete(conversation_instance)
+            session.commit()
+            return True
+            
+    @staticmethod
+    def list_conversations() -> List[Conversation]:
+        """Lists all Conversation records."""
+        with get_session() as session:
+            conversations = session.exec(select(Conversation)).all()
+            return conversations
+
+create_db_and_tables()

litepolis_database_default-0.0.1/litepolis_database_default/MigrationRecord.py

@@ -0,0 +1,51 @@
+from typing import Dict, Any, Optional, List
+from sqlmodel import SQLModel, Field
+from datetime import datetime, UTC
+
+# Removed BaseManager import
+from .utils import create_db_and_tables, get_session # Import get_session
+from sqlmodel import Session, select # Import Session and select
+
+class MigrationRecord(SQLModel, table=True):
+    __tablename__ = "migrations"
+    id: str = Field(primary_key=True)  # Migration filename
+    hash: str  # Content hash
+    executed_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class MigrationRecordManager:
+    @staticmethod
+    def create_migration(data: Dict[str, Any]) -> MigrationRecord:
+        """Creates a new MigrationRecord record."""
+        with get_session() as session:
+            migration_record_instance = MigrationRecord(**data)
+            session.add(migration_record_instance)
+            session.commit()
+            session.refresh(migration_record_instance)
+            return migration_record_instance
+
+    @staticmethod
+    def read_migration(migration_record_id: str) -> Optional[MigrationRecord]:
+        """Reads a MigrationRecord record by ID (migration ID is a string)."""
+        with get_session() as session:
+            migration_record_instance = session.get(MigrationRecord, migration_record_id)
+            return migration_record_instance
+
+    @staticmethod
+    def delete_migration(migration_record_id: str) -> bool:
+        """Deletes a MigrationRecord record by ID."""
+        with get_session() as session:
+            migration_record_instance = session.get(MigrationRecord, migration_record_id)
+            if not migration_record_instance:
+                return False
+            session.delete(migration_record_instance)
+            session.commit()
+            return True
+
+    @staticmethod
+    def list_migrations() -> List[MigrationRecord]:
+        """Lists all MigrationRecord records."""
+        with get_session() as session:
+            migration_record_instances = session.exec(select(MigrationRecord)).all()
+            return migration_record_instances
+
+create_db_and_tables()

litepolis_database_default-0.0.1/litepolis_database_default/Report.py

@@ -0,0 +1,85 @@
+from sqlmodel import SQLModel, Field, Relationship
+from typing import Optional, List, Type, Any, Dict
+from datetime import datetime, UTC
+
+# Removed BaseManager import
+from .utils import create_db_and_tables, get_session # Import get_session
+from sqlmodel import Session, select # Import Session and select
+
+class BaseModel(SQLModel):
+    id: int = Field(primary_key=True)
+    created: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class Report(BaseModel, table=True):
+    __tablename__ = "reports"
+    reporter_id: int = Field(foreign_key="users.id")
+    target_comment_id: int = Field(foreign_key="comments.id")
+    reason: str
+    status: str = Field(default="pending")  # pending/resolved
+
+class ReportManager:
+    @staticmethod
+    def create_report(data: Dict[str, Any]) -> Report:
+        """Creates a new Report record."""
+        with get_session() as session:
+            report_instance = Report(**data)
+            session.add(report_instance)
+            session.commit()
+            session.refresh(report_instance)
+            return report_instance
+
+    @staticmethod
+    def read_report(report_id: int) -> Optional[Report]:
+        """Reads a Report record by ID."""
+        with get_session() as session:
+            report_instance = session.get(Report, report_id)
+            return report_instance
+
+    @staticmethod
+    def update_report(report_id: int, data: Dict[str, Any]) -> Optional[Report]:
+        """Updates a Report record by ID."""
+        with get_session() as session:
+            report_instance = session.get(Report, report_id)
+            if not report_instance:
+                return None
+            for key, value in data.items():
+                setattr(report_instance, key, value)
+            session.add(report_instance)
+            session.commit()
+            session.refresh(report_instance)
+            return report_instance
+
+    @staticmethod
+    def delete_report(report_id: int) -> bool:
+        """Deletes a Report record by ID."""
+        with get_session() as session:
+            report_instance = session.get(Report, report_id)
+            if not report_instance:
+                return False
+            session.delete(report_instance)
+            session.commit()
+            return True
+
+    @staticmethod
+    def list_reports() -> List[Report]:
+        """Lists all Report records."""
+        with get_session() as session:
+            report_instances = session.exec(select(Report)).all()
+            return report_instances
+
+    @staticmethod
+    def update_report_status(report_id: int, status: str) -> Optional[Report]:
+        """Specific method to update only the report status."""
+        with get_session() as session:
+            report_instance = session.get(Report, report_id)
+            if not report_instance:
+                return None
+            report_instance.status = status # type: ignore
+            session.add(report_instance)
+            session.commit()
+            session.refresh(report_instance)
+            return report_instance
+
+
+create_db_and_tables()

litepolis_database_default-0.0.1/litepolis_database_default/Users.py

@@ -0,0 +1,80 @@
+from sqlmodel import SQLModel, Field, Relationship
+from typing import Optional, List, Type, Any, Dict
+from datetime import datetime, UTC
+
+# Removed BaseManager import
+from .utils import create_db_and_tables, get_session # Import get_session
+from sqlmodel import Session, select # Import Session and select
+
+class BaseModel(SQLModel):
+    id: int = Field(primary_key=True)
+    created: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class User(BaseModel, table=True):
+    __tablename__ = "users"
+    email: str = Field(index=True)
+    auth_token: str
+    is_admin: bool = Field(default=False)
+    # Relationships
+    comments: List["Comment"] = Relationship(back_populates="user")
+    votes: List["Vote"] = Relationship(back_populates="user")
+
+class UserManager:
+    @staticmethod
+    def create_user(data: Dict[str, Any]) -> User:
+        """Creates a new User record."""
+        with get_session() as session:
+            user_instance = User(**data)
+            session.add(user_instance)
+            session.commit()
+            session.refresh(user_instance)
+            return user_instance
+
+    @staticmethod
+    def read_user(user_id: int) -> Optional[User]:
+        """Reads a User record by ID."""
+        with get_session() as session:
+            user_instance = session.get(User, user_id)
+            return user_instance
+
+    @staticmethod
+    def list_users() -> List[User]:
+        """Reads all User records."""
+        with get_session() as session:
+            users = session.exec(select(User)).all()
+            return users
+
+    @staticmethod
+    def update_user(user_id: int, data: Dict[str, Any]) -> Optional[User]:
+        """Updates a User record by ID."""
+        with get_session() as session:
+            user_instance = session.get(User, user_id)
+            if not user_instance:
+                return None
+            for key, value in data.items():
+                setattr(user_instance, key, value)
+            session.add(user_instance)
+            session.commit()
+            session.refresh(user_instance)
+            return user_instance
+
+    @staticmethod
+    def delete_user(user_id: int) -> bool:
+        """Deletes a User record by ID. Returns True if successful."""
+        with get_session() as session:
+            user_instance = session.get(User, user_id)
+            if not user_instance:
+                return False
+            session.delete(user_instance)
+            session.commit()
+            return True
+
+    @staticmethod
+    def list_users() -> List[User]:
+        """Lists all User records."""
+        with get_session() as session:
+            users = session.exec(select(User)).all()
+            return users
+
+create_db_and_tables()

litepolis_database_default-0.0.1/litepolis_database_default/Vote.py

@@ -0,0 +1,73 @@
+from sqlmodel import SQLModel, Field, Relationship
+from typing import Optional, List, Type, Any, Dict
+from datetime import datetime, UTC
+
+# Removed BaseManager import
+from .utils import create_db_and_tables, get_session # Import get_session
+from sqlmodel import Session, select # Import Session and select
+
+class BaseModel(SQLModel):
+    id: int = Field(primary_key=True)
+    created: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class Vote(BaseModel, table=True):
+    __tablename__ = "votes"
+    user_id: int = Field(foreign_key="users.id")
+    comment_id: int = Field(foreign_key="comments.id")
+    value: int  # -1, 0, 1
+    # Relationships
+    user: "User" = Relationship(back_populates="votes")
+    comment: "Comment" = Relationship(back_populates="votes")
+
+class VoteManager:
+    @staticmethod
+    def create_vote(data: Dict[str, Any]) -> Vote:
+        """Creates a new Vote record."""
+        with get_session() as session:
+            vote_instance = Vote(**data)
+            session.add(vote_instance)
+            session.commit()
+            session.refresh(vote_instance)
+            return vote_instance
+
+    @staticmethod
+    def read_vote(vote_id: int) -> Optional[Vote]:
+        """Reads a Vote record by ID."""
+        with get_session() as session:
+            vote_instance = session.get(Vote, vote_id)
+            return vote_instance
+
+    @staticmethod
+    def update_vote(vote_id: int, data: Dict[str, Any]) -> Optional[Vote]:
+        """Updates a Vote record by ID."""
+        with get_session() as session:
+            vote_instance = session.get(Vote, vote_id)
+            if not vote_instance:
+                return None
+            for key, value in data.items():
+                setattr(vote_instance, key, value)
+            session.add(vote_instance)
+            session.commit()
+            session.refresh(vote_instance)
+            return vote_instance
+
+    @staticmethod
+    def delete_vote(vote_id: int) -> bool:
+        """Deletes a Vote record by ID."""
+        with get_session() as session:
+            vote_instance = session.get(Vote, vote_id)
+            if not vote_instance:
+                return False
+            session.delete(vote_instance)
+            session.commit()
+            return True
+
+    @staticmethod
+    def list_votes() -> List[Vote]:
+        """Lists all Vote records."""
+        with get_session() as session:
+            vote_instances = session.exec(select(Vote)).all()
+            return vote_instances
+
+create_db_and_tables()

litepolis_database_default-0.0.1/litepolis_database_default/__init__.py

@@ -0,0 +1,2 @@
+from .utils import DEFAULT_CONFIG
+from .Actor import DatabaseActor

litepolis_database_default-0.0.1/litepolis_database_default/utils.py

@@ -0,0 +1,36 @@
+import os
+from contextlib import contextmanager
+from sqlmodel import Session, SQLModel, create_engine
+
+from litepolis import get_config
+
+DEFAULT_CONFIG = {
+    "database_url": "sqlite:///database.db"
+}
+
+if ("PYTEST_CURRENT_TEST" not in os.environ and
+    "PYTEST_VERSION" not in os.environ):
+    database_url = get_config("litepolis_database_default", "database_url")
+else:
+    database_url = DEFAULT_CONFIG.get("database_url")
+engine = create_engine(database_url,
+                        pool_size=5,
+                        max_overflow=10,
+                        pool_timeout=30,
+                        pool_pre_ping=True)
+
+def connect_db():
+    engine = create_engine(database_url,
+                            pool_size=5,
+                            max_overflow=10,
+                            pool_timeout=30,
+                            pool_pre_ping=True)
+
+def create_db_and_tables():
+    # SQLModel.metadata.create_all() has checkfirst=True by default
+    # so tables will only be created if they don't exist
+    SQLModel.metadata.create_all(engine)
+
+@contextmanager
+def get_session():
+    yield Session(engine)