golded 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
golded/__init__.py ADDED
File without changes
golded/__main__.py ADDED
@@ -0,0 +1,3 @@
1
+ from golded.cli import main
2
+
3
+ main()
golded/cli.py ADDED
@@ -0,0 +1,65 @@
1
+ import argparse
2
+ import sqlite3
3
+ import sys
4
+
5
+ from golded.data.store import open_message_store
6
+ from golded.logic.user_config import THEME_NAMES, load_user_config
7
+ from golded.ui.app import run
8
+
9
+ DEFAULT_DATABASE = "messages.sqlite3"
10
+ DEFAULT_CONFIG = "golded.toml"
11
+
12
+
13
+ def main() -> None:
14
+ parser = argparse.ArgumentParser(
15
+ prog="golded", description="GoldED.py message reader"
16
+ )
17
+ parser.add_argument(
18
+ "--config",
19
+ default=DEFAULT_CONFIG,
20
+ help="path to golded.toml (default: golded.toml)",
21
+ )
22
+ parser.add_argument(
23
+ "--database",
24
+ default=None,
25
+ help="path to SQLite message database (overrides config)",
26
+ )
27
+ parser.add_argument(
28
+ "--theme",
29
+ choices=THEME_NAMES,
30
+ default=None,
31
+ help="colour theme (overrides config; toggle with F9)",
32
+ )
33
+ args = parser.parse_args()
34
+
35
+ try:
36
+ user_config = load_user_config(args.config)
37
+ except (OSError, ValueError) as error:
38
+ print(f"Cannot read config {args.config}: {error}", file=sys.stderr)
39
+ raise SystemExit(1) from None
40
+
41
+ if args.database is None:
42
+ database = (
43
+ DEFAULT_DATABASE if user_config.database == "" else user_config.database
44
+ )
45
+ else:
46
+ database = args.database
47
+
48
+ theme = user_config.theme if args.theme is None else args.theme
49
+
50
+ try:
51
+ store = open_message_store(database)
52
+ except FileNotFoundError:
53
+ print(f"Database not found: {database}", file=sys.stderr)
54
+ print("Pass --database PATH or set database in golded.toml.", file=sys.stderr)
55
+ raise SystemExit(1) from None
56
+ except (sqlite3.Error, ValueError) as error:
57
+ # golded-ftn-sqlite raises ValueError for a foreign or unsupported schema.
58
+ print(f"Cannot open database {database}: {error}", file=sys.stderr)
59
+ raise SystemExit(1) from None
60
+
61
+ run(store, theme, user_config)
62
+
63
+
64
+ if __name__ == "__main__":
65
+ main()
File without changes
golded/data/area.py ADDED
@@ -0,0 +1,8 @@
1
+ """One message area in the store."""
2
+
3
+
4
+ class Area:
5
+ def __init__(self, code: str, name: str, kind: str = "echomail") -> None:
6
+ self.code = code
7
+ self.name = name
8
+ self.kind = kind
@@ -0,0 +1,99 @@
1
+ """SQLite message store."""
2
+
3
+ from collections.abc import Sequence
4
+ from pathlib import Path
5
+
6
+ from golded_ftn import FtnAddress, OutgoingMessage, ParsedMessage
7
+ from golded_ftn_sqlite import (
8
+ AreaDefinition,
9
+ AreaKind,
10
+ SqliteDatabase,
11
+ SqliteReader,
12
+ SqliteWriter,
13
+ )
14
+
15
+ from golded.data.area import Area
16
+ from golded.data.store import MessageStore
17
+
18
+
19
+ def _to_definition(
20
+ area: Area, default_origin: FtnAddress | None = None
21
+ ) -> AreaDefinition:
22
+ return AreaDefinition(
23
+ code=area.code,
24
+ name=area.name,
25
+ kind=AreaKind(area.kind),
26
+ default_origin=default_origin,
27
+ )
28
+
29
+
30
+ def _from_definition(area: AreaDefinition) -> Area:
31
+ if area.kind is AreaKind.NETMAIL:
32
+ kind = "netmail"
33
+ else:
34
+ kind = "echomail"
35
+
36
+ return Area(area.code, area.name, kind)
37
+
38
+
39
+ class SqliteMessageStore(MessageStore):
40
+ def __init__(self, path: Path) -> None:
41
+ self.__path = path
42
+ self.__db = SqliteDatabase.open(path)
43
+
44
+ def areas(self) -> tuple[Area, ...]:
45
+ result = []
46
+ for area in self.__db.areas():
47
+ result.append(_from_definition(area))
48
+
49
+ return tuple(result)
50
+
51
+ def messages(self, area: str) -> tuple[ParsedMessage, ...]:
52
+ result = []
53
+ for message in SqliteReader(area).read(self.__path):
54
+ result.append(message)
55
+
56
+ return tuple(result)
57
+
58
+ def message(self, area: str, msgno: int) -> ParsedMessage:
59
+ with SqliteWriter(area).open(self.__path) as session:
60
+ return session.read(msgno).message
61
+
62
+ def append(self, area: str, message: OutgoingMessage) -> int:
63
+ with SqliteWriter(area).open(self.__path) as session:
64
+ result = session.append(message)
65
+
66
+ return result.identity.msgno
67
+
68
+ def delete(self, area: str, msgno: int) -> None:
69
+ with SqliteWriter(area).open(self.__path) as session:
70
+ stored = session.read(msgno)
71
+ session.delete(stored.identity, stored.revision)
72
+
73
+
74
+ def open_message_store(path: str | Path) -> SqliteMessageStore:
75
+ return SqliteMessageStore(Path(path).resolve())
76
+
77
+
78
+ def create_message_store(
79
+ path: str | Path,
80
+ areas: Sequence[Area],
81
+ default_origin: FtnAddress | None = None,
82
+ ) -> SqliteMessageStore:
83
+ if len(areas) == 0:
84
+ raise ValueError("at least one area is required")
85
+
86
+ database_path = Path(path).resolve()
87
+
88
+ first = areas[0]
89
+
90
+ SqliteDatabase.create(
91
+ database_path,
92
+ area=_to_definition(first, default_origin),
93
+ )
94
+
95
+ db = SqliteDatabase.open(database_path)
96
+ for area in areas[1:]:
97
+ db.add_area(_to_definition(area))
98
+
99
+ return SqliteMessageStore(database_path)
golded/data/store.py ADDED
@@ -0,0 +1,47 @@
1
+ """Message store ABC and open/create entry points; implementation in sqlite_store."""
2
+
3
+ from abc import ABC, abstractmethod
4
+ from collections.abc import Sequence
5
+ from pathlib import Path
6
+
7
+ from golded_ftn import FtnAddress, OutgoingMessage, ParsedMessage
8
+
9
+ from golded.data.area import Area
10
+
11
+
12
+ class MessageStore(ABC):
13
+ @abstractmethod
14
+ def areas(self) -> tuple[Area, ...]:
15
+ pass
16
+
17
+ @abstractmethod
18
+ def messages(self, area: str) -> tuple[ParsedMessage, ...]:
19
+ pass
20
+
21
+ @abstractmethod
22
+ def message(self, area: str, msgno: int) -> ParsedMessage:
23
+ pass
24
+
25
+ @abstractmethod
26
+ def append(self, area: str, message: OutgoingMessage) -> int:
27
+ pass
28
+
29
+ @abstractmethod
30
+ def delete(self, area: str, msgno: int) -> None:
31
+ pass
32
+
33
+
34
+ def open_message_store(path: str | Path) -> MessageStore:
35
+ from golded.data.sqlite_store import open_message_store as open_store
36
+
37
+ return open_store(path)
38
+
39
+
40
+ def create_message_store(
41
+ path: str | Path,
42
+ areas: Sequence[Area],
43
+ default_origin: FtnAddress | None = None,
44
+ ) -> MessageStore:
45
+ from golded.data.sqlite_store import create_message_store as create_store
46
+
47
+ return create_store(path, areas, default_origin)
File without changes
@@ -0,0 +1,15 @@
1
+ """Optional display repair for damaged charset text."""
2
+
3
+ from golded_ftn import repair_mojibake
4
+ from rich.text import Text
5
+
6
+
7
+ def for_display(text: str, repair: bool) -> str:
8
+ if not repair:
9
+ return text
10
+
11
+ return repair_mojibake(text).text
12
+
13
+
14
+ def literal_text(text: str) -> Text:
15
+ return Text(text)
golded/logic/quote.py ADDED
@@ -0,0 +1,124 @@
1
+ """Classic GoldED FL quote initials."""
2
+
3
+
4
+ def quote_initials(from_name: str) -> str:
5
+ words = from_name.split()
6
+ letters = []
7
+
8
+ for word in words:
9
+ for character in word:
10
+ if character.isalpha():
11
+ letters.append(character.upper())
12
+ break
13
+
14
+ if len(letters) == 0:
15
+ return ""
16
+
17
+ if len(letters) == 1:
18
+ return letters[0]
19
+
20
+ return letters[0] + letters[-1]
21
+
22
+
23
+ def _is_origin_line(line: str) -> bool:
24
+ return line.startswith(" * Origin: ")
25
+
26
+
27
+ def _is_tearline_line(line: str) -> bool:
28
+ return line.startswith("--- ")
29
+
30
+
31
+ def _trailing_tagline_start(lines: list[str]) -> int | None:
32
+ index = len(lines) - 1
33
+
34
+ while index >= 0 and lines[index].strip() == "":
35
+ index -= 1
36
+
37
+ if index < 0 or not _is_origin_line(lines[index]):
38
+ return None
39
+
40
+ tear_index = index - 1
41
+ while tear_index >= 0 and lines[tear_index].strip() == "":
42
+ tear_index -= 1
43
+
44
+ if tear_index < 0 or not _is_tearline_line(lines[tear_index]):
45
+ return None
46
+
47
+ return tear_index
48
+
49
+
50
+ def body_without_tearline(body_text: str) -> str:
51
+ lines = body_text.splitlines()
52
+ start = _trailing_tagline_start(lines)
53
+
54
+ if start is None:
55
+ return body_text
56
+
57
+ return "\n".join(lines[:start])
58
+
59
+
60
+ def split_body_at_tagline(body_text: str) -> tuple[str, str]:
61
+ lines = body_text.splitlines()
62
+ start = _trailing_tagline_start(lines)
63
+
64
+ if start is None:
65
+ return body_text, ""
66
+
67
+ return "\n".join(lines[:start]), "\n".join(lines[start:])
68
+
69
+
70
+ def has_golded_tagline(body_text: str) -> bool:
71
+ lines = body_text.splitlines()
72
+ start = _trailing_tagline_start(lines)
73
+
74
+ if start is not None:
75
+ return lines[start].startswith("--- GoldED")
76
+
77
+ index = len(lines) - 1
78
+ while index >= 0 and lines[index].strip() == "":
79
+ index -= 1
80
+
81
+ if index < 0:
82
+ return False
83
+
84
+ return lines[index].startswith("--- GoldED")
85
+
86
+
87
+ def quote_body(from_name: str, body_text: str) -> str:
88
+ initials = quote_initials(from_name)
89
+ main = body_without_tearline(body_text)
90
+ lines = []
91
+
92
+ for line in main.splitlines():
93
+ if initials == "":
94
+ if line == "":
95
+ lines.append(">")
96
+ else:
97
+ lines.append("> " + line)
98
+ else:
99
+ if line == "":
100
+ lines.append(initials + ">")
101
+ else:
102
+ lines.append(initials + "> " + line)
103
+
104
+ return "\n".join(lines) + "\n"
105
+
106
+
107
+ def first_name(full_name: str) -> str:
108
+ words = full_name.split()
109
+ if len(words) == 0:
110
+ return ""
111
+
112
+ return words[0]
113
+
114
+
115
+ def reply_intro(from_name: str, body_for_quote: str) -> str:
116
+ name = first_name(from_name)
117
+ if name == "":
118
+ greeting = "Hello"
119
+ else:
120
+ greeting = "Hello " + name
121
+
122
+ quoted = quote_body(from_name, body_for_quote)
123
+
124
+ return greeting + "\n\n" + quoted
@@ -0,0 +1,304 @@
1
+ """Selected area, current message and draft."""
2
+
3
+ from golded_ftn import FtnAddress, OutgoingMessage, ParsedMessage
4
+
5
+ from golded.data.area import Area
6
+ from golded.data.store import MessageStore
7
+ from golded.logic.quote import reply_intro
8
+ from golded.logic.subject import reply_subject, thread_subject
9
+ from golded.logic.tear_origin import with_tear_origin
10
+ from golded.logic.thread_tree import ThreadRow, build_thread_rows
11
+ from golded.logic.user_config import UserConfig
12
+
13
+
14
+ class Session:
15
+ def __init__(
16
+ self,
17
+ store: MessageStore,
18
+ user_config: UserConfig | None = None,
19
+ ) -> None:
20
+ self.__store = store
21
+ self.__user = UserConfig() if user_config is None else user_config
22
+ self.__selected_area: str | None = None
23
+ self.__current_message_index: int | None = None
24
+ self.__draft_message: OutgoingMessage | None = None
25
+ self.__draft_area: str | None = None
26
+ self.__threaded_list = self.__user.threaded_list
27
+ self.__message_rows_cache: list[ThreadRow] | None = None
28
+ self.__cache_area: str | None = None
29
+ self.__cache_threaded: bool | None = None
30
+
31
+ def __clear_message_cache(self) -> None:
32
+ self.__message_rows_cache = None
33
+
34
+ def areas(self) -> tuple[Area, ...]:
35
+ return self.__store.areas()
36
+
37
+ def selected_area(self) -> str | None:
38
+ return self.__selected_area
39
+
40
+ def current_message_index(self) -> int | None:
41
+ return self.__current_message_index
42
+
43
+ def message_count(self, area: str) -> int:
44
+ return len(self.__store.messages(area))
45
+
46
+ def draft_message(self) -> OutgoingMessage | None:
47
+ return self.__draft_message
48
+
49
+ def draft_area(self) -> str | None:
50
+ return self.__draft_area
51
+
52
+ def splash_seconds(self) -> int:
53
+ return self.__user.splash_seconds
54
+
55
+ def threaded_list(self) -> bool:
56
+ return self.__threaded_list
57
+
58
+ def toggle_threaded_list(self) -> bool:
59
+ current = self.current_message()
60
+ msgno = None
61
+ if current is not None:
62
+ msgno = current.msgno
63
+
64
+ self.__threaded_list = not self.__threaded_list
65
+
66
+ if msgno is not None:
67
+ self.select_message(msgno)
68
+
69
+ return self.__threaded_list
70
+
71
+ def select_area(self, area: str) -> None:
72
+ self.__selected_area = area
73
+ self.__current_message_index = None
74
+ self.__clear_message_cache()
75
+
76
+ def message_rows(self) -> list[ThreadRow]:
77
+ if self.__selected_area is None:
78
+ return []
79
+
80
+ if (
81
+ self.__message_rows_cache is not None
82
+ and self.__cache_area == self.__selected_area
83
+ and self.__cache_threaded == self.__threaded_list
84
+ ):
85
+ return self.__message_rows_cache
86
+
87
+ messages = self.__store.messages(self.__selected_area)
88
+
89
+ if self.__threaded_list:
90
+ rows = build_thread_rows(messages)
91
+ else:
92
+ rows = []
93
+ for message in messages:
94
+ rows.append(ThreadRow(message, []))
95
+
96
+ self.__cache_area = self.__selected_area
97
+ self.__cache_threaded = self.__threaded_list
98
+ self.__message_rows_cache = rows
99
+
100
+ return rows
101
+
102
+ def messages(self) -> tuple[ParsedMessage, ...]:
103
+ rows = self.message_rows()
104
+ result = []
105
+ for row in rows:
106
+ result.append(row.message)
107
+
108
+ return tuple(result)
109
+
110
+ def select_message(self, msgno: int) -> None:
111
+ messages = self.messages()
112
+
113
+ for index, message in enumerate(messages):
114
+ if message.msgno == msgno:
115
+ self.__current_message_index = index
116
+ return
117
+
118
+ self.__current_message_index = None
119
+
120
+ def current_message(self) -> ParsedMessage | None:
121
+ if self.__current_message_index is None:
122
+ return None
123
+
124
+ messages = self.messages()
125
+ if self.__current_message_index >= len(messages):
126
+ return None
127
+
128
+ return messages[self.__current_message_index]
129
+
130
+ def next_message(self) -> None:
131
+ if self.__current_message_index is None:
132
+ return
133
+
134
+ messages = self.messages()
135
+
136
+ if self.__current_message_index + 1 < len(messages):
137
+ self.__current_message_index = self.__current_message_index + 1
138
+
139
+ def previous_message(self) -> None:
140
+ if self.__current_message_index is None:
141
+ return
142
+
143
+ if self.__current_message_index > 0:
144
+ self.__current_message_index = self.__current_message_index - 1
145
+
146
+ def next_subject_message(self) -> None:
147
+ if self.__current_message_index is None:
148
+ return
149
+
150
+ messages = self.messages()
151
+
152
+ current = messages[self.__current_message_index]
153
+ subject = thread_subject(current.subject)
154
+
155
+ for index, message in enumerate(messages):
156
+ if index <= self.__current_message_index:
157
+ continue
158
+ if thread_subject(message.subject) == subject:
159
+ self.__current_message_index = index
160
+ return
161
+
162
+ def previous_subject_message(self) -> None:
163
+ if self.__current_message_index is None:
164
+ return
165
+
166
+ messages = self.messages()
167
+
168
+ current = messages[self.__current_message_index]
169
+ subject = thread_subject(current.subject)
170
+
171
+ for index, message in reversed(list(enumerate(messages))):
172
+ if index >= self.__current_message_index:
173
+ continue
174
+ if thread_subject(message.subject) == subject:
175
+ self.__current_message_index = index
176
+ return
177
+
178
+ def area_name(self, area: str) -> str:
179
+ for item in self.__store.areas():
180
+ if item.code == area:
181
+ return item.name
182
+
183
+ return area
184
+
185
+ def area_kind(self, area: str) -> str:
186
+ for item in self.__store.areas():
187
+ if item.code == area:
188
+ return item.kind
189
+
190
+ return "echomail"
191
+
192
+ def start_draft_message(self) -> None:
193
+ if self.__selected_area is None:
194
+ return
195
+
196
+ to_name = ""
197
+ if self.area_kind(self.__selected_area) == "echomail":
198
+ to_name = "All"
199
+
200
+ self.__draft_area = self.__selected_area
201
+
202
+ self.__draft_message = OutgoingMessage(
203
+ from_name=self.__user.from_name,
204
+ to_name=to_name,
205
+ subject="",
206
+ body_text=with_tear_origin(
207
+ "",
208
+ self.__user.origin,
209
+ self.__user.from_address,
210
+ ),
211
+ from_address=self.__user.from_address,
212
+ )
213
+
214
+ def start_reply_draft(
215
+ self,
216
+ body_for_quote: str,
217
+ subject_for_reply: str | None = None,
218
+ ) -> None:
219
+ if self.__selected_area is None:
220
+ return
221
+
222
+ message = self.current_message()
223
+ if message is None:
224
+ return
225
+
226
+ if subject_for_reply is None:
227
+ subject_for_reply = message.subject
228
+
229
+ body = reply_intro(message.from_name, body_for_quote)
230
+
231
+ self.__draft_area = self.__selected_area
232
+
233
+ # The reader returns addresses as text; the writer stores str(FtnAddress),
234
+ # so parsing it back gives the same address.
235
+ to_address = None
236
+ if message.from_address is not None:
237
+ to_address = FtnAddress.from_string(message.from_address)
238
+
239
+ self.__draft_message = OutgoingMessage(
240
+ from_name=self.__user.from_name,
241
+ to_name=message.from_name,
242
+ subject=reply_subject(subject_for_reply),
243
+ body_text=with_tear_origin(
244
+ body,
245
+ self.__user.origin,
246
+ self.__user.from_address,
247
+ ),
248
+ reply_to_msgno=message.msgno,
249
+ from_address=self.__user.from_address,
250
+ to_address=to_address,
251
+ )
252
+
253
+ def set_draft_message(self, message: OutgoingMessage) -> None:
254
+ if self.__draft_area is None:
255
+ return
256
+
257
+ self.__draft_message = message
258
+
259
+ def discard_draft_message(self) -> None:
260
+ self.__draft_message = None
261
+ self.__draft_area = None
262
+
263
+ def save_draft_message(self) -> int | None:
264
+ if self.__draft_message is None or self.__draft_area is None:
265
+ return None
266
+
267
+ if self.__draft_message.from_name.strip() == "":
268
+ raise ValueError("from name is required")
269
+
270
+ if self.__draft_message.to_name.strip() == "":
271
+ raise ValueError("to name is required")
272
+
273
+ if self.__draft_message.subject.strip() == "":
274
+ raise ValueError("subject is required")
275
+
276
+ if (
277
+ self.area_kind(self.__draft_area) == "netmail"
278
+ and self.__draft_message.to_address is None
279
+ ):
280
+ raise ValueError("netmail requires a destination address")
281
+
282
+ draft = self.__draft_message
283
+
284
+ message = OutgoingMessage(
285
+ from_name=draft.from_name,
286
+ to_name=draft.to_name,
287
+ subject=draft.subject,
288
+ body_text=with_tear_origin(
289
+ draft.body_text,
290
+ self.__user.origin,
291
+ draft.from_address,
292
+ ),
293
+ reply_to_msgno=draft.reply_to_msgno,
294
+ from_address=draft.from_address,
295
+ to_address=draft.to_address,
296
+ )
297
+
298
+ msgno = self.__store.append(self.__draft_area, message)
299
+
300
+ self.__draft_message = None
301
+ self.__draft_area = None
302
+ self.__clear_message_cache()
303
+
304
+ return msgno
@@ -0,0 +1,22 @@
1
+ """Subject line helpers for threads and replies."""
2
+
3
+
4
+ def subject_without_re(subject: str) -> str:
5
+ text = subject.strip()
6
+
7
+ while True:
8
+ lower = text.lower()
9
+ if lower.startswith("re:"):
10
+ text = text[3:].lstrip()
11
+ else:
12
+ break
13
+
14
+ return text
15
+
16
+
17
+ def thread_subject(subject: str) -> str:
18
+ return subject_without_re(subject).lower()
19
+
20
+
21
+ def reply_subject(subject: str) -> str:
22
+ return "Re: " + subject_without_re(subject)