From e93b86801b42684bc7df99ead1cd9261253fc881 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juhani=20Krekel=C3=A4?= Date: Tue, 26 Oct 2021 16:18:27 +0300 Subject: [PATCH] TkPyrkki v1 --- tkpyrkki.py | 376 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 376 insertions(+) create mode 100644 tkpyrkki.py diff --git a/tkpyrkki.py b/tkpyrkki.py new file mode 100644 index 0000000..bdf775f --- /dev/null +++ b/tkpyrkki.py @@ -0,0 +1,376 @@ +#!/usr/bin/env python3 +# +# TkPyrkki v1, by nortti +# +# CC0 1.0 Universal +# +# CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE +# LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN +# ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS +# INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES +# REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS +# PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM +# THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED +# HEREUNDER. +# +# Statement of Purpose +# +# The laws of most jurisdictions throughout the world automatically confer +# exclusive Copyright and Related Rights (defined below) upon the creator +# and subsequent owner(s) (each and all, an "owner") of an original work of +# authorship and/or a database (each, a "Work"). +# +# Certain owners wish to permanently relinquish those rights to a Work for +# the purpose of contributing to a commons of creative, cultural and +# scientific works ("Commons") that the public can reliably and without fear +# of later claims of infringement build upon, modify, incorporate in other +# works, reuse and redistribute as freely as possible in any form whatsoever +# and for any purposes, including without limitation commercial purposes. +# These owners may contribute to the Commons to promote the ideal of a free +# culture and the further production of creative, cultural and scientific +# works, or to gain reputation or greater distribution for their Work in +# part through the use and efforts of others. +# +# For these and/or other purposes and motivations, and without any +# expectation of additional consideration or compensation, the person +# associating CC0 with a Work (the "Affirmer"), to the extent that he or she +# is an owner of Copyright and Related Rights in the Work, voluntarily +# elects to apply CC0 to the Work and publicly distribute the Work under its +# terms, with knowledge of his or her Copyright and Related Rights in the +# Work and the meaning and intended legal effect of CC0 on those rights. +# +# 1. Copyright and Related Rights. A Work made available under CC0 may be +# protected by copyright and related or neighboring rights ("Copyright and +# Related Rights"). Copyright and Related Rights include, but are not +# limited to, the following: +# +# i. the right to reproduce, adapt, distribute, perform, display, +# communicate, and translate a Work; +# ii. moral rights retained by the original author(s) and/or performer(s); +# iii. publicity and privacy rights pertaining to a person's image or +# likeness depicted in a Work; +# iv. rights protecting against unfair competition in regards to a Work, +# subject to the limitations in paragraph 4(a), below; +# v. rights protecting the extraction, dissemination, use and reuse of data +# in a Work; +# vi. database rights (such as those arising under Directive 96/9/EC of the +# European Parliament and of the Council of 11 March 1996 on the legal +# protection of databases, and under any national implementation +# thereof, including any amended or successor version of such +# directive); and +# vii. other similar, equivalent or corresponding rights throughout the +# world based on applicable law or treaty, and any national +# implementations thereof. +# +# 2. Waiver. To the greatest extent permitted by, but not in contravention +# of, applicable law, Affirmer hereby overtly, fully, permanently, +# irrevocably and unconditionally waives, abandons, and surrenders all of +# Affirmer's Copyright and Related Rights and associated claims and causes +# of action, whether now known or unknown (including existing as well as +# future claims and causes of action), in the Work (i) in all territories +# worldwide, (ii) for the maximum duration provided by applicable law or +# treaty (including future time extensions), (iii) in any current or future +# medium and for any number of copies, and (iv) for any purpose whatsoever, +# including without limitation commercial, advertising or promotional +# purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +# member of the public at large and to the detriment of Affirmer's heirs and +# successors, fully intending that such Waiver shall not be subject to +# revocation, rescission, cancellation, termination, or any other legal or +# equitable action to disrupt the quiet enjoyment of the Work by the public +# as contemplated by Affirmer's express Statement of Purpose. +# +# 3. Public License Fallback. Should any part of the Waiver for any reason +# be judged legally invalid or ineffective under applicable law, then the +# Waiver shall be preserved to the maximum extent permitted taking into +# account Affirmer's express Statement of Purpose. In addition, to the +# extent the Waiver is so judged Affirmer hereby grants to each affected +# person a royalty-free, non transferable, non sublicensable, non exclusive, +# irrevocable and unconditional license to exercise Affirmer's Copyright and +# Related Rights in the Work (i) in all territories worldwide, (ii) for the +# maximum duration provided by applicable law or treaty (including future +# time extensions), (iii) in any current or future medium and for any number +# of copies, and (iv) for any purpose whatsoever, including without +# limitation commercial, advertising or promotional purposes (the +# "License"). The License shall be deemed effective as of the date CC0 was +# applied by Affirmer to the Work. Should any part of the License for any +# reason be judged legally invalid or ineffective under applicable law, such +# partial invalidity or ineffectiveness shall not invalidate the remainder +# of the License, and in such case Affirmer hereby affirms that he or she +# will not (i) exercise any of his or her remaining Copyright and Related +# Rights in the Work or (ii) assert any associated claims and causes of +# action with respect to the Work, in either case contrary to Affirmer's +# express Statement of Purpose. +# +# 4. Limitations and Disclaimers. +# +# a. No trademark or patent rights held by Affirmer are waived, abandoned, +# surrendered, licensed or otherwise affected by this document. +# b. Affirmer offers the Work as-is and makes no representations or +# warranties of any kind concerning the Work, express, implied, +# statutory or otherwise, including without limitation warranties of +# title, merchantability, fitness for a particular purpose, non +# infringement, or the absence of latent or other defects, accuracy, or +# the present or absence of errors, whether or not discoverable, all to +# the greatest extent permissible under applicable law. +# c. Affirmer disclaims responsibility for clearing rights of other persons +# that may apply to the Work or any use thereof, including without +# limitation any person's Copyright and Related Rights in the Work. +# Further, Affirmer disclaims responsibility for obtaining any necessary +# consents, permissions or other rights required for any use of the +# Work. +# d. Affirmer understands and acknowledges that Creative Commons is not a +# party to this document and has no duty or obligation with respect to +# this CC0 or use of the Work. + +import os +import socket +import sys +import threading +import time + +import tkinter +from tkinter import ttk + +receiver_quit = False +class Receiver(threading.Thread): + def __init__(self, s): + self.s = s + super().__init__() + + def run(self): + global receiver_quit + buffer = bytearray() + while True: + data = self.s.recv(1024) + if data == b'': break + buffer.extend(data) + + while b'\r\n' in buffer: + line, _, buffer = buffer.partition(b'\r\n') + fields = line.split(b' ') + if len(fields) > 0 and fields[0] == b'PING': + with sock_lock: + self.s.sendall(b'PONG ' + b' '.join(fields[1:]) + b'\r\n') + continue + elif len(fields) > 1 and fields[1] == b'PRIVMSG': + prefix, _, target, *message = fields + msg_nick = prefix.split(b'!')[0][1:].decode(errors='replace') + target = target.decode(errors='replace') + if target == nick: + target = msg_nick + message = b' '.join(message).decode(errors='replace')[1:] + append_message(target, msg_nick, message) + else: + scrollback_append(line.decode(errors='replace')) + receiver_quit = True + +if 'USER' in os.environ: + username = os.environ['USER'] +elif 'USERNAME' in os.environ: + username = os.environ['USERNAME'] +else: + username = 'tkpyrkki-user' + +if len(sys.argv) > 4: + print('{} [server [port [nick]]]'.format(sys.argv[0])) + sys.exit(1) + +elif len(sys.argv) == 4: + host = sys.argv[1] + try: + port = int(sys.argv[2]) + except ValueError: + print('Port must be an intenger') + nick = sys.argv[3] + +else: + root = tkinter.Tk() + root.title('Connect...') + frame = ttk.Frame(root) + frame.grid(column=0, row=0, sticky='NSWE') + root.columnconfigure(0, weight=1) + root.rowconfigure(0, weight=1) + + host_str = tkinter.StringVar() + host_str.set(sys.argv[1] if len(sys.argv) > 1 else 'irc.libera.chat') + host_label = ttk.Label(frame, text='Host') + host_label.grid(column=0, row=0, sticky='W') + host_entry = ttk.Entry(frame, textvariable=host_str) + host_entry.grid(column=1, row=0, sticky='WE') + host_entry.icursor('end') + host_entry.focus() + + def check_port(port): + if port == '': return True + try: + port_int = int(port) + except ValueError: + return False + return 0 < port_int < 1<<16 + + port_str = tkinter.StringVar() + port_str.set(sys.argv[2] if len(sys.argv) > 2 else '6667') + port_label = ttk.Label(frame, text='Port') + port_label.grid(column=0, row=1, sticky='W') + port_entry = ttk.Entry(frame, textvariable=port_str, validate='key', validatecommand=(root.register(check_port), '%P')) + port_entry.grid(column=1, row=1, sticky='WE') + + nick_str = tkinter.StringVar() + nick_str.set(username) # If it's set on command line, we don't get here + nick_label = ttk.Label(frame, text='Nick') + nick_label.grid(column=0, row=2, sticky='W') + nick_entry = ttk.Entry(frame, textvariable=nick_str) + nick_entry.grid(column=1, row=2, sticky='WE') + + should_connect = False + def connect_click(*_): + global should_connect + should_connect = True + root.destroy() + connect_button = ttk.Button(frame, text='Connect', command=connect_click) + connect_button.grid(column=1, row=3, sticky='SE', pady=(2,0)) + + frame.columnconfigure(1, weight=1) + frame.rowconfigure(3, weight=1) + + root.bind('', connect_click) + + root.mainloop() + + if not should_connect: + sys.exit(0) + + host = host_str.get() + port = int(port_str.get()) + nick = nick_str.get() + +root = tkinter.Tk() +root.title('TkPyrkki') +frame = ttk.Frame(root) +frame.grid(column=0, row=0, sticky='NSWE') +root.columnconfigure(0, weight=1) +root.rowconfigure(0, weight=1) + +scrollback = tkinter.Text(frame, width=80, height=24, wrap='word') +scrollback.insert('1.0', 'Connecting to {}'.format(host, ':{}'.format(port) if port != 6667 else '')) +scrollback['state'] = 'disabled' +scrollback.grid(column=0, columnspan=2, row=0, sticky='NSWE') + +scrollback_lock = threading.Lock() +def scrollback_append(text): + with scrollback_lock: + scrollback['state'] = 'normal' + scrollback.insert('end', '\n') + scrollback.insert('end', text) + scrollback['state'] = 'disabled' + scrollback.see('end') + +scrollback_scroll = ttk.Scrollbar(frame, orient=tkinter.VERTICAL, command=scrollback.yview) +scrollback_scroll.grid(column=2, row=0, sticky='NS') + +scrollback['yscrollcommand'] = scrollback_scroll.set + +channel = tkinter.StringVar() +ttk.Label(frame, textvariable=channel).grid(column=0, row=1, sticky='W') + +input_text = tkinter.StringVar() +inputline = ttk.Entry(frame, textvariable=input_text) +inputline.grid(column=1, columnspan=2, row=1, sticky='WE', pady=(2,0)) +inputline.focus() + +frame.columnconfigure(1, weight=1) +frame.rowconfigure(0, weight=1) + +s = None +try: + for af, socktype, proto, canonname, sa in socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM): + try: + s = socket.socket(af, socktype, proto) + except OSError: + s = None + continue + try: + s.connect((host, port)) + except OSError: + s.close() + s = None + continue + break + +except socket.gaierror: + pass + +sock_lock = threading.Lock() + +def sendline(sock, line): + assert '\n' not in line + with sock_lock: + sock.sendall(line.encode() + b'\r\n') + +still_connected = True +if s is not None: + sendline(s, 'nick {}'.format(nick)) + sendline(s, 'USER {} a a :{}'.format(username, username)) + + Receiver(s).start() + +else: + scrollback_append('Failed to establish connection') + inputline.state(['disabled']) + still_connected = False + +def append_message(target, nick, message): + scrollback_append('{} <{}> {}'.format(target, nick, message)) + +def send(*_): + global nick, still_connected + line = input_text.get() + + if line.startswith('/'): + command, _, args = line[1:].lstrip().partition(' ') + command = command.lower() + if command == 'join': + channel.set(args.strip()) + sendline(s, 'JOIN {}'.format(channel.get())) + elif command == 'msg': + target, _, message = args.lstrip().partition(' ') + sendline(s, 'PRIVMSG {} :{}'.format(target, message)) + append_message(target, nick, message) + elif command == 'nick': + nick = args.strip() + sendline(s, 'NICK {}'.format(nick)) + elif command == 'part': + part_channel = channel.get() if args.strip() == '' else args.strip() + if part_channel == channel.get(): channel.set('') + sendline(s, 'PART {}'.format(part_channel)) + elif command == 'quit': + reason = 'TkPyrkki quit' if args.strip() == '' else args.strip() + sendline(s, 'QUIT :{}'.format(reason)) + inputline.state(['disabled']) + still_connected = False + elif command == 'raw': + sendline(s, args) + elif command == 'target': + channel.set(args.strip()) + else: + return + else: + if channel.get() != '': + sendline(s, 'PRIVMSG {} :{}'.format(channel.get(), line)) + append_message(channel.get(), nick, line) + else: + return + + input_text.set('') + +inputline.bind('', send) + +def quit(): + if still_connected: + sendline(s, 'QUIT :TkPyrkki quit') + while not receiver_quit: + time.sleep(0.1) + root.destroy() +root.protocol('WM_DELETE_WINDOW', quit) + +root.mainloop()