mastui 0.3.0__py3-none-any.whl

mastui/app.css

@@ -0,0 +1,302 @@
+Screen {
+    layout: vertical;
+}
+
+Timelines {
+    layout: horizontal;
+    height: 1fr;
+}
+
+Timeline {
+    layout: vertical;
+    border: solid $accent;
+    width: 1fr;
+    height: 100%;
+    margin: 1;
+}
+
+.timeline-content {
+    /* This is now empty, as display is handled by the widget itself */
+}
+
+Timeline:focus {
+    border: double $accent-darken-2;
+}
+
+.timeline-header {
+    height: 1;
+    background: $accent;
+    color: $text;
+    dock: top;
+}
+
+.timeline_title {
+    width: 1fr;
+    height: 1;
+    text-align: center;
+    padding: 0 1;
+}
+
+.timeline-refresh-spinner {
+    dock: right;
+    width: auto;
+    height: 1;
+    display: none;
+    margin: 0 1;
+}
+
+.timeline-item {
+    height: auto;
+    margin-bottom: 1;
+}
+
+.boost-header {
+    padding: 0 1;
+    background: $primary-darken-2;
+    color: $text;
+    height: 1;
+}
+
+SplashScreen > Vertical {
+    align: center middle;
+    height: 100%;
+}
+
+
+#logo {
+    width: auto;
+    height: auto;
+}
+
+#version {
+    width: auto;
+    text-align: center;
+}
+
+#splash-status {
+    width: auto;
+    text-align: center;
+}
+
+.action-spinner {
+    display: none;
+}
+
+
+.post-footer {
+    height: 1;
+    padding: 0 1;
+    background: $surface-darken-1;
+}
+
+.post-footer > Static {
+    width: 1fr;
+    text-align: center;
+}
+
+.status-message {
+    margin-top: 1;
+    text-align: center;
+}
+
+Post.favourited {
+    background: $success 20%;
+}
+
+Post.reblogged {
+    background: $warning 20%;
+}
+
+.timeline-item.selected {
+    background: $primary 20%;
+}
+
+Post.selected {
+    background: $primary 20%;
+}
+
+Notification.selected {
+    background: $primary 20%;
+}
+
+
+#dialog {
+    grid-size: 2;
+    grid-gutter: 1;
+    align: center middle;
+    width: 80%;
+    height: auto;
+    max-height: 80%;
+    background: $surface;
+    border: thick $primary 80%;
+    padding: 1;
+}
+
+#dialog > .hidden {
+    display: none;
+}
+
+#auth_link_container {
+    column-span: 2;
+    margin-top: 1;
+    border: round $primary;
+    padding: 1;
+}
+
+#auth_link_container > TextArea {
+    height: 5;
+}
+
+#auth_link_container.hidden {
+    display: none;
+}
+
+#status {
+    column-span: 2;
+    text-align: center;
+    color: $error;
+    height: auto;
+}
+
+#status.hidden {
+    display: none;
+}
+
+#post_dialog {
+    grid-size: 1;
+    grid-gutter: 1;
+    align: center middle;
+    width: 80%;
+    height: auto;
+    max-height: 80%;
+    background: $surface;
+    border: thick $primary 80%;
+    padding: 1;
+}
+
+#post_title {
+    width: 100%;
+    text-align: center;
+    background: $primary;
+    color: $text;
+    padding: 0 1;
+}
+
+#post_content {
+    height: 10;
+}
+
+#post_options {
+    height: auto;
+}
+
+#post_language_container {
+    height: auto;
+}
+
+.post_option_label {
+    width: auto;
+    height: 100%;
+    content-align: left middle;
+}
+
+#cw_input {
+    width: 1fr;
+}
+
+#language_select {
+    width: 1fr;
+}
+
+#post_buttons {
+    width: 100%;
+    align-horizontal: right;
+    height: auto;
+}
+
+#post_buttons > Button {
+    margin-left: 1;
+}
+
+#reply_dialog {
+    grid-size: 1;
+    grid-gutter: 1;
+    align: center middle;
+    width: 80%;
+    height: auto;
+    max-height: 90%;
+    background: $surface;
+    border: thick $primary 80%;
+    padding: 1;
+}
+
+#reply_title {
+    width: 100%;
+    text-align: center;
+    background: $primary;
+    color: $text;
+    padding: 0 1;
+}
+
+#original_post_preview {
+    height: auto;
+    max-height: 10;
+    overflow: auto;
+    margin-bottom: 1;
+}
+
+#reply_content {
+    height: 10;
+}
+
+#reply_options {
+    height: auto;
+}
+
+#reply_language_container {
+    height: auto;
+}
+
+.reply_option_label {
+    width: auto;
+    height: 100%;
+    content-align: left middle;
+}
+
+#cw_input {
+    width: 1fr;
+}
+
+#language_select {
+    width: 1fr;
+}
+
+#reply_buttons {
+    width: 100%;
+    align-horizontal: right;
+    height: auto;
+}
+
+#reply_buttons > Button {
+    margin-left: 1;
+}
+#thread-dialog {
+    width: 80%;
+    height: 80%;
+    background: $surface;
+    border: thick $primary 80%;
+    padding: 1;
+}
+
+#thread-container {
+    padding: 1;
+}
+
+.main-post {
+    border: round $accent;
+}
+
+.reply-post {
+    margin-left: 4;
+}
+

