tchat-client 0.12.0__tar.gz

tchat_client-0.12.0/.gitignore

@@ -0,0 +1,9 @@
+compile_commands.json
+__pycache__
+venv/
+~/.config/tchat/config.toml
+.gitignore
+.env
+dist/
+*.egg-info/
+ONBOARDING.md

tchat_client-0.12.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: tchat-client
+Version: 0.12.0
+Summary: tchat — client
+Requires-Python: >=3.11
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: typer>=0.24.1

tchat_client-0.12.0/install.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Script d'installation de tchat pour les users.
+# Usage: curl -sSL https://raw.githubusercontent.com/TheLeBerton/tchat-client/main/install.sh | bash
+
+set -e
+
+echo "=== Installation de tchat ==="
+
+# Vérifie python3
+if ! command -v python3 &>/dev/null; then
+    echo "Erreur : python3 non trouvé."
+    echo "Installe Python 3.11+ depuis https://www.python.org/downloads/"
+    exit 1
+fi
+
+# Vérifie version >= 3.11
+if ! python3 -c "import sys; exit(0 if sys.version_info >= (3, 11) else 1)" 2>/dev/null; then
+    version=$(python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
+    echo "Erreur : Python 3.11+ requis (tu as $version)."
+    echo "Mets à jour Python depuis https://www.python.org/downloads/"
+    exit 1
+fi
+
+# Assure que pip est disponible
+python3 -m ensurepip --upgrade 2>/dev/null || true
+
+# Installe / met à jour tchat-client
+echo "Installation de tchat-client..."
+python3 -m pip install --upgrade tchat-client --quiet
+
+# Trouve le binaire installé
+TCHAT_BIN=$(python3 -c "import sysconfig; print(sysconfig.get_path('scripts'))")/tchat
+USER_BIN=$(python3 -m site --user-base 2>/dev/null)/bin/tchat
+
+if command -v tchat &>/dev/null; then
+    echo ""
+    echo "Terminé ! Lance : tchat"
+elif [ -f "$TCHAT_BIN" ]; then
+    echo ""
+    echo "Terminé ! Lance : $TCHAT_BIN"
+    echo ""
+    echo "Astuce — pour utiliser juste 'tchat', ajoute cette ligne à ton ~/.zshrc ou ~/.bashrc :"
+    echo "  export PATH=\"$(dirname $TCHAT_BIN):\$PATH\""
+elif [ -f "$USER_BIN" ]; then
+    echo ""
+    echo "Terminé ! Lance : $USER_BIN"
+    echo ""
+    echo "Astuce — pour utiliser juste 'tchat', ajoute cette ligne à ton ~/.zshrc ou ~/.bashrc :"
+    echo "  export PATH=\"$(dirname $USER_BIN):\$PATH\""
+else
+    echo ""
+    echo "Terminé ! Lance : python3 -m tchat"
+fi

tchat_client-0.12.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tchat-client"
+version = "0.12.0"
+description = "tchat — client"
+requires-python = ">=3.11"
+dependencies = [
+    "typer>=0.24.1",
+    "prompt_toolkit>=3.0.52",
+]
+
+[project.scripts]
+tchat = "tchat.client.runner:run"
+
+[tool.hatch.build.targets.wheel]
+packages = ["tchat"]
+include = ["tchat/**/*.toml"]

tchat_client-0.12.0/tchat/client/connection.py

@@ -0,0 +1,43 @@
+import socket
+
+from tchat.config import config
+from tchat.message.message import Message
+from tchat.message.framing import send_framed, receive_framed
+
+
+class Connection:
+    """
+    TCP connection.
+    """
+
+    def __init__( self, host: str | None = None ) -> None:
+        self._host = host or config.client.ip
+        self._socket: socket.socket | None = None
+
+    def connect( self ) -> None:
+        """
+        Connect to server.
+        """
+        self._socket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
+        self._socket.connect( ( self._host, config.client.port ) )
+
+    def close( self ) -> None:
+        """
+        Close the connection.
+        """
+        if self._socket:
+            self._socket.close()
+
+    def send( self, msg: Message ) -> None:
+        """
+        Send a message.
+        """
+        assert self._socket is not None
+        send_framed( self._socket, msg.to_json() )
+
+    def receive( self ) -> str:
+        """
+        Receive a message.
+        """
+        assert self._socket is not None
+        return receive_framed( self._socket )

tchat_client-0.12.0/tchat/client/identity.py

@@ -0,0 +1,40 @@
+import re
+from pathlib import Path
+
+USERNAME_FILE = Path.home() / ".tchat_username"
+_USERNAME_PATTERN = re.compile( r"^[a-zA-Z0-9_]{2,20}$" )
+
+
+def _validate( name: str ) -> str | None:
+    """Returns an error message if invalid, None if valid."""
+    if len( name ) < 2:
+        return "Username must be at least 2 characters."
+    if len( name ) > 20:
+        return "Username must be at most 20 characters."
+    if not _USERNAME_PATTERN.match( name ):
+        return "Username can only contain letters, digits, and underscores."
+    return None
+
+
+def load_username() -> str | None:
+    if USERNAME_FILE.exists():
+        return USERNAME_FILE.read_text().strip()
+    return None
+
+def save_username( name: str ) -> None:
+    USERNAME_FILE.write_text( name )
+
+def prompt_username( saved: str | None = None ) -> str:
+    if saved:
+        print( f"Saved username: \033[1m{ saved }\033[0m — press Enter to use it, or type a new one." )
+    while True:
+        raw = input( "Username: " ).strip()
+        if raw == "" and saved:
+            return saved
+        name = raw or saved or ""
+        error = _validate( name )
+        if error:
+            print( f"\033[31m{ error }\033[0m" )
+            continue
+        save_username( name )
+        return name

tchat_client-0.12.0/tchat/client/receiver.py

@@ -0,0 +1,69 @@
+import os
+import signal
+import threading
+
+from prompt_toolkit.patch_stdout import patch_stdout
+
+from tchat import logger
+from tchat.message.message import Message
+from tchat.message.types import MessageType
+from tchat.client.connection import Connection
+from tchat.exceptions import MessageFramingError, InvalidMessageError
+
+
+class TypingTracker:
+    EXPIRY = 2.0
+
+    def __init__( self ) -> None:
+        self._typing: dict[ str, threading.Timer ] = {}
+        self._lock = threading.Lock()
+
+    def set_typing( self, username: str, state: str ) -> None:
+        with self._lock:
+            if username in self._typing:
+                self._typing[ username ].cancel()
+            if state == "start":
+                t = threading.Timer( self.EXPIRY, self._expire, args=[ username ] )
+                t.daemon = True
+                t.start()
+                self._typing[ username ] = t
+            else:
+                self._typing.pop( username, None )
+
+    def _expire( self, username: str ) -> None:
+        with self._lock:
+            self._typing.pop( username, None )
+
+    def get_typing_users( self ) -> list[ str ]:
+        with self._lock:
+            return list( self._typing.keys() )
+
+
+class ReceiveLoop:
+    def __init__( self, connection: Connection ) -> None:
+        self._connection = connection
+        self._connection_lost = False
+        self.typing_tracker = TypingTracker()
+
+    @property
+    def connection_lost( self ) -> bool:
+        return self._connection_lost
+
+    def start( self ) -> None:
+        thread = threading.Thread( target=self._loop, daemon=True )
+        thread.start()
+
+    def _loop( self ) -> None:
+        while True:
+            try:
+                raw = self._connection.receive()
+                msg = Message.from_json( raw )
+                if msg.type == MessageType.TYPING:
+                    self.typing_tracker.set_typing( msg.sender, msg.content )
+                else:
+                    logger.client.message( msg )
+            except ( MessageFramingError, InvalidMessageError ):
+                break
+        logger.client.warning( "\n[ Connection closed ]"  )
+        self._connection_lost = True
+        os.kill( os.getpid(), signal.SIGINT )

tchat_client-0.12.0/tchat/client/runner.py

@@ -0,0 +1,41 @@
+import time
+
+from tchat import logger
+from tchat.client.updater import check_and_update
+from tchat.config import config as _config
+from tchat.version import VERSION
+from tchat.message.message import Message
+from tchat.message.types import MessageType
+from tchat.client.connection import Connection
+from tchat.client.identity import load_username, prompt_username
+from tchat.client.receiver import ReceiveLoop
+from tchat.client.sender import InputLoop
+
+
+def run( host: str | None = None ) -> None:
+    check_and_update()
+    logger.client.banner()
+    username = prompt_username( load_username() )
+    while True:
+        conn = Connection( host=host )
+        try:
+            conn.connect()
+        except OSError:
+            logger.client.info( "Cannot connect. Retrying in 5s..." )
+            time.sleep( 5 )
+            continue
+        version_msg = Message.from_json( conn.receive() )
+        if version_msg.content != VERSION:
+            logger.client.info( f"Version mismatch — serveur: { version_msg.content }, client: { VERSION }. Telecharge la derniere version." )
+            conn.close()
+            return
+        conn.send( Message.make( MessageType.JOIN, username, "" ) )
+        receiver = ReceiveLoop( conn )
+        receiver.start()
+        should_reconnect = InputLoop( conn, username ).run( receiver )
+        conn.close()
+        if should_reconnect:
+            logger.client.info( "Connection lost. Reconnecting in 5s..." )
+            time.sleep( _config.client.reconnect_delay )
+            continue
+        return

tchat_client-0.12.0/tchat/client/sender.py

@@ -0,0 +1,121 @@
+import threading
+import time
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.patch_stdout import patch_stdout
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.completion import Completer, Completion
+
+from tchat.message.message import Message
+from tchat.message.types import MessageType
+from tchat.client.connection import Connection
+from tchat.client.receiver import ReceiveLoop
+
+
+COMMANDS = [ "/whoonline", "/status", "/help", "/quit" ]
+
+
+class CommandCompleter( Completer ):
+    def get_completions( self, document, complete_event ):
+        text = document.text_before_cursor
+        if not text.startswith( "/" ):
+            return
+        for cmd in COMMANDS:
+            if cmd.startswith( text ):
+                yield Completion( cmd, start_position=-len( text ) )
+
+
+class TypingNotifier:
+    THROTTLE = 2.5
+    IDLE_TIMEOUT = 4.0
+
+    def __init__( self, connection: Connection, username: str ) -> None:
+        self._connection = connection
+        self._username = username
+        self._last_sent = 0.0
+        self._is_typing = False
+        self._timer: threading.Timer | None = None
+        self._lock = threading.Lock()
+
+    def on_text_changed( self, _buffer ) -> None:
+        now = time.monotonic()
+        with self._lock:
+            if self._timer:
+                self._timer.cancel()
+            if now - self._last_sent >= self.THROTTLE:
+                self._send( "start" )
+                self._last_sent = now
+                self._is_typing = True
+            self._timer = threading.Timer( self.IDLE_TIMEOUT, self._send_stop )
+            self._timer.daemon = True
+            self._timer.start()
+
+    def on_message_sent( self ) -> None:
+        with self._lock:
+            if self._timer:
+                self._timer.cancel()
+                self._timer = None
+            if self._is_typing:
+                self._send( "stop" )
+                self._is_typing = False
+                self._last_sent = 0.0
+
+    def _send_stop( self ) -> None:
+        with self._lock:
+            if self._is_typing:
+                self._send( "stop" )
+                self._is_typing = False
+                self._last_sent = 0.0
+
+    def _send( self, state: str ) -> None:
+        try:
+            self._connection.send( Message.make( MessageType.TYPING, self._username, state ) )
+        except OSError:
+            pass
+
+
+class InputLoop:
+    def __init__( self, connection: Connection, username: str ) -> None:
+        self._connection = connection
+        self._username = username
+
+    def run( self, receiver: ReceiveLoop ) -> bool:
+        history_file = Path.home() / ".tchat_history"
+        notifier = TypingNotifier( self._connection, self._username )
+
+        def bottom_toolbar():
+            users = receiver.typing_tracker.get_typing_users()
+            if not users:
+                return ""
+            names = ", ".join( users )
+            return f" { names } is typing..."
+
+        session = PromptSession(
+            f"[{ self._username }] > ",
+            history=FileHistory( str( history_file ) ),
+            completer=CommandCompleter(),
+            complete_while_typing=True,
+            bottom_toolbar=bottom_toolbar,
+            refresh_interval=0.5,
+        )
+
+        def pre_run():
+            session.app.current_buffer.on_text_changed += notifier.on_text_changed
+
+        with patch_stdout( raw=True ):
+            while not receiver.connection_lost:
+                try:
+                    text = session.prompt( pre_run=pre_run )
+                except ( EOFError, KeyboardInterrupt ):
+                    if receiver.connection_lost:
+                        return True
+                    return False
+                notifier.on_message_sent()
+                if text == "/quit":
+                    return False
+                elif text.startswith( "/" ):
+                    self._connection.send( Message.make( MessageType.COMMAND, self._username, text[ 1: ] ) )
+                else:
+                    self._connection.send( Message.make( MessageType.CHAT, self._username, text ) )
+        return True

tchat_client-0.12.0/tchat/client/updater.py

@@ -0,0 +1,39 @@
+import json
+import os
+import subprocess
+import sys
+import urllib.request
+from importlib.metadata import PackageNotFoundError, version as pkg_version
+
+from tchat.version import VERSION
+
+_PYPI_URL = "https://pypi.org/pypi/tchat-client/json"
+
+
+def _fetch_remote_version() -> str | None:
+    try:
+        with urllib.request.urlopen( _PYPI_URL, timeout=3 ) as resp:
+            data = json.loads( resp.read() )
+            return data[ "info" ][ "version" ]
+    except Exception:
+        pass
+    return None
+
+
+def check_and_update() -> None:
+    try:
+        pkg_version( "tchat-client" )
+    except PackageNotFoundError:
+        return  # running from source (dev), skip
+
+    remote = _fetch_remote_version()
+    if remote is None or remote == VERSION.lstrip( "v" ):
+        return
+
+    print( f"Mise à jour disponible ({ VERSION } → v{ remote }). Installation..." )
+    subprocess.run(
+        [ sys.executable, "-m", "pip", "install", "--upgrade", "--quiet", "tchat-client" ],
+        check=True,
+    )
+    print( "Mise à jour terminée. Redémarrage..." )
+    os.execv( sys.executable, [ sys.executable ] + sys.argv )

tchat_client-0.12.0/tchat/config/__init__.py

@@ -0,0 +1 @@
+from .config import config

tchat_client-0.12.0/tchat/config/config.py

@@ -0,0 +1,82 @@
+import shutil
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+from tchat.exceptions import ConfigError
+
+
+_CONFIG_DIR = Path.home() / ".config" / "tchat"
+_CONFIG_PATH = _CONFIG_DIR / "config.toml"
+_TEMPLATE_PATH = Path( __file__ ).parent / "config.toml"
+
+
+@dataclass
+class ServerConfig:
+    ip: str
+    port: int
+    waiting_list_size: int
+
+
+@dataclass
+class ClientConfig:
+    ip: str
+    port: int
+    reconnect_delay: int
+
+@dataclass
+class LoggerConfig:
+    typewriter: bool
+    typewriter_delay: float
+    timestamp_format: str
+    log_to_file: bool
+    log_file: str
+
+@dataclass
+class ChatConfig:
+    max_message_length: int
+    history_size: int
+
+@dataclass
+class ColorsConfig:
+    join: str
+    leave: str
+    server: str
+    timestamp: str
+    error: str
+    info: str
+
+
+@dataclass
+class Config:
+    server: ServerConfig
+    client: ClientConfig
+    logger: LoggerConfig
+    chat: ChatConfig
+    colors: ColorsConfig
+
+
+def _ensure_config() -> None:
+    if not _CONFIG_PATH.exists():
+        _CONFIG_DIR.mkdir( parents=True, exist_ok=True )
+        shutil.copy( _TEMPLATE_PATH, _CONFIG_PATH )
+        print( f"Config created at { _CONFIG_PATH }" )
+        print( f"--> Edit it to set your server IP ( client.ip )." )
+
+
+def _load_config() -> Config:
+    _ensure_config()
+    try:
+        with open( _CONFIG_PATH, "rb" ) as f:
+            data = tomllib.load( f )
+    except OSError as e:
+        raise ConfigError( f"Cannot read config: { e }" ) from e
+    return Config(
+            server=ServerConfig( **data[ "server" ] ),
+            client=ClientConfig( **data[ "client" ] ),
+            logger=LoggerConfig( **data[ "logger" ] ),
+            chat=ChatConfig( **data[ "chat" ] ),
+            colors=ColorsConfig( **data[ "colors" ] ),
+    )
+
+config = _load_config()

tchat_client-0.12.0/tchat/config/config.toml

@@ -0,0 +1,28 @@
+[server]
+ip = "0.0.0.0"
+port = 9999
+waiting_list_size = 1
+
+[client]
+ip = "100.81.188.25" # e.g. 132.12.122.1
+port = 9999
+reconnect_delay = 5
+
+[logger]
+typewriter = false
+typewriter_delay = 0.02
+timestamp_format = "%H:%M"
+log_to_file = true
+log_file = "~/.local/share/tchat/server.log"
+
+[chat]
+max_message_length = 500
+history_size = 50
+
+[colors]
+join = "green"
+leave = "red"
+server = "blue"
+timestamp = "white"
+error = "red"
+info = "yellow"

tchat_client-0.12.0/tchat/exceptions.py

@@ -0,0 +1,26 @@
+class ChatError( Exception ):
+    """Base class for all chat application errors."""
+
+
+class MessageFramingError( ChatError ):
+    """Raised when a framed message cannot be read ( connection closed mid-frame )."""
+
+
+class InvalidMessageError( ChatError ):
+    """Raised when a message cannot be parsed ( invalid JSON or unknown type )."""
+
+
+class UnknowUserError( ChatError ):
+    """Raised when an address is not registered in the server state."""
+
+
+class CommandError( ChatError ):
+    """Raised when a command is unknow or malformed."""
+
+
+class ConfigError( ChatError ):
+    """Raised when configuration is missing or invalid."""
+
+
+class JoinError( ChatError ):
+    """Raised when a JOIN request is invalid ( empty or taken username )."""

tchat_client-0.12.0/tchat/logger/__init__.py

@@ -0,0 +1 @@
+from . import client, server

tchat_client-0.12.0/tchat/logger/base.py

@@ -0,0 +1,24 @@
+import threading
+from datetime import datetime
+
+from .colors import Colors
+from . import typewriter
+from tchat.config import config as _config
+
+
+_lock = threading.Lock()
+_user_colors: dict[ str, Colors ] = {}
+_available_colors = [ Colors.BLUE, Colors.GREEN, Colors.YELLOW, Colors.RED, Colors.WHITE ]
+
+def get_user_color( user: str ) -> Colors:
+    if user not in _user_colors:
+        _user_colors[ user ] = _available_colors[ len( _user_colors ) % len( _available_colors ) ]
+    return _user_colors[ user ]
+
+def log( msg: str, server_mode: bool = False ) -> None:
+    with _lock:
+        if not server_mode and _config.logger.typewriter:
+            typewriter.write( msg, _config.logger.typewriter_delay )
+        else:
+            print( msg )
+

tchat_client-0.12.0/tchat/logger/client.py

@@ -0,0 +1,42 @@
+from . import base
+from .colors import Colors
+from tchat.message.message import Message, MessageType
+
+
+def _tag( label: str, color: str ) -> str:
+    return f"{ Colors.WHITE.value }>{ Colors.RESET.value } { color }[{ label:^5}]{ Colors.RESET.value }"
+
+def _emit( msg: str ) -> None:
+    base.log( msg, server_mode=False )
+
+def info( msg: str ) -> None:
+    _emit( f"{ _tag('SYS', Colors.WHITE.value) } { msg }" )
+
+def warning( msg: str ) -> None:
+    _emit( f"{ _tag('WARN', Colors.YELLOW.value) } { msg }" )
+
+def error( msg: str ) -> None:
+    _emit( f"{ _tag('ERR', Colors.RED.value) } { msg }" )
+
+def message( msg: Message ) -> None:
+    if msg.type == MessageType.JOIN:
+        _emit( f"{ _tag('JOIN', Colors.GREEN.value) } { msg.sender } has entered the chat" )
+    elif msg.type == MessageType.LEAVE:
+        _emit( f"{ _tag('LEAVE', Colors.YELLOW.value) } { msg.sender } has left the chat" )
+    elif msg.type == MessageType.CHAT:
+        color = base.get_user_color( msg.sender ).value
+        _emit( f"{ _tag('MSG', Colors.WHITE.value) } { color }{ Colors.BOLD.value }{ msg.sender }{ Colors.RESET.value }: { msg.content }" )
+    elif msg.type == MessageType.COMMAND:
+        _emit( f"{ _tag('CMD', Colors.BLUE.value) } { msg.content }" )
+
+def banner() -> None:
+    chat = r"""
+ _____ _   _  _____   _     _____ _____ _   _ _ _____   _____  _   _   ___ _____
+|_   _| | | ||  ___| | |   |_   _|  _  | \ | ( )  ___| /  __ \| | | | / _ \_   _|
+  | | | |_| || |__   | |     | | | | | |  \| |/\ `--.  | /  \/| |_| |/ /_\ \| |
+  | | |  _  ||  __|  | |     | | | | | | . ` |  `--. \ | |    |  _  ||  _  || |
+  | | | | | || |___  | |_____| |_\ \_/ / |\  | /\__/ / | \__/\| | | || | | || |
+  \_/ \_| |_/\____/  \_____/\___/ \___/\_| \_/ \____/   \____/\_| |_/\_| |_/\_/
+
+"""
+    print( f"{ Colors.BLUE.value }{ chat }{ Colors.RESET.value }" )

tchat_client-0.12.0/tchat/logger/colors.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class Colors( Enum ):
+    BLUE = "\033[34m"
+    GREEN = "\033[32m"
+    WHITE = "\033[37m"
+    YELLOW = "\033[33m"
+    RED = "\033[31m"
+    RESET = "\033[0m"
+    BOLD = "\033[1m"

tchat_client-0.12.0/tchat/logger/server.py

@@ -0,0 +1,48 @@
+import os
+from datetime import datetime
+from pathlib import Path
+
+from . import base
+from tchat.message.message import Message, MessageType
+from tchat.config import config as _config
+
+
+def _prefix( level: str ) -> str:
+    timestamp = datetime.now().strftime( "%b %d %H:%M:%S" )
+    return f"{ timestamp } tchat[{ os.getpid() }]: { level:^7}"
+
+def _emit( msg: str ) -> None:
+    base.log( msg, server_mode=True )
+    _log_to_file( msg )
+
+def info( msg: str ) -> None:
+    _emit( f"{ _prefix('INFO') } { msg }" )
+
+def warning( msg: str ) -> None:
+    _emit( f"{ _prefix('WARN') } { msg }" )
+
+def error( msg: str ) -> None:
+    _emit( f"{ _prefix('ERROR') } { msg }" )
+
+def message( msg: Message ) -> None:
+    if msg.type == MessageType.JOIN:
+        _emit( f"{ _prefix('JOIN') } { msg.sender } joined" )
+    elif msg.type == MessageType.LEAVE:
+        _emit( f"{ _prefix('LEAVE') } { msg.sender } left" )
+    elif msg.type == MessageType.CHAT:
+        _emit( f"{ _prefix('CHAT') } { msg.sender }: { msg.content }" )
+    elif msg.type == MessageType.COMMAND:
+        _emit( f"{ _prefix('CMD') } { msg.content }" )
+
+def connected( address: tuple ) -> None:
+    _emit( f"{ _prefix('CONN') } { address }" )
+
+def disconnected( address: tuple ) -> None:
+    _emit( f"{ _prefix('DISC') } { address }" )
+
+def _log_to_file( msg: str ) -> None:
+    if _config.logger.log_to_file:
+        log_path = Path( _config.logger.log_file ).expanduser()
+        log_path.parent.mkdir( parents=True, exist_ok=True )
+        with open( log_path, "a" ) as f:
+            f.write( msg + "\n" )

tchat_client-0.12.0/tchat/logger/typewriter.py

@@ -0,0 +1,10 @@
+import time
+import sys
+
+
+def write( msg: str, delay: float = 0.1 ) -> None:
+    for char in msg:
+        sys.stdout.write( char )
+        sys.stdout.flush()
+        time.sleep( delay )
+    print()

tchat_client-0.12.0/tchat/message/framing.py

@@ -0,0 +1,44 @@
+import struct
+import socket
+
+from tchat.exceptions import MessageFramingError
+
+
+def send_framed( sock: socket.socket, payload: str ) -> None:
+    """
+    Send a framed message through a socket.
+    """
+    data = payload.encode( "utf-8" )
+    sock.sendall( struct.pack( ">I", len( data ) ) + data )
+
+def receive_framed( sock: socket.socket ) -> str:
+    """
+    Receive a framed message from a socket.
+
+    The message format is:
+        [ 4 bytes length ][ payload ]
+
+    The first 4 bytes indicate the size of the payload (big-endian).
+    Then the exact number of bytes is read and decoded as UTF-8.
+    """
+    header = _receive_exact( sock, 4 )
+    length = struct.unpack( ">I", header )[ 0 ]
+    body = _receive_exact( sock, length )
+    return body.decode( "utf-8" )
+
+def _receive_exact( sock: socket.socket, n: int ) -> bytes:
+    """
+    This function keeps reading from the socket until n bytes are received.
+    If the connection is closed or an error occurs before that, an 'MessageFramingError'
+    is raised. Else the received data of length n is returned.
+    """
+    buf = b""
+    while len( buf ) < n:
+        try:
+            chunk = sock.recv( n - len( buf ) )
+        except OSError:
+            raise MessageFramingError( "Socket error or connection closed" )
+        if not chunk:
+            raise MessageFramingError( "Connection closed mid-frame" )
+        buf += chunk
+    return buf

tchat_client-0.12.0/tchat/message/message.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass, asdict
+from datetime import datetime
+import json
+
+from .types import MessageType
+from tchat.exceptions import InvalidMessageError
+from tchat.config import config as _config
+
+
+@dataclass
+class Message:
+    type: MessageType
+    sender: str
+    content: str
+    timestamp: str
+
+    @classmethod
+    def make( cls, type: MessageType, sender: str, content: str ) -> "Message":
+        return cls(
+            type=type,
+            sender=sender,
+            content=content,
+            timestamp=datetime.now().strftime( _config.logger.timestamp_format )
+        )
+
+    def to_json( self ) -> str:
+        self_dict = asdict( self )
+        self_dict[ "type" ] = self.type.value
+        return json.dumps( self_dict )
+
+    @classmethod
+    def from_json( cls, data: str ) -> "Message":
+        try:
+            self_dict = json.loads( data )
+            self_dict[ "type" ] = MessageType( self_dict[ "type" ] )
+            return cls( **self_dict )
+        except ( json.JSONDecodeError, KeyError, ValueError ) as e:
+            raise InvalidMessageError( f"Cannot parse message: { e }" ) from e

tchat_client-0.12.0/tchat/message/types.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MessageType( Enum ):
+    CHAT = "chat"
+    COMMAND = "command"
+    JOIN = "join"
+    LEAVE = "leave"
+    VERSION = "version"
+    TYPING = "typing"

tchat_client-0.12.0/tchat/version.py

@@ -0,0 +1 @@
+VERSION = "v0.12.0"