textchat 0.0.1__tar.gz

textchat-0.0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: textchat
+Version: 0.0.1
+Author-email: Matthew Blau <mrb1105@gmail.com>
+Requires-Python: >=3.8
+Requires-Dist: textual>=0.66.0
+Requires-Dist: irc>=20.4.0
+Requires-Dist: textual-autocomplete>=2.1.0b0
+Requires-Dist: SQLAlchemy>=2.0.30
+Requires-Dist: aiosqlite>=0.20.0

textchat-0.0.1/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "textchat"
+version = "0.0.1"
+authors = [
+    { name = "Matthew Blau", email = "mrb1105@gmail.com" },
+]
+dependencies = ["textual >=0.66.0", "irc >=20.4.0", "textual-autocomplete >=2.1.0b0","SQLAlchemy >=2.0.30", "aiosqlite >=0.20.0"]
+requires-python = ">=3.8"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+textchat = "textchat.chat:ircchat"

textchat-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

textchat-0.0.1/src/textchat/chat/client.py

@@ -0,0 +1,145 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import sys
+import threading
+from textual import work
+from textual.widgets import Label, TabbedContent, TabPane
+from irc.client import SimpleIRCClient
+from datetime import datetime
+import time
+import ib3.auth
+import ib3.connection
+import irc.bot
+from ..utils.channels import load_channels
+from ..db.db import add_channel_to_list
+
+#channels = load_channels()
+
+  
+
+class IRCApp(SimpleIRCClient):
+    def __init__(self,app, server_list, nickname, realname, ident_password, channels=load_channels()):
+        super().__init__()
+        self.app = app
+        self.server_list = server_list
+        self.server_name = server_list[0][0]
+        self.server_port = server_list[0][1]
+        self.nickname = nickname
+        self.realname= realname
+        self.ident_password = ident_password
+        self.channels = channels
+        self._thread_pool = ThreadPoolExecutor(max_workers=1)
+
+    def start_event_loop(self):
+        print("connecting..")
+        self._thread_pool.submit(self._irc_event_loop)
+        print("actually connecting")
+
+    def _irc_event_loop(self):
+        self.start() 
+        print("really connecting!!!!")
+    def stop(self):
+        self._thread_pool.shutdown(wait=False)
+
+    
+    def start(self):
+        self.connect(
+                    self.server_name,
+                    self.server_port,
+                    self.nickname,
+                    self.ident_password,
+                    self.realname,
+                   )
+        super().start()
+    
+    def on_welcome(self, connection, event):
+        #self.connection.privmsg("nickserv", f'identify {self.password}')
+        for channel in self.channels:
+            connection.join(channel)
+            #await add_channel_to_list(channel)
+        time.sleep(7)
+        self.app.notify("Connected!")
+
+    
+    async def _intercept_join(self, message):
+        self.tab = self.app.query_one(TabbedContent).active_pane 
+        if message.startswith("/join"):
+            channel = message.split()[1]
+            if not channel in self.channels:
+                self.connection.join(channel) 
+                self.channels.append(channel)
+                await add_channel_to_list(channel)
+                self.app.query_one(TabbedContent).add_pane(TabPane(channel,
+                                                        Label(),
+                                                       name=channel, 
+                                                       id=f'{channel.replace("#", "").lower()}'))
+            else:
+                self.app.notify(f"Already in {channel}!")
+            return True
+        return False 
+    
+    def _intercept_part(self, message):
+        self.tab = self.app.query_one(TabbedContent).active_pane 
+        if message.startswith("/part"):
+            channel = message.split()[1]
+            self.connection.part(channel) 
+            self.channels.remove(channel)
+            self.app.query_one(TabbedContent).remove_pane(f'{channel.replace("#", "").lower()}')
+            return True
+        return False 
+    
+    def on_pubmsg(self, connection, event):
+        print(event)
+        sender = event.source.nick
+        message = event.arguments[0]
+        channel = event.target
+        now = datetime.now()
+        if now.minute <= 9:
+            self.app.handle_irc_message(f'{now.hour}:0{now.minute}', channel,  sender, message, classes=None)
+        else:
+            self.app.handle_irc_message(f'{now.hour}:{now.minute}', channel,  f'{sender}', message, classes=None)
+
+    def on_privmsg(self, connection, event):
+        message = event.arguments[0]
+        user = event.source.nick
+        now = datetime.now()
+        if now.minute <= 9:
+            self.app.handle_private_message(f'{now.hour}:0{now.minute}',  user, message, classes=None)
+        else:
+            self.app.handle_private_message(f'{now.hour}:{now.minute}', user, message, classes=None)
+
+    def on_ctcp(self, connection, event):
+        sender = event.source.nick
+        message = event.arguments[1]
+        channel = event.target
+        now = datetime.now()
+        classes = "italics"
+        if now.minute  <= 9:
+
+            self.app.handle_irc_message(f'{now.hour}:0{now.minute}', channel,  f'{sender}', message, classes)
+        else:
+            self.app.handle_irc_message(f'{now.hour}:{now.minute}', channel,  f'{sender}', message, classes)
+
+    def on_namreply(self, connection, event):
+        channel = event.arguments[1]
+        user_list = event.arguments[2].split()
+        self.app.add_to_tree(channel, user_list)
+
+    def on_join(self, connection, event):
+        sender = event.source.nick
+        try:
+            message = event.arguments[0]
+        except IndexError:
+            message = "has joined"
+        channel = event.target
+        now = datetime.now()
+        classes = "italics"
+        if now.minute  <= 9 and self.nickname != sender:
+            self.app.handle_irc_message(f'{now.hour}:0{now.minute}', channel,  f'{sender}', message, classes)
+        elif self.nickname != sender:
+            self.app.handle_irc_message(f'{now.hour}:{now.minute}', channel,  f'{sender}', message, classes)
+    
+    def on_disconnect(self):
+        self._stop_event.set()
+
+