mastui/app.py

@@ -0,0 +1,275 @@
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer
+from textual import on
+from mastui.login import LoginScreen
+from mastui.post import PostScreen
+from mastui.reply import ReplyScreen
+from mastui.splash import SplashScreen
+from mastui.mastodon_api import get_api
+from mastui.timeline import Timelines, Timeline
+from mastui.widgets import Post, LikePost, BoostPost
+from mastui.thread import ThreadScreen
+from mastui.profile import ProfileScreen
+from mastui.logging_config import setup_logging
+import logging
+import argparse
+import os
+from mastui.config import config
+from mastui.messages import (
+    PostStatusUpdate,
+    ActionFailed,
+    TimelineData,
+    FocusNextTimeline,
+    FocusPreviousTimeline,
+    ViewProfile,
+)
+
+# Set up logging
+log = logging.getLogger(__name__)
+
+
+# Get the absolute path to the CSS file
+css_path = os.path.join(os.path.dirname(__file__), "app.css")
+
+
+class Mastui(App):
+    """A Textual app to interact with Mastodon."""
+
+    BINDINGS = [
+        ("d", "toggle_dark", "Toggle dark mode"),
+        ("r", "refresh_timelines", "Refresh timelines"),
+        ("c", "compose_post", "Compose post"),
+        ("p", "view_profile", "View profile"),
+        ("a", "reply_to_post", "Reply to post"),
+        ("l", "like_post", "Like post"),
+        ("b", "boost_post", "Boost post"),
+        ("up", "scroll_up", "Scroll up"),
+        ("down", "scroll_down", "Scroll down"),
+    ]
+    CSS_PATH = css_path
+    initial_data = None
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        yield Header()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Called when the app is mounted."""
+        self.dark = config.theme == "dark"
+        self.push_screen(SplashScreen())
+        self.api = get_api()
+        if self.api:
+            self.load_initial_data()
+        else:
+            self.call_later(self.show_login_screen)
+
+    def show_login_screen(self):
+        if isinstance(self.screen, SplashScreen):
+            self.pop_screen()
+        self.push_screen(LoginScreen(), self.on_login)
+
+    def load_initial_data(self):
+        """Starts the worker to load initial data."""
+        self.run_worker(self.do_load_initial_data, exclusive=True, thread=True)
+
+    def do_load_initial_data(self):
+        """Worker to load initial data from the Mastodon API."""
+        log.info("Starting initial data load...")
+        def update_status(message):
+            if isinstance(self.screen, SplashScreen):
+                self.call_from_thread(self.screen.update_status, message)
+
+        try:
+            update_status("Fetching home timeline...")
+            home_timeline = self.api.timeline_home()
+            log.info(f"Fetched {len(home_timeline)} posts for home timeline.")
+
+            update_status("Fetching notifications...")
+            notifications = self.api.notifications()
+            log.info(f"Fetched {len(notifications)} notifications.")
+
+            update_status("Fetching federated timeline...")
+            federated_timeline = self.api.timeline_public()
+            log.info(f"Fetched {len(federated_timeline)} posts for federated timeline.")
+
+            self.initial_data = {
+                "home": home_timeline,
+                "notifications": notifications,
+                "federated": federated_timeline,
+            }
+            log.info("Initial data load complete.")
+            self.call_from_thread(self.show_timelines)
+        except Exception as e:
+            log.error(f"Error loading initial data: {e}", exc_info=True)
+            self.notify(f"Error loading initial data: {e}", severity="error")
+            self.call_from_thread(self.show_login_screen)
+
+    def on_login(self, api) -> None:
+        """Called when the login screen is dismissed."""
+        log.info("Login successful.")
+        self.api = api
+        self.push_screen(SplashScreen())
+        self.load_initial_data()
+
+    def show_timelines(self):
+        if isinstance(self.screen, SplashScreen):
+            self.pop_screen()
+        log.info("Showing timelines...")
+        self.mount(Timelines(initial_data=self.initial_data))
+        try:
+            self.query_one("#home", Timeline).focus()
+        except Exception:
+            pass
+
+    def watch_dark(self, dark: bool) -> None:
+        """Called when dark mode is toggled."""
+        config.theme = "dark" if dark else "light"
+        config.save_config()
+
+    def action_refresh_timelines(self) -> None:
+        """An action to refresh the timelines."""
+        log.info("Refreshing all timelines...")
+        for timeline in self.query(Timeline):
+            timeline.refresh_posts()
+
+    def action_compose_post(self) -> None:
+        """An action to compose a new post."""
+        self.push_screen(PostScreen(), self.on_post_screen_dismiss)
+
+    def action_reply_to_post(self) -> None:
+        focused = self.query("Timeline:focus")
+        if focused:
+            focused.first().reply_to_post()
+
+    def on_post_screen_dismiss(self, result: dict) -> None:
+        """Called when the post screen is dismissed."""
+        if result:
+            try:
+                log.info("Sending post...")
+                self.api.status_post(
+                    status=result["content"],
+                    spoiler_text=result["spoiler_text"],
+                    language=result["language"],
+                )
+                log.info("Post sent successfully.")
+                self.notify("Post sent successfully!", severity="information")
+                self.action_refresh_timelines()
+            except Exception as e:
+                log.error(f"Error sending post: {e}", exc_info=True)
+                self.notify(f"Error sending post: {e}", severity="error")
+
+    def on_reply_screen_dismiss(self, result: dict) -> None:
+        """Called when the reply screen is dismissed."""
+        if result:
+            try:
+                log.info(f"Sending reply to post {result['in_reply_to_id']}...")
+                self.api.status_post(
+                    status=result["content"],
+                    spoiler_text=result["spoiler_text"],
+                    language=result["language"],
+                    in_reply_to_id=result["in_reply_to_id"],
+                )
+                log.info("Reply sent successfully.")
+                self.notify("Reply sent successfully!", severity="information")
+                self.action_refresh_timelines()
+            except Exception as e:
+                log.error(f"Error sending reply: {e}", exc_info=True)
+                self.notify(f"Error sending reply: {e}", severity="error")
+
+    @on(LikePost)
+    def handle_like_post(self, message: LikePost):
+        self.run_worker(lambda: self.do_like_post(message.post_id), exclusive=True, thread=True)
+
+    def do_like_post(self, post_id: str):
+        try:
+            post_data = self.api.status_favourite(post_id)
+            self.post_message(PostStatusUpdate(post_data))
+        except Exception as e:
+            log.error(f"Error liking post {post_id}: {e}", exc_info=True)
+            self.post_message(ActionFailed(post_id))
+
+    @on(BoostPost)
+    def handle_boost_post(self, message: BoostPost):
+        self.run_worker(lambda: self.do_boost_post(message.post_id), exclusive=True, thread=True)
+
+    def do_boost_post(self, post_id: str):
+        try:
+            post_data = self.api.status_reblog(post_id)
+            self.post_message(PostStatusUpdate(post_data))
+        except Exception as e:
+            log.error(f"Error boosting post {post_id}: {e}", exc_info=True)
+            self.post_message(ActionFailed(post_id))
+
+    def on_post_status_update(self, message: PostStatusUpdate) -> None:
+        updated_post_data = message.post_data
+        target_post = updated_post_data.get("reblog") or updated_post_data
+        target_id = target_post["id"]
+
+        for container in [self.screen, *self.query(Timelines)]:
+            for post_widget in container.query(Post):
+                original_status = post_widget.post.get("reblog") or post_widget.post
+                if original_status["id"] == target_id:
+                    post_widget.update_from_post(updated_post_data)
+
+    def on_action_failed(self, message: ActionFailed) -> None:
+        for container in [self.screen, *self.query(Timelines)]:
+            for post_widget in container.query(Post):
+                original_status = post_widget.post.get("reblog") or post_widget.post
+                if original_status["id"] == message.post_id:
+                    post_widget.hide_spinner()
+
+    @on(FocusNextTimeline)
+    def on_focus_next_timeline(self, message: FocusNextTimeline) -> None:
+        timelines = self.query(Timeline)
+        for i, timeline in enumerate(timelines):
+            if timeline.has_focus:
+                timelines[(i + 1) % len(timelines)].focus()
+                return
+
+    @on(FocusPreviousTimeline)
+    def on_focus_previous_timeline(self, message: FocusPreviousTimeline) -> None:
+        timelines = self.query(Timeline)
+        for i, timeline in enumerate(timelines):
+            if timeline.has_focus:
+                timelines[(i - 1) % len(timelines)].focus()
+                return
+
+    @on(ViewProfile)
+    def on_view_profile(self, message: ViewProfile) -> None:
+        self.push_screen(ProfileScreen(message.account_id, self.api))
+
+    def action_like_post(self) -> None:
+        focused = self.query("Timeline:focus")
+        if focused:
+            focused.first().like_post()
+
+    def action_boost_post(self) -> None:
+        focused = self.query("Timeline:focus")
+        if focused:
+            focused.first().boost_post()
+
+    def action_scroll_up(self) -> None:
+        focused = self.query("Timeline:focus")
+        if focused:
+            focused.first().scroll_up()
+
+    def action_scroll_down(self) -> None:
+        focused = self.query("Timeline:focus")
+        if focused:
+            focused.first().scroll_down()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="A Textual app to interact with Mastodon.")
+    parser.add_argument("--no-ssl-verify", action="store_false", dest="ssl_verify", help="Disable SSL verification.")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+    args = parser.parse_args()
+    setup_logging(debug=args.debug)
+    config.ssl_verify = args.ssl_verify
+    app = Mastui()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

mastui/config.py

@@ -0,0 +1,35 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    def __init__(self):
+        self.mastodon_host = os.getenv("MASTODON_HOST")
+        self.mastodon_client_id = os.getenv("MASTODON_CLIENT_ID")
+        self.mastodon_client_secret = os.getenv("MASTODON_CLIENT_SECRET")
+        self.mastodon_access_token = os.getenv("MASTODON_ACCESS_TOKEN")
+        self.ssl_verify = True
+        self.theme = os.getenv("THEME", "dark")
+
+    def save_config(self):
+        with open(".env", "w") as f:
+            if self.mastodon_host:
+                f.write(f"MASTODON_HOST={self.mastodon_host}\n")
+            if self.mastodon_client_id:
+                f.write(f"MASTODON_CLIENT_ID={self.mastodon_client_id}\n")
+            if self.mastodon_client_secret:
+                f.write(f"MASTODON_CLIENT_SECRET={self.mastodon_client_secret}\n")
+            if self.mastodon_access_token:
+                f.write(f"MASTODON_ACCESS_TOKEN={self.mastodon_access_token}\n")
+            if self.theme:
+                f.write(f"THEME={self.theme}\n")
+
+    def save_credentials(self, host, client_id, client_secret, access_token):
+        self.mastodon_host = host
+        self.mastodon_client_id = client_id
+        self.mastodon_client_secret = client_secret
+        self.mastodon_access_token = access_token
+        self.save_config()
+
+config = Config()

mastui/logging_config.py

@@ -0,0 +1,13 @@
+import logging
+import os
+
+def setup_logging(debug=False):
+    """Set up logging to a file."""
+    log_file = os.path.join(os.path.dirname(os.path.dirname(__file__)), "mastui.log")
+    level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        filename=log_file,
+        filemode="w",  # Overwrite the log file on each run
+    )

mastui/login.py

@@ -0,0 +1,76 @@
+import pyperclip
+from textual.app import App, ComposeResult
+from textual.containers import Grid, Vertical
+from textual.widgets import Button, Label, Input, Static, TextArea
+from textual.screen import ModalScreen
+
+from mastui.mastodon_api import login, create_app
+
+class LoginScreen(ModalScreen):
+    """Screen for user to login."""
+
+    def compose(self) -> ComposeResult:
+        with Grid(id="dialog"):
+            yield Label("Mastodon Instance:")
+            yield Input(placeholder="mastodon.social", id="host")
+            
+            yield Static() # Spacer
+            yield Button("Get Auth Link", variant="primary", id="get_auth")
+
+            yield Static(id="status", classes="hidden")
+
+            with Vertical(id="auth_link_container", classes="hidden"):
+                yield Static("1. Link copied to clipboard! Open it in your browser to authorize.")
+                yield TextArea("", id="auth_link",)
+                yield Static("2. Paste the authorization code here:")
+                yield Input(placeholder="Authorization Code", id="auth_code")
+                yield Button("Login", variant="primary", id="login")
+
+
+    def on_mount(self) -> None:
+        """Called when the screen is mounted."""
+        self.query_one("#host").focus()
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        status = self.query_one("#status")
+        if event.button.id == "get_auth":
+            host = self.query_one("#host").value
+            if not host:
+                status.update("[red]Please enter a Mastodon instance.[/red]")
+                status.remove_class("hidden")
+                return
+
+            status.update("Generating authorization link...")
+            status.remove_class("hidden")
+            auth_url, error = create_app(host)
+            if error:
+                status.update(f"[red]Error: {error}[/red]")
+                return
+            
+            pyperclip.set_clipboard("xclip")
+            pyperclip.copy(auth_url)
+
+            auth_link_input = self.query_one("#auth_link")
+            auth_link_input.text = auth_url
+            auth_link_input.read_only = True
+            self.query_one("#auth_link_container").remove_class("hidden")
+            self.query_one("#get_auth").parent.add_class("hidden") # Hide the button's parent container
+            self.query_one("#host").disabled = True
+            self.query_one("#auth_code").focus()
+            status.add_class("hidden")
+
+        elif event.button.id == "login":
+            auth_code = self.query_one("#auth_code").value
+            host = self.query_one("#host").value
+            if not auth_code:
+                status.update("[red]Please enter the authorization code.[/red]")
+                status.remove_class("hidden")
+                return
+
+            status.update("Logging in...")
+            status.remove_class("hidden")
+            api, error = login(host, auth_code)
+            if api:
+                self.dismiss(api)
+            else:
+                status.update(f"[red]Login failed: {error}[/red]")