commit a32d63d2aef8979ae35ca5ecdd5a43f591125df3 · zenfyr.dev/xpost

+22

cross/attachments.py

···

       1
       +
       from dataclasses import dataclass

     

       2
       +
       

     

       3
       +
       

     

       4
       +
       @dataclass

     

       5
       +
       class Attachment():

     

       6
       +
           pass

     

       7
       +
       

     

       8
       +
       @dataclass

     

       9
       +
       class SpoilerAttachment(Attachment):

     

       10
       +
           spoiler: str

     

       11
       +
       

     

       12
       +
       @dataclass

     

       13
       +
       class LanguagesAttachment(Attachment):

     

       14
       +
           langs: list[str]

     

       15
       +
       

     

       16
       +
       @dataclass

     

       17
       +
       class SensitiveAttachment(Attachment):

     

       18
       +
           sensitive: bool

     

       19
       +
       

     

       20
       +
       @dataclass

     

       21
       +
       class RemoteUrlAttachment(Attachment):

     

       22
       +
           url: str

+18

cross/fragments.py

···

       1
       +
       from dataclasses import dataclass

     

       2
       +
       

     

       3
       +
       @dataclass

     

       4
       +
       class Fragment:

     

       5
       +
           start: int

     

       6
       +
           end: int

     

       7
       +
       

     

       8
       +
       @dataclass

     

       9
       +
       class LinkFragment(Fragment):

     

       10
       +
           url: str

     

       11
       +
       

     

       12
       +
       @dataclass

     

       13
       +
       class TagFragment(Fragment):

     

       14
       +
           tag: str

     

       15
       +
       

     

       16
       +
       @dataclass

     

       17
       +
       class MentionFragment(Fragment):

     

       18
       +
           uri: str

+29

cross/post.py

···

       1
       +
       from dataclasses import dataclass, field

     

       2
       +
       from cross.attachments import Attachment

     

       3
       +
       from cross.fragments import Fragment

     

       4
       +
       from typing import TypeVar

     

       5
       +
       

     

       6
       +
       T = TypeVar('T', bound=Attachment)

     

       7
       +
       

     

       8
       +
       class AttachmentKeeper:

     

       9
       +
           def __init__(self) -> None:

     

       10
       +
               self._map: dict[type, Attachment] = {}

     

       11
       +
       

     

       12
       +
           def put(self, cls: type[T], attachment: T) -> None:

     

       13
       +
               self._map[cls] = attachment

     

       14
       +
       

     

       15
       +
           def get(self, cls: type[T]) -> T | None:

     

       16
       +
               instance = self._map.get(cls)

     

       17
       +
               if instance is None:

     

       18
       +
                   return None

     

       19
       +
               if not isinstance(instance, cls):

     

       20
       +
                   raise TypeError(f"Expected {cls.__name__}, got {type(instance).__name__}")

     

       21
       +
               return instance

     

       22
       +
       

     

       23
       +
       @dataclass

     

       24
       +
       class Post:

     

       25
       +
           id: str

     

       26
       +
           parent_id: str | None

     

       27
       +
           text: bytes # utf-8 text bytes

     

       28
       +
           attachments: AttachmentKeeper

     

       29
       +
           fragments: list[Fragment] = field(default_factory=list)

+29

cross/service.py

···

       1
       +
       from pathlib import Path

     

       2
       +
       import sqlite3

     

       3
       +
       from typing import cast

     

       4
       +
       

     

       5
       +
       from database.connection import get_conn

     

       6
       +
       

     

       7
       +
       

     

       8
       +
       class Service:

     

       9
       +
           def __init__(self, url: str, db: Path) -> None:

     

       10
       +
               self.url: str = url

     

       11
       +
               self.conn: sqlite3.Connection = get_conn(db)

     

       12
       +
       

     

       13
       +
           def get_post(self, url: str, user: str, identifier: str) -> sqlite3.Row | None:

     

       14
       +
               cursor = self.conn.cursor()

     

       15
       +
               _ = cursor.execute(

     

       16
       +
                   """

     

       17
       +
                   SELECT * FROM posts

     

       18
       +
                   WHERE service = ?

     

       19
       +
                       AND user_id = ?

     

       20
       +
                       AND identifier = ?

     

       21
       +
                   """,

     

       22
       +
                   (url, user, identifier),

     

       23
       +
               )

     

       24
       +
               return cast(sqlite3.Row, cursor.fetchone())

     

       25
       +
       

     

       26
       +
           def get_post_by_id(self, id: int) -> sqlite3.Row | None:

     

       27
       +
               cursor = self.conn.cursor()

     

       28
       +
               _ = cursor.execute("SELECT * FROM posts WHERE id = ?", (id,))

     

       29
       +
               return cast(sqlite3.Row, cursor.fetchone())

