···

       
2
       
 
       


     

       
3
       
 
       


     

       
4
       
 
       
@dataclass

     

       
5
       
-
       
class Attachment():

     

       
6
       
 
       
    pass

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
@dataclass

     

       
9
       
 
       
class SpoilerAttachment(Attachment):

     

       
10
       
 
       
    spoiler: str

     

       
0
       
 
       

     

       
11
       
 
       


     

       
12
       
 
       
@dataclass

     

       
13
       
 
       
class LanguagesAttachment(Attachment):

     

       
14
       
 
       
    langs: list[str]

     

       
15
       
 
       


     

       
0
       
 
       

     

       
16
       
 
       
@dataclass

     

       
17
       
 
       
class SensitiveAttachment(Attachment):

     

       
18
       
 
       
    sensitive: bool

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
 
       
@dataclass

     

       
21
       
 
       
class RemoteUrlAttachment(Attachment):

     

       
22
       
 
       
    url: str

     

       
0
       
 
       

     

       
23
       
 
       


     

       
24
       
 
       
@dataclass

     

       
25
       
 
       
class QuoteAttachment(Attachment):

     

···

       
2
       
 
       


     

       
3
       
 
       


     

       
4
       
 
       
@dataclass

     

       
5
       
+
       
class Attachment:

     

       
6
       
 
       
    pass

     

       
7
       
+
       


     

       
8
       
 
       


     

       
9
       
 
       
@dataclass

     

       
10
       
 
       
class SpoilerAttachment(Attachment):

     

       
11
       
 
       
    spoiler: str

     

       
12
       
+
       


     

       
13
       
 
       


     

       
14
       
 
       
@dataclass

     

       
15
       
 
       
class LanguagesAttachment(Attachment):

     

       
16
       
 
       
    langs: list[str]

     

       
17
       
 
       


     

       
18
       
+
       


     

       
19
       
 
       
@dataclass

     

       
20
       
 
       
class SensitiveAttachment(Attachment):

     

       
21
       
 
       
    sensitive: bool

     

       
22
       
+
       


     

       
23
       
 
       


     

       
24
       
 
       
@dataclass

     

       
25
       
 
       
class RemoteUrlAttachment(Attachment):

     

       
26
       
 
       
    url: str

     

       
27
       
+
       


     

       
28
       
 
       


     

       
29
       
 
       
@dataclass

     

       
30
       
 
       
class QuoteAttachment(Attachment):

     

···

       
1
       
 
       
from dataclasses import dataclass

     

       
2
       
 
       


     

       
0
       
 
       

     

       
3
       
 
       
@dataclass

     

       
4
       
 
       
class Fragment:

     

       
5
       
 
       
    start: int

     

       
6
       
 
       
    end: int

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
@dataclass

     

       
9
       
 
       
class LinkFragment(Fragment):

     

       
10
       
 
       
    url: str

     

       
11
       
 
       


     

       
0
       
 
       

     

       
12
       
 
       
@dataclass

     

       
13
       
 
       
class TagFragment(Fragment):

     

       
14
       
 
       
    tag: str

     

       
0
       
 
       

     

       
15
       
 
       


     

       
16
       
 
       
@dataclass

     

       
17
       
 
       
class MentionFragment(Fragment):

     

···

       
1
       
 
       
from dataclasses import dataclass

     

       
2
       
 
       


     

       
3
       
+
       


     

       
4
       
 
       
@dataclass

     

       
5
       
 
       
class Fragment:

     

       
6
       
 
       
    start: int

     

       
7
       
 
       
    end: int

     

       
8
       
+
       


     

       
9
       
 
       


     

       
10
       
 
       
@dataclass

     

       
11
       
 
       
class LinkFragment(Fragment):

     

       
12
       
 
       
    url: str

     

       
13
       
 
       


     

       
14
       
+
       


     

       
15
       
 
       
@dataclass

     

       
16
       
 
       
class TagFragment(Fragment):

     

       
17
       
 
       
    tag: str

     

       
18
       
+
       


     

       
19
       
 
       


     

       
20
       
 
       
@dataclass

     

       
21
       
 
       
class MentionFragment(Fragment):

     

···

       
1
       
 
       
from dataclasses import dataclass, field

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2
       
 
       
from cross.attachments import Attachment

     

       
3
       
 
       
from cross.fragments import Fragment

     

       
4
       
-
       
from typing import TypeVar

     

       
5
       
 
       


     

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

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
class AttachmentKeeper:

     

       
9
       
 
       
    def __init__(self) -> None:

     
···

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

     

       
21
       
 
       
        return instance

     

       
22
       
 
       


     

       
0
       
 
       

     

       
23
       
 
       
@dataclass

     

       
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)

     

···

       
1
       
 
       
from dataclasses import dataclass, field

     

       
2
       
+
       
from typing import TypeVar

     

       
3
       
+
       


     

       
4
       
 
       
from cross.attachments import Attachment

     

       
5
       
 
       
from cross.fragments import Fragment

     

       
0
       
 
       

     

       
6
       
 
       


     

       
7
       
+
       
T = TypeVar("T", bound=Attachment)

     

       
8
       
