commit dba88a76f846b697682321e05ae9998dfafef410 · zenfyr.dev/xpost

+4

cross/attachments.py

···

       20
        
       @dataclass

     

       21
        
       class RemoteUrlAttachment(Attachment):

     

       22
        
           url: str

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       20
        
       @dataclass

     

       21
        
       class RemoteUrlAttachment(Attachment):

     

       22
        
           url: str

     

       23
       +
       

     

       24
       +
       @dataclass

     

       25
       +
       class QuoteAttachment(Attachment):

     

       26
       +
           quoted_id: str

+1 -1

cross/post.py

···

       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)

···

       24
        
       class Post:

     

       25
        
           id: str

     

       26
        
           parent_id: str | None

     

       27
       +
           text: str # utf-8 text

     

       28
        
           attachments: AttachmentKeeper

     

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

+29 -1

cross/service.py

···

       1
        
       from pathlib import Path

     

       2
        
       import sqlite3

     

       3
       -
       from typing import cast

     

       4
        
       

     

       5
        
       from database.connection import get_conn

     

       0
        
       
     

       6
        
       

     

       0
        
       
     

       7
        
       

     

       8
        
       class Service:

     

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

     
···

       27
        
               cursor = self.conn.cursor()

     

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

     

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

     

       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

···

       1
        
       from pathlib import Path

     

       2
        
       import sqlite3

     

       3
       +
       from typing import Callable, cast

     

       4
        
       

     

       5
        
       from database.connection import get_conn

     

       6
       +
       from util.util import LOGGER

     

       7
        
       

     

       8
       +
       from cross.post import Post

     

       9
        
       

     

       10
        
       class Service:

     

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

     
···

       29
        
               cursor = self.conn.cursor()

     

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

     

       31
        
               return cast(sqlite3.Row, cursor.fetchone())

     

       32
       +
       

     

       33
       +
           def close(self):

     

       34
       +
               self.conn.close()

     

       35
       +
       

     

       36
       +
       class OutputService(Service):

     

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

     

       38
       +
               super().__init__(url, db)

     

       39
       +
       

     

       40
       +
           def accept_post(self, post: Post):

     

       41
       +
               LOGGER.warning("NOT IMPLEMENTED, accept_post %s", post.id)

     

       42
       +
       

     

       43
       +
           def delete_post(self, post_id: str):

     

       44
       +
               LOGGER.warning("NOT IMPLEMENTED, delete_post %s", post_id)

     

       45
       +
       

     

       46
       +
           def accept_repost(self, repost_id: str, reposted_id: str):

     

       47
       +
               LOGGER.warning("NOT IMPLEMENTED, accept_repost %s", repost_id)

     

       48
       +
       

     

       49
       +
           def delete_repost(self, repost_id: str):

     

       50
       +
               LOGGER.warning("NOT IMPLEMENTED, delete_repost %s", repost_id)

     

       51
       +
       

     

       52
       +
       class InputService(Service):

     

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

     

       54
       +
               super().__init__(url, db)

     

       55
       +
       

     

       56
       +
           async def listen(self, outputs: list[OutputService], submitter: Callable[[Callable[[], None]], None]):

     

       57
       +
               pass

+1 -1

database/connection.py

···

       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;