textchat-0.0.1/src/textchat/chat/ircchat.py

@@ -0,0 +1,170 @@
+from datetime import datetime
+from pathlib import Path
+import time
+try:
+     from .screens.quit import QuitScreen
+except:
+     from textchat.chat.screens.quit import QuitScreen
+try:
+    from .screens.settings import SettingsScreen
+except:
+     from textchat.chat.screens.settings import SettingsScreen
+from textchat.db.db import get_password, get_port, get_server_address, get_username
+from textual import work
+from textual import on
+from textual.app import App
+from textual.command import Command
+from textual.widgets import Input, Label, TabbedContent, TabPane,Tree
+from textual.worker import get_current_worker
+try:
+    from .client import IRCApp
+except:
+    from textchat.chat.client import IRCApp
+try:
+    from .screens.irc import IRCScreen
+except:
+    from textchat.chat.screens.irc import IRCScreen
+try: 
+     from .screens.settings import SettingsScreen
+except:
+     from textchat.chat.screens.settings import SettingsScreen
+try:
+    from ..db.base import create_table
+except:
+     from textchat.db.base import create_table
+
+try:
+    from ..utils.channels import load_channels
+except:
+     from textchat.utils.channels import load_channels
+
+
+class TextChat(App):
+    def __init__(self):
+        super().__init__()
+    CSS_PATH = 'irc.tcss'
+    SCREENS = {"irc": IRCScreen(), "settings":SettingsScreen() }
+    BINDINGS = [("ctrl+h", "return_home", "Home"),
+                ("ctrl+s", "open_settings", "Settings"),
+                ("ctrl+q", "request_quit", "Quit"), 
+                ("ctrl+d", "toggle_dark", "Toggle dark mode")
+                ]
+ 
+
+
+    async def on_mount(self) -> None:
+        self.channel_list = None
+        self.users = set()
+        self.username = await get_username()
+        self.port = await get_port()
+        self.server_address = await get_server_address()
+        self.password = await get_password()
+        await create_table()
+
+        existing_channels = await load_channels()
+        if not existing_channels:
+             self.app.push_screen(self.SCREENS['settings'])
+        else:
+            self.app.push_screen(self.SCREENS['irc'])
+            self.irc_client = IRCApp(self,
+                                 server_list=[(self.server_address, self.port)],
+                                 nickname=self.username,
+                                 realname=self.username,
+                                 ident_password=self.password,
+                                 channels=existing_channels,
+                                 )
+            self.irc_client.start_event_loop()
+
+             
+    
+    def action_toggle_dark(self) -> None:
+        """An action to toggle dark mode."""
+        self.dark = not self.dark
+
+    def action_request_quit(self) -> None:
+
+        def check_quit(quit: bool) -> None:
+            if quit:
+                self.app.exit()
+                self.irc_client.stop()
+                
+        self.push_screen(QuitScreen(), check_quit) 
+    
+    def action_open_settings(self) -> None:
+        self.push_screen(SettingsScreen()) 
+
+    def action_return_home(self) -> None:
+         self.push_screen(self.SCREENS['irc'])
+          
+    @on(Input.Submitted) 
+    async def send_message(self, event) -> None:
+        self.query_one(Input).value = "" 
+        self.tab = self.query_one(TabbedContent).active_pane
+        now = datetime.now()
+        if now.minute <= 9 and not await self.irc_client._intercept_join(event.value):
+                self.irc_client.connection.privmsg(self.tab.name, event.value)
+                self.tab.mount(Label(f'{now.hour}:0{now.minute} <{self.irc_client.nickname}> {event.value}'))
+        elif not await self.irc_client._intercept_join(event.value):
+            self.irc_client.connection.privmsg(self.tab.name, event.value)
+            self.tab.mount(Label(f'{now.hour}:{now.minute} <{self.irc_client.nickname}> {event.value}'))
+
+    def get_channel_list(self):
+        if self.app.channel_list is None:
+            return None
+        else:
+            return self.app.channel_list    
+         
+    def irc_message(self, time, channel, sender, message,classes):
+        self.tab = self.app.query_one(TabbedContent).get_pane(channel.replace("#", "").lower())
+        if self.irc_client.nickname in message:
+            self.app.notify(f"{time} <{sender}> {message}", title=channel)
+            self.tab.mount(Label(f"{time} <{sender}> {message}", classes="highlight"))
+        else:
+            self.tab.mount(Label(f'{time} <{sender}> {message}', classes=classes))
+
+
+    def received_private_message(self, time, sender, message, classes):
+        self.tab = self.app.query_one(TabbedContent).add_pane(TabPane(sender,
+                                                        Label(),
+                                                       name=sender, 
+                                                       id=f'{sender}'))
+        self.tab = self.app.query_one(TabbedContent).get_pane(f'{sender}')
+        self.tab.mount(Label(f'{time} <{sender}> {message}', classes=classes))
+
+
+    def add_to_tree(self, channel, user_list):
+        tree = self.app.query_one(Tree)
+        self.app.channel_list = self.app.get_channel_list()
+        if self.app.channel_list is not None and channel != self.app.channel_list.data:
+                channels_list = tree.root.add(channel, data=channel)
+                self.app.channel_list = channels_list
+        elif self.channel_list is None:
+                channels_list = tree.root.add(channel, data=channel)
+                self.app.channel_list = channels_list
+        for user in user_list:
+                self.app.channel_list.add_leaf(user)
+        for user in user_list:
+             self.app.users.add(user)
+        else:
+            pass
+        
+    @work(exclusive=True)
+    async def handle_irc_message(self, time, channel, sender, message, classes):
+        worker = get_current_worker()
+        if not worker.is_cancelled:
+            self.irc_message(time, channel, sender, message, classes) 
+        else:
+            pass
+    
+    @work(exclusive=True)
+    async def handle_private_message(self, time, sender, message, classes):
+        worker = get_current_worker()
+        if not worker.is_cancelled:
+            self.received_private_message(time, sender, message, classes) 
+        else:
+            pass
+    async def on_shutdown(self):
+        self.irc_client.on_disconnect() 
+
+app = TextChat()
+app.run()