+14

database/connection.py

···

       1
       +
       from pathlib import Path

     

       2
       +
       import sqlite3

     

       3
       +
       

     

       4
       +
       def get_conn(db: Path) -> sqlite3.Connection:

     

       5
       +
           conn = sqlite3.connect(db, autocommit=True)

     

       6
       +
           conn.row_factory = sqlite3.Row

     

       7
       +
           _ = conn.executescript("""

     

       8
       +
               PRAGMA journal_mode = WAL;

     

       9
       +
               PRAGMA mmap_size = 134217728;

     

       10
       +
               PRAGMA cache_size = 4000;

     

       11
       +
               PRAGMA synchronous = NORMAL;

     

       12
       +
               PRAGMA foreign_keys = ON;

     

       13
       +
           """)

     

       14
       +
           return conn

+4 -4

database/migrations.py

···

       2
        
       from pathlib import Path

     

       3
        
       

     

       4
        
       from util.util import LOGGER

     

       0
        
       
     

       5
        
       

     

       6
        
       

     

       7
        
       class DatabaseMigrator:

     

       8
        
           def __init__(self, db_path: Path, migrations_folder: Path) -> None:

     

       9
        
               self.db_path: Path = db_path

     

       10
        
               self.migrations_folder: Path = migrations_folder

     

       11
       -
               self.conn: sqlite3.Connection = sqlite3.connect(db_path, autocommit=False)

     

       12
       -
               self.conn.row_factory = sqlite3.Row

     

       13
        
       

     

       14
        
           def close(self):

     

       15
        
               self.conn.close()

     
···

       34
        
                       version = int(f.stem.split("_")[0])

     

       35
        
                       files.append((version, f))

     

       36
        
                   except (ValueError, IndexError):

     

       37
       -
                       LOGGER.warning(f"Warning: Skipping invalid migration file: {f.name}")

     

       38
        
       

     

       39
        
               return sorted(files, key=lambda x: x[0])

     

       40
        
       

     
···

       46
        
               try:

     

       47
        
                   _ = cursor.executescript(sql)

     

       48
        
                   self.set_version(version)

     

       49
       -
                   LOGGER.info(f"Applied migration: {path.name}")

     

       50
        
               except sqlite3.Error as e:

     

       51
        
                   self.conn.rollback()

     

       52
        
                   raise Exception(f"Error applying migration {version}: {e}")

···

       2
        
       from pathlib import Path

     

       3
        
       

     

       4
        
       from util.util import LOGGER

     

       5
       +
       from database.connection import get_conn

     

       6
        
       

     

       7
        
       

     

       8
        
       class DatabaseMigrator:

     

       9
        
           def __init__(self, db_path: Path, migrations_folder: Path) -> None:

     

       10
        
               self.db_path: Path = db_path

     

       11
        
               self.migrations_folder: Path = migrations_folder

     

       12
       +
               self.conn: sqlite3.Connection = get_conn(db_path)

     

       0
        
       
     

       13
        
       

     

       14
        
           def close(self):

     

       15
        
               self.conn.close()

     
···

       34
        
                       version = int(f.stem.split("_")[0])

     

       35
        
                       files.append((version, f))

     

       36
        
                   except (ValueError, IndexError):

     

       37
       +
                       LOGGER.warning("Warning: Skipping invalid migration file: %", f.name)

     

       38
        
       

     

       39
        
               return sorted(files, key=lambda x: x[0])

     

       40
        
       

     
···

       46
        
               try:

     

       47
        
                   _ = cursor.executescript(sql)

     

       48
        
                   self.set_version(version)

     

       49
       +
                   LOGGER.info("Applied migration: %s", path.name)

     

       50
        
               except sqlite3.Error as e:

     

       51
        
                   self.conn.rollback()

     

       52
        
                   raise Exception(f"Error applying migration {version}: {e}")

+4

env.py

···

       1
       +
       import os

     

       2
       +
       

     

       3
       +
       DATA_DIR = os.environ.get('DATA_DIR') or "./data"

     

       4
       +
       MIGRATIONS_DIR = os.environ.get('MIGRATIONS_DIR') or "./migrations"

+40 -4

main.py