+
       


     

       
9
       
 
       


     

       
10
       
 
       
class AttachmentKeeper:

     

       
11
       
 
       
    def __init__(self) -> None:

     
···

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

     

       
23
       
 
       
        return instance

     

       
24
       
 
       


     

       
25
       
+
       


     

       
26
       
 
       
@dataclass

     

       
27
       
 
       
class Post:

     

       
28
       
 
       
    id: str

     

       
29
       
 
       
    parent_id: str | None

     

       
30
       
+
       
    text: str  # utf-8 text

     

       
31
       
 
       
    attachments: AttachmentKeeper

     

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

     

···

       
1
       
-
       
from pathlib import Path

     

       
2
       
 
       
import sqlite3

     

       
0
       
 
       

     

       
3
       
 
       
from typing import Callable, cast

     

       
4
       
 
       


     

       
0
       
 
       

     

       
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:

     
···

       
33
       
 
       
    def close(self):

     

       
34
       
 
       
        self.conn.close()

     

       
35
       
 
       


     

       
0
       
 
       

     

       
36
       
 
       
class OutputService(Service):

     

       
37
       
 
       
    def accept_post(self, post: Post):

     

       
38
       
 
       
        LOGGER.warning("NOT IMPLEMENTED (%s), accept_post %s", self.url, post.id)

     
···

       
41
       
 
       
        LOGGER.warning("NOT IMPLEMENTED (%s), delete_post %s", self.url, post_id)

     

       
42
       
 
       


     

       
43
       
 
       
    def accept_repost(self, repost_id: str, reposted_id: str):

     

       
44
       
-
       
        LOGGER.warning("NOT IMPLEMENTED (%s), accept_repost %s of %s", self.url, repost_id, reposted_id)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
45
       
 
       


     

       
46
       
 
       
    def delete_repost(self, repost_id: str):

     

       
47
       
 
       
        LOGGER.warning("NOT IMPLEMENTED (%s), delete_repost %s", self.url, repost_id)

     

       
48
       
 
       


     

       
49
       
-
       
class InputService(Service):

     

       
50
       
 
       


     

       
51
       
-
       
    async def listen(self, outputs: list[OutputService], submitter: Callable[[Callable[[], None]], None]):  # pyright: ignore[reportUnusedParameter]

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
52
       
 
       
        pass

     

···

       
0
       
 
       

     

       
1
       
 
       
import sqlite3

     

       
2
       
+
       
from pathlib import Path

     

       
3
       
 
       
from typing import Callable, cast

     

       
4
       
 
       


     

       
5
       
+
       
from cross.post import Post

     

       
6
       
 
       
from database.connection import get_conn

     

       
7
       
 
       
from util.util import LOGGER

     

       
8
       
 
       


     

       
0
       
 
       

     

       
9
       
 
       


     

       
10
       
 
       
class Service:

     

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

     
···

       
33
       
 
       
    def close(self):

     

       
34
       
 
       
        self.conn.close()

     

       
35
       
 
       


     

       
36
       
+
       


     

       
37
       
 
       
class OutputService(Service):

     

       
38
       
 
       
    def accept_post(self, post: Post):

     

       
39
       
 
       
        LOGGER.warning("NOT IMPLEMENTED (%s), accept_post %s", self.url, post.id)

     
···

       
42
       
 
       
        LOGGER.warning("NOT IMPLEMENTED (%s), delete_post %s", self.url, post_id)

     

       
43
       
 
       


     

       
44
       
 
       
    def accept_repost(self, repost_id: str, reposted_id: str):

     

       
45
       
+
       
        LOGGER.warning(

     

       
46
       
+
       
            "NOT IMPLEMENTED (%s), accept_repost %s of %s",

     

       
47
       
+
       
            self.url,

     

       
48
       
+
       
            repost_id,

     

       
49
       
+
       
            reposted_id,

     

       
50
       
+
       
        )

     

       
51
       
 
       


     

       
52
       
 
       
    def delete_repost(self, repost_id: str):

     

       
53
       
 
       
        LOGGER.warning("NOT IMPLEMENTED (%s), delete_repost %s", self.url, repost_id)

     

       
54
       
 
       


     

       
0
       
 
       

     

       
55
       
 
       


     

       
56
       
+
       
class InputService(Service):

     

       
57
       
+
       
    async def listen(

     

       
58
       
+
       
        self,

     

       
59
       
+
       
        outputs: list[OutputService],

     

       
60
       
+
       
        submitter: Callable[[Callable[[], None]], None],

     

       
61
       
+
       
    ):  # pyright: ignore[reportUnusedParameter]

     

       
62
       
 
       
        pass

     

···

       
0
       
 
       

     

       
1
       
 
       
from pathlib import Path

     

       
2
       
-
       
import sqlite3

     

       
3
       
 
       


     

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

     

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

     

···

       
1
       
+
       
import sqlite3

     

       
2
       
 
       
from pathlib import Path

     

       
3
       
+
       


     

       
4
       
 
       


     

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

     

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

     

···

       
1
       
 
       
import sqlite3

     

       
2
       
 
       
from pathlib import Path

     

       
3
       
 
       


     

       
4
       