textchat-0.0.1/src/textchat/chat/screens/irc.py

@@ -0,0 +1,39 @@
+import asyncio
+from textchat.utils.channels import load_channels
+from textual.app import ComposeResult
+from textual.widgets import Input, Tree, Footer, TabbedContent, TabPane, Label
+from textual.screen import Screen
+from textual_autocomplete import DropdownItem, InputState
+
+
+class IRCScreen(Screen):
+    try:
+        channels = asyncio.run(load_channels())
+    except:
+        channels = False
+    def compose(self) -> ComposeResult:
+        def get_items(input_state: InputState):
+            items = []
+            for user in self.app.users:
+                items.append(
+                    DropdownItem(user.replace("+", "").replace("@", ""))
+                )
+            matches = [c for c in items if input_state.value.lower() in c.main.plain.lower()]
+            ordered = sorted(matches, key=lambda v: input_state.value.lower() in v.main.plain.lower(), reverse=True)
+            return ordered
+
+
+        with TabbedContent() as self.tabbed_content:
+            if not self.channels:
+                with TabPane("uh oh!"):
+                    yield(Label("Please visit the settings tab and restart when finished to see your channels here!"))
+            else:
+                for name in self.channels:
+                    tab_id = f'{name.replace("#", "")}'
+                    with TabPane(name, name=name, id=tab_id.lower()):
+                        yield(Label())
+        tree: Tree[dict] = Tree("Channels", id="sidebar")
+        yield tree
+        yield Input(id="chat-input")
+        #yield AutoComplete(Input(placeholder=f"Enter your message", id="chat-input"), Dropdown(items=get_items))
+        yield Footer()