···

       0
        
       
     

       0
        
       
     

       1
        
       from pathlib import Path

     

       0
        
       
     

       0
        
       
     

       2
        
       

     

       0
        
       
     

       3
        
       from database.migrations import DatabaseMigrator

     

       4
        
       from util.util import LOGGER

     

       5
        
       

     

       6
        
       

     

       7
       -
       def main(data: Path):

     

       0
        
       
     

       0
        
       
     

       8
        
           if not data.exists():

     

       9
        
               data.mkdir(parents=True)

     

       10
        
       

     
···

       13
        
       

     

       14
        
           if not settings.exists():

     

       15
        
               LOGGER.info("First launch detected! Creating %s and exiting!", settings)

     

       16
       -
               return 0

     

       17
        
       

     

       18
        
           LOGGER.info("Loading settings...")

     

       19
        
           # TODO

     

       20
        
       

     

       21
       -
           migrator = DatabaseMigrator(database, Path("./migrations"))

     

       22
        
           try:

     

       23
        
               migrator.migrate()

     

       24
        
           except Exception:

     
···

       26
        
           finally:

     

       27
        
               migrator.close()

     

       28
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       29
        
       

     

       30
        
       if __name__ == "__main__":

     

       31
       -
           main(Path("./data"))

···

       1
       +
       import queue

     

       2
       +
       import threading

     

       3
        
       from pathlib import Path

     

       4
       +
       from time import sleep

     

       5
       +
       from typing import Callable

     

       6
        
       

     

       7
       +
       import env

     

       8
        
       from database.migrations import DatabaseMigrator

     

       9
        
       from util.util import LOGGER

     

       10
        
       

     

       11
        
       

     

       12
       +
       def main() -> None:

     

       13
       +
           data = Path(env.DATA_DIR)

     

       14
       +
       

     

       15
        
           if not data.exists():

     

       16
        
               data.mkdir(parents=True)

     

       17
        
       

     
···

       20
        
       

     

       21
        
           if not settings.exists():

     

       22
        
               LOGGER.info("First launch detected! Creating %s and exiting!", settings)

     

       23
       +
               return

     

       24
        
       

     

       25
        
           LOGGER.info("Loading settings...")

     

       26
        
           # TODO

     

       27
        
       

     

       28
       +
           migrator = DatabaseMigrator(database, Path(env.MIGRATIONS_DIR))

     

       29
        
           try:

     

       30
        
               migrator.migrate()

     

       31
        
           except Exception:

     
···

       33
        
           finally:

     

       34
        
               migrator.close()

     

       35
        
       

     

       36
       +
           LOGGER.info("Starting task worker...")

     

       37
       +
       

     

       38
       +
           def worker(task_queue: queue.Queue[Callable[[], None] | None]):

     

       39
       +
               while True:

     

       40
       +
                   task = task_queue.get()

     

       41
       +
                   if task is None:

     

       42
       +
                       break

     

       43
       +
       

     

       44
       +
                   try:

     

       45
       +
                       task()

     

       46
       +
                   except Exception:

     

       47
       +
                       LOGGER.exception("Exception in worker thread!")

     

       48
       +
                   finally:

     

       49
       +
                       task_queue.task_done()

     

       50
       +
       

     

       51
       +
           task_queue: queue.Queue[Callable[[], None] | None] = queue.Queue()

     

       52
       +
           thread = threading.Thread(target=worker, args=(task_queue,), daemon=True)

     

       53
       +
           thread.start()

     

       54
       +
       

     

       55
       +
           LOGGER.info("Connecting to %s...", 'TODO') # TODO

     

       56
       +
           try:

     

       57
       +
               task_queue.put(lambda: print("hi"))

     

       58
       +
               sleep(10) # TODO

     

       59
       +
           except KeyboardInterrupt:

     

       60
       +
               LOGGER.info("Stopping...")

     

       61
       +
       

     

       62
       +
           task_queue.join()

     

       63
       +
           task_queue.put(None)

     

       64
       +
           thread.join()

     

       65
        
       

     

       66
        
       if __name__ == "__main__":

     

       67
       +
           main()

-2

migrations/001_initdb.sql

···

       1
       -
       PRAGMA foreign_keys = ON;

     

       2
       -
       

     

       3
        
       CREATE TABLE IF NOT EXISTS posts (

     

       4
        
           id         INTEGER PRIMARY KEY AUTOINCREMENT,

     

       5
        
           user_id    TEXT NOT NULL,

···

       0
        
       
     

       0
        
       
     

       1
        
       CREATE TABLE IF NOT EXISTS posts (

     

       2
        
           id         INTEGER PRIMARY KEY AUTOINCREMENT,

     

       3
        
           user_id    TEXT NOT NULL,