···

       2
        
       import sqlite3

     

       3
        
       

     

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

     

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

     

       6
        
           conn.row_factory = sqlite3.Row

     

       7
        
           _ = conn.executescript("""

     

       8
        
               PRAGMA journal_mode = WAL;

+40

mastodon/input.py

···

       1
       +
       import re

     

       2
       +
       from dataclasses import dataclass, field

     

       3
       +
       from pathlib import Path

     

       4
       +
       from typing import Any, Callable, override

     

       5
       +
       

     

       6
       +
       from cross.service import InputService, OutputService

     

       7
       +
       from util.util import LOGGER

     

       8
       +
       

     

       9
       +
       ALLOWED_VISIBILITY: list[str] = ["public", "unlisted"]

     

       10
       +
       

     

       11
       +
       @dataclass(kw_only=True)

     

       12
       +
       class MastodonInputOptions:

     

       13
       +
           token: str

     

       14
       +
           instance: str

     

       15
       +
           allowed_visibility: list[str] = field(default_factory=lambda: ALLOWED_VISIBILITY.copy())

     

       16
       +
           regex_filters: list[re.Pattern[str]] = field(default_factory=lambda: [])

     

       17
       +
       

     

       18
       +
           @classmethod

     

       19
       +
           def from_dict(cls, data: dict[str, Any]) -> 'MastodonInputOptions':

     

       20
       +
               data['instance'] = data['instance'][:-1] if data['instance'].endswith("/") else data['instance']

     

       21
       +
       

     

       22
       +
               if 'allowed_visibility' in data:

     

       23
       +
                   for vis in data.get('allowed_visibility', []):

     

       24
       +
                       if vis not in ALLOWED_VISIBILITY:

     

       25
       +
                           raise ValueError(f"Invalid visibility option {vis}!")

     

       26
       +
       

     

       27
       +
               if 'regex_filters' in data:

     

       28
       +
                   data['regex_filters'] = [re.compile(r) for r in data['regex_filters']]

     

       29
       +
       

     

       30
       +
               return MastodonInputOptions(**data)

     

       31
       +
       

     

       32
       +
       class MastodonInputService(InputService):

     

       33
       +
           def __init__(self, db: Path, options: MastodonInputOptions) -> None:

     

       34
       +
               super().__init__(options.instance, db)

     

       35
       +
       

     

       36
       +
               LOGGER.info("Verifying %s credentails...", self.url)

     

       37
       +
       

     

       38
       +
           @override

     

       39
       +
           async def listen(self, outputs: list[OutputService], submitter: Callable[[Callable[[], None]], None]):

     

       40
       +
               return await super().listen(outputs, submitter) # TODO

+27

mastodon/output.py

···

       1
       +
       from dataclasses import dataclass

     

       2
       +
       from pathlib import Path

     

       3
       +
       from typing import Any

     

       4
       +
       from cross.service import OutputService

     

       5
       +
       

     

       6
       +
       ALLOWED_POSTING_VISIBILITY: list[str] = ["public", "unlisted", "private"]

     

       7
       +
       

     

       8
       +
       @dataclass(kw_only=True)

     

       9
       +
       class MastodonOutputOptions:

     

       10
       +
           token: str

     

       11
       +
           instance: str

     

       12
       +
           visibility: str = "public"

     

       13
       +
       

     

       14
       +
           @classmethod

     

       15
       +
           def from_dict(cls, data: dict[str, Any]) -> 'MastodonOutputOptions':

     

       16
       +
               data['instance'] = data['instance'][:-1] if data['instance'].endswith("/") else data['instance']

     

       17
       +
       

     

       18
       +
               if 'visibility' in data:

     

       19
       +
                   if data['visibility'] not in ALLOWED_POSTING_VISIBILITY:

     

       20
       +
                       raise ValueError(f"Invalid visibility option {data['visibility']}!")

     

       21
       +
       

     

       22
       +
               return MastodonOutputOptions(**data)

     

       23
       +
       

     

       24
       +
       # TODO

     

       25
       +
       class MastodonOutputService(OutputService):

     

       26
       +
           def __init__(self, db: Path, options: MastodonOutputOptions) -> None:

     

       27
       +
               super().__init__(options.instance, db)

+6 -6

migrations/001_initdb.sql

···

       1
        
       CREATE TABLE IF NOT EXISTS posts (

     

       2
        
           id          INTEGER PRIMARY KEY AUTOINCREMENT,

     

       3
       -
           user_id     TEXT NOT NULL,

     

       4
        
           service     TEXT NOT NULL,

     

       5
        
           identifier  TEXT NOT NULL,

     

       6
       -
           parent_id   INTEGER NULL REFERENCES posts(id),

     

       7
       -
           root_id     INTEGER NULL REFERENCES posts(id),

     

       8
       -
           reposted_id INTEGER NULL REFERENCES posts(id),

     

       9
        
           extra_data  TEXT NULL

     

       10
        
       );

     

       11
        
       

     

       12
        
       CREATE TABLE IF NOT EXISTS mappings (

     

       13
       -
           original_post_id INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE,

     

       14
       -
           mapped_post_id   INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE

     

       15
        
       );

···

       1
        
       CREATE TABLE IF NOT EXISTS posts (

     

       2
        
           id          INTEGER PRIMARY KEY AUTOINCREMENT,

     

       3
       +
           user        TEXT NOT NULL,

     

       4
        
           service     TEXT NOT NULL,

     

       5
        
           identifier  TEXT NOT NULL,

     

       6
       +
           parent      INTEGER NULL REFERENCES posts(id),

     

       7
       +
           root        INTEGER NULL REFERENCES posts(id),

     

       8
       +
           reposted    INTEGER NULL REFERENCES posts(id),

     

       9
        
           extra_data  TEXT NULL

     

       10
        
       );

     

       11
        
       

     

       12
        
       CREATE TABLE IF NOT EXISTS mappings (

     

       13
       +
           original INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE,

     

       14
       +
           mapped   INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE

     

       15
        
       );