textchat-0.0.1/src/textchat/chat/screens/quit.py

@@ -0,0 +1,22 @@
+from textual.app import ComposeResult
+from textual.containers import Grid
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label
+
+class QuitScreen(ModalScreen[bool]):  
+    """Screen with a dialog to quit."""
+
+    def compose(self) -> ComposeResult:
+        yield Grid(
+            Label("Are you sure you want to quit?", id="question"),
+            Button("Quit", variant="error", id="quit"),
+            Button("Cancel", variant="primary", id="cancel"),
+            id="dialog",
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "quit":
+            self.dismiss(True)
+            
+        else:
+            self.dismiss(False)

textchat-0.0.1/src/textchat/chat/screens/settings.py

@@ -0,0 +1,52 @@
+from textchat.chat.client import IRCApp
+from textchat.db.base import create_table
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Input, Footer, Button
+from textual.containers import Vertical
+from ..widgets.address import ServerAddress, ServerPort
+from ..widgets.nickname import Nickname
+from ..widgets.channels import Channels
+from ..widgets.password import Password
+from ...db.db import add_channel_to_list, add_server_info
+from ...utils.channels import load_channels
+
+class SettingsScreen(Screen):
+ 
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            ServerAddress(placeholder="Server address"),
+            ServerPort(placeholder="port", type="integer"),
+            Nickname(placeholder="nickname"),
+            Channels(placeholder="channels to join (seperate by comma)"),
+            Password(placeholder="password", password=True),
+            Button(label="Save", id="save"),
+            classes="column"
+        )
+        yield Footer()
+    async def on_mount(self):
+        await create_table()
+
+    
+    async def on_button_pressed(self, event: Button.Pressed):
+        if event.button.id =="save":
+            server_address = self.query_one(ServerAddress).value
+            server_port = self.query_one(ServerPort).value
+            nickname = self.query_one(Nickname).value
+            channels = self.query_one(Channels).value
+            password = self.query_one(Password).value
+            await add_server_info(server_address, server_port, nickname, password)
+            existing_channnels = await load_channels()
+            for channel in channels.split(","):
+             if channel not in existing_channnels:
+                await add_channel_to_list(channel)
+             else:
+                pass
+            self.irc_client = IRCApp(self,
+                                 server_list=[(server_address, server_port)],
+                                 nickname=nickname,
+                                 realname=nickname,
+                                 ident_password=password,
+                                 channels=channels,
+                                 )
+            self.irc_client.start_event_loop()

textchat-0.0.1/src/textchat/chat/widgets/address.py

@@ -0,0 +1,7 @@
+from textual.widgets import Input
+
+class ServerAddress(Input):
+    pass
+
+class ServerPort(Input):
+    pass

textchat-0.0.1/src/textchat/chat/widgets/channels.py

@@ -0,0 +1,4 @@
+from textual.widgets import Input
+
+class Channels(Input):
+    pass

textchat-0.0.1/src/textchat/chat/widgets/nickname.py

@@ -0,0 +1,4 @@
+from textual.widgets import Input
+
+class Nickname(Input):
+    pass

textchat-0.0.1/src/textchat/chat/widgets/password.py

@@ -0,0 +1,4 @@
+from textual.widgets import Input
+
+class Password(Input):
+    pass

textchat-0.0.1/src/textchat/db/base.py

@@ -0,0 +1,47 @@
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.ext.asyncio import async_sessionmaker
+from sqlalchemy.sql.schema import MetaData
+import asyncio
+engine = create_async_engine(
+    "sqlite+aiosqlite:///textchat.db", echo=False,)
+Session = async_sessionmaker(
+    bind=engine, expire_on_commit=False)
+metadata = MetaData()
+from sqlalchemy.orm import DeclarativeBase
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Channels(Base):
+    __tablename__ = 'channels'
+
+    id = Column(Integer, primary_key=True,
+                autoincrement=True)
+    channel_name = Column(String, unique=True)
+
+
+    def __init__(self, channel_name):
+        self.channel_name = channel_name
+
+class ServerInfo(Base):
+    __tablename__ = 'server'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    server_address = Column(String, unique=True)
+    port = Column(Integer, unique=False)
+    nickname = Column(String, unique=False)
+    password = Column(String, unique=False)
+
+    def __init__(self, server_address, port, nickname, password):
+        self.server_address = server_address
+        self.port = port
+        self.nickname = nickname
+        self.password = password
+
+
+async def create_table():
+    async with engine.begin() as conn:
+       await conn.run_sync(Base.metadata.create_all)
+