-
       
from util.util import LOGGER

     

       
5
       
 
       
from database.connection import get_conn

     

       
0
       
 
       

     

       
6
       
 
       


     

       
7
       
 
       


     

       
8
       
 
       
class DatabaseMigrator:

     

···

       
1
       
 
       
import sqlite3

     

       
2
       
 
       
from pathlib import Path

     

       
3
       
 
       


     

       
0
       
 
       

     

       
4
       
 
       
from database.connection import get_conn

     

       
5
       
+
       
from util.util import LOGGER

     

       
6
       
 
       


     

       
7
       
 
       


     

       
8
       
 
       
class DatabaseMigrator:

     

···

       
1
       
 
       
import os

     

       
2
       
 
       


     

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

     

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

     

···

       
1
       
 
       
import os

     

       
2
       
 
       


     

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

     

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

     

···

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

     

       
54
       
 
       
    thread.start()

     

       
55
       
 
       


     

       
56
       
-
       
    LOGGER.info("Connecting to %s...", 'TODO') # TODO

     

       
57
       
 
       
    try:

     

       
58
       
 
       
        task_queue.put(lambda: print("hi"))

     

       
59
       
-
       
        sleep(10) # TODO

     

       
60
       
 
       
    except KeyboardInterrupt:

     

       
61
       
 
       
        LOGGER.info("Stopping...")

     

       
62
       
 
       


     

       
63
       
 
       
    task_queue.join()

     

       
64
       
 
       
    task_queue.put(None)

     

       
65
       
 
       
    thread.join()

     

       
0
       
 
       

     

       
66
       
 
       


     

       
67
       
 
       
if __name__ == "__main__":

     

       
68
       
 
       
    main()

     

···

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

     

       
54
       
 
       
    thread.start()

     

       
55
       
 
       


     

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

     

       
57
       
 
       
    try:

     

       
58
       
 
       
        task_queue.put(lambda: print("hi"))

     

       
59
       
+
       
        sleep(10)  # TODO

     

       
60
       
 
       
    except KeyboardInterrupt:

     

       
61
       
 
       
        LOGGER.info("Stopping...")

     

       
62
       
 
       


     

       
63
       
 
       
    task_queue.join()

     

       
64
       
 
       
    task_queue.put(None)

     

       
65
       
 
       
    thread.join()

     

       
66
       
+
       


     

       
67
       
 
       


     

       
68
       
 
       
if __name__ == "__main__":

     

       
69
       
 
       
    main()

     

···

       
1
       
 
       
from abc import ABC, abstractmethod

     

       
2
       
-
       
from cross.service import Service

     

       
3
       
 
       


     

       
4
       
 
       
import requests

     

       
5
       
 
       


     

       
0
       
 
       

     

       
6
       
 
       
from util.util import LOGGER

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
class MisskeyService(ABC, Service):

     

       
9
       
 
       
    def verify_credentials(self):

     

···

       
1
       
 
       
from abc import ABC, abstractmethod

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
 
       
import requests

     

       
4
       
 
       


     

       
5
       
+
       
from cross.service import Service

     

       
6
       
 
       
from util.util import LOGGER

     

       
7
       
+
       


     

       
8
       
 
       


     

       
9
       
 
       
class MisskeyService(ABC, Service):

     

       
10
       
 
       
    def verify_credentials(self):

     

···

       
1
       
 
       
import asyncio

     

       
2
       
-
       
from dataclasses import dataclass, field

     

       
3
       
 
       
import json

     

       
4
       
-
       
from pathlib import Path

     

       
5
       
 
       
import re

     

       
6
       
-
       
from typing import Any, Callable, override

     

       
7
       
 
       
import uuid

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
import websockets

     

       
10
       
 
       


     
···

       
85
       
 
       
                    async for msg in ws:

     

       
86
       
 
       
                        LOGGER.info(msg)  # TODO

     

       
87
       
 
       


     

       
88
       
-
       
                #keepalive = asyncio.create_task(self._send_keepalive(ws))

     

       
89
       
 
       
                listen = asyncio.create_task(listen_for_messages())

     

       
90
       
 
       


     

       
91
       
 
       
                _ = await asyncio.gather(listen)

     

···

       
1
       
 
       
import asyncio

     

       
0
       
 
       

     

       
2
       
 
       
import json

     

       
0
       
 
       

     

       
3
       
 
       
import re

     

       
0
       
 
       

     

       
4
       
 
       
import uuid

     

       
5
       
+
       
from dataclasses import dataclass, field

     

       
6
       
+
       
from pathlib import Path

     

       
7
       
+
       
from typing import Any, Callable, override

     

       
8
       
 
       


     

       
9
       
 
       
import websockets

     

       
10
       
 
       


     
···

       
85
       
 
       
                    async for msg in ws:

     

       
86
       
 
       
                        LOGGER.info(msg)  # TODO

     

       
87
       
 
       


     

       
0
       
 
       

     

       
88
       
 
       
                listen = asyncio.create_task(listen_for_messages())

     

       
89
       
 
       


     

       
90
       
 
       
                _ = await asyncio.gather(listen)