textchat-0.0.1/src/textchat/db/db.py

@@ -0,0 +1,47 @@
+from sqlalchemy import select
+from .base import Session, Channels, ServerInfo
+
+async def get_channels():
+    async with Session() as session:
+        channels = await session.execute(select(Channels))
+        await session.commit()
+        channel_names = channels.scalars().all()
+        return channel_names
+    
+async def add_channel_to_list(channel):
+    async with Session() as session:
+        channel_name = Channels(channel_name=channel)
+        session.add(channel_name)
+        await session.commit()
+    return channel_name
+
+async def add_server_info(server_address, port, nickname, password):
+    async with Session() as session:
+        server_info = ServerInfo(server_address, port, nickname, password)
+        session.add(server_info)
+        await session.commit()
+    return server_info
+
+async def get_username():
+    async with Session() as session:
+        username = await session.execute(select(ServerInfo.nickname))
+        await session.commit()
+        return username.scalars().first()
+    
+async def get_password():
+    async with Session() as session:
+        password = await session.execute(select(ServerInfo.password))
+        await session.commit()
+        return password.scalars().first()
+    
+async def get_port():
+    async with Session() as session:
+        port = await session.execute(select(ServerInfo.port))
+        await session.commit()
+        return port.scalars().first()
+
+async def get_server_address():
+    async with Session() as session:
+        server_address = await session.execute(select(ServerInfo.server_address))
+        await session.commit()
+        return server_address.scalars().first()

textchat-0.0.1/src/textchat/db/model.py

@@ -0,0 +1 @@
+

textchat-0.0.1/src/textchat/utils/channels.py

@@ -0,0 +1,5 @@
+from ..db.db import get_channels
+async def load_channels():
+    channels = await get_channels()
+
+    return [name.channel_name for name in channels]

textchat-0.0.1/src/textchat.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: textchat
+Version: 0.0.1
+Author-email: Matthew Blau <mrb1105@gmail.com>
+Requires-Python: >=3.8
+Requires-Dist: textual>=0.66.0
+Requires-Dist: irc>=20.4.0
+Requires-Dist: textual-autocomplete>=2.1.0b0
+Requires-Dist: SQLAlchemy>=2.0.30
+Requires-Dist: aiosqlite>=0.20.0

textchat-0.0.1/src/textchat.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+pyproject.toml
+src/__init__.py
+src/textchat.egg-info/PKG-INFO
+src/textchat.egg-info/SOURCES.txt
+src/textchat.egg-info/dependency_links.txt
+src/textchat.egg-info/entry_points.txt
+src/textchat.egg-info/requires.txt
+src/textchat.egg-info/top_level.txt
+src/textchat/chat/__init__.py
+src/textchat/chat/client.py
+src/textchat/chat/ircchat.py
+src/textchat/chat/commands/__init__.py
+src/textchat/chat/screens/__init__.py
+src/textchat/chat/screens/irc.py
+src/textchat/chat/screens/quit.py
+src/textchat/chat/screens/settings.py
+src/textchat/chat/widgets/__init__.py
+src/textchat/chat/widgets/address.py
+src/textchat/chat/widgets/channels.py
+src/textchat/chat/widgets/nickname.py
+src/textchat/chat/widgets/password.py
+src/textchat/db/base.py
+src/textchat/db/db.py
+src/textchat/db/model.py
+src/textchat/utils/channels.py

textchat-0.0.1/src/textchat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

textchat-0.0.1/src/textchat.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+textchat = textchat.chat:ircchat

textchat-0.0.1/src/textchat.egg-info/requires.txt

@@ -0,0 +1,5 @@
+textual>=0.66.0
+irc>=20.4.0
+textual-autocomplete>=2.1.0b0
+SQLAlchemy>=2.0.30
+aiosqlite>=0.20.0

textchat-0.0.1/src/textchat.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+textchat