updates

.gitignore

@@ -1,15 +1,27 @@
+.pylint.err
+.pylint.out
 *.pyc
 *.pyo
+
+*.zip
+*.bak
+*.lis
+*.dst
+*.so
+
 toxygen/toxcore
 tests/tests
-tests/libs
+toxygen/libs
 tests/.cache
 tests/__pycache__
 tests/avatars
 toxygen/libs
 .idea
 *~
+#*
 *.iml
+*.junk
+
 *.so
 *.log
 toxygen/build

.pre-commit-config.yaml

@@ -0,0 +1,23 @@
+# -*- mode: yaml; indent-tabs-mode: nil; tab-width: 2; coding: utf-8-unix -*-
+---
+
+default_language_version:
+    python: python3.11
+default_stages: [pre-commit]
+fail_fast: true
+repos:
+- repo: local
+  hooks:
+    - id: pylint
+      name: pylint
+      entry: env PYTHONPATH=/mnt/o/var/local/src/toxygen.git/toxygen toxcore_pylint.bash
+      language: system
+      types: [python]
+      args:
+        [
+          "--source-roots=/mnt/o/var/local/src/toxygen.git/toxygen",
+          "-rn", # Only display messages
+          "-sn", # Don't display the score
+          "--rcfile=/usr/local/etc/testforge/pylint.rc", # Link to your config file
+          "-E"
+        ]

.pylintrc

@@ -0,0 +1,4 @@
+[pre-commit-hook]
+command=env PYTHONPATH=/mnt/o/var/local/src/toxygen.git/toxygen /usr/local/bin/toxcore_pylint.bash
+params= -E --exit-zero
+limit=8

.rsync.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+#find * -name \*.py | xargs grep -l '[ 	]*$' | xargs sed -i -e 's/[	 ]*$//'
+rsync "$@" -vaxL  --include \*.py \
+	--exclude Toxygen.egg-info --exclude build \
+	--exclude \*.pyc --exclude .pyl\* --exclude \*.so  --exclude \*~ \
+	--exclude __pycache__ --exclude \*.egg-info --exclude \*.new \
+	./ ../toxygen.git/|grep -v /$

README.md

@@ -1,13 +1,17 @@
 # Toxygen
 
-Toxygen is powerful cross-platform [Tox](https://tox.chat/) client written in pure Python3.
+Toxygen is powerful cross-platform [Tox](https://tox.chat/) client
+for Tox and IRC/weechat written in pure Python3.
 
 ### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md) - [Compile](/docs/compile.md) - [Contact](/docs/contact.md)
 
-### Supported OS: Linux and Windows
+### Supported OS: Linux and Windows (only Linux is tested at the moment)
 
 ### Features:
 
+- PyQt5, PyQt6, and maybe PySide2, PySide6 via qtpy
+- IRC via weechat /relay
+- NGC groups
 - 1v1 messages
 - File transfers
 - Audio calls
@@ -19,14 +23,13 @@ Toxygen is powerful cross-platform [Tox](https://tox.chat/) client written in pu
 - Emoticons
 - Stickers
 - Screenshots
-- Name lookups (toxme.io support)
 - Save file encryption
 - Profile import and export
 - Faux offline messaging
 - Faux offline file transfers
 - Inline images
 - Message splitting
-- Proxy support
+- Proxy support - runs over tor, without DNS leaks
 - Avatars
 - Multiprofile
 - Multilingual
@@ -37,47 +40,108 @@ Toxygen is powerful cross-platform [Tox](https://tox.chat/) client written in pu
 - Changing nospam
 - File resuming
 - Read receipts
-- NGC groups
+- uses gevent
 
 ### Screenshots
 *Toxygen on Ubuntu and Windows*
 ![Ubuntu](/docs/ubuntu.png)
 ![Windows](/docs/windows.png)
 
+Windows was working but is not currently being tested. AV is working
+but the video is garbled: we're unsure of naming the AV devices
+from the commandline. We need to get a working echobot that supports SOCKS5;
+we were working on one in https://git.plastiras.org/emdee/toxygen_wrapper
+
 ## Forked
 
 This hard-forked from the dead https://github.com/toxygen-project/toxygen
 ```next_gen``` branch.
  
-https://git.plastiras.org/emdee/toxygen_wrapper needs packaging
-is making a dependency. Just download it and copy the two directories
-```wrapper``` and ```wrapper_tests``` into ```toxygen/toxygen```.
-
 See ToDo.md to the current ToDo list.
 
+## IRC Weechat
+
 You can have a [weechat](https://github.com/weechat/qweechat)
 console so that you can have IRC and jabber in a window as well as Tox.
-There's a copy of qweechat in ```thirdparty/qweechat``` backported to
+There's a copy of qweechat in https://git.plastiras.org/emdee/qweechat
-PyQt5 and integrated into toxygen. Follow the normal instructions for
+that you must install first, which was backported to PyQt5 now to qtpy
-adding a ```relay``` to [weechat](https://github.com/weechat/weechat)
+(PyQt5 PyQt6 and PySide2 and PySide6) and integrated into toxygen.
-```
+Follow the normal instructions for adding a ```relay``` to
-/relay add ipv4.ssl.weechat 9001
+[weechat](https://github.com/weechat/weechat)
-/relay start ipv4.ssl.weechat
-```
-or
 ```
 /relay add weechat 9000
 /relay start weechat
 ```
-and use the Plugins/Weechat Console to start weechat under Toxygen.
+or
-Then use th File/Connect menu item of the console to connect to weechat.
+```
+weechat -r '/relay add weechat 9000;/relay start weechat'
+```
+and use the Plugins -> Weechat Console to start weechat under Toxygen.
+Then use the File/Connect menu item of the Console to connect to weechat.
 
 Weechat has a Jabber plugin to enable XMPP:
 ```
 /python load jabber.el
 /help jabber
 ```
-so you can have Tox, IRC and XMPP in the same application!
+so you can have Tox, IRC and XMPP in the same application! See docs/ToxygenWeechat.md
 
-Work on Tox on this project is suspended until the
+## Install
+
+To install read the requirements.txt and look at the comments; there
+are things that need installing by hand or decisions to be made
+on supported alternatives.
+
+https://git.plastiras.org/emdee/toxygen_wrapper needs installing as it is a
+dependency. Just download and install it from
+https://git.plastiras.org/emdee/toxygen_wrapper The same with
+https://git.plastiras.org/emdee/qweechat
+
+This is being ported to Qt6 using qtpy https://github.com/spyder-ide/qtpy
+It now runs on PyQt5 and PyQt6, and may run on PySide2 and PySide6 - YMMV.
+You will be able to choose between them by setting the environment variable
+```QT_API``` to one of: ```pyqt5 pyqt6 pyside2 pyside6```.
+It's currently tested mainly on PyQt5.
+
+To install it,  look in the Makefile for the install target and type
+```
+make install
+```
+You should set the PIP_EXE_MSYS and PYTHON_EXE_MSYS variables and it does
+```
+	${PIP_EXE_MSYS} --python ${PYTHON_EXE_MSYS} install \
+		--no-deps \
+		--target ${PREFIX}/lib/python${PYTHON_MINOR}/site-packages/ \
+		--upgrade .
+```
+and installs into PREFIX which is usually /usr/local
+
+## Updates
+
+Up-to-date code is on https://git.plastiras.org/emdee/toxygen
+
+Tox works over Tor, and the c-toxcore library can leak DNS requests
+due to a 6-year old known security issue:
+https://github.com/TokTok/c-toxcore/issues/469 but toxygen looksup
+addresses before calling c-toxcore. This also allows us to use onion
+addresses in the DHTnodes.json file. Still for anonymous communication
+we recommend having a TCP and UDP firewall in place.
+
+Although Tox works with multi-user group chat, there are no checks
+against impersonation of a screen nickname, so you may not be chatting
+with the person you think. For the Toxic client, the (closed) issue is:
+https://github.com/JFreegman/toxic/issues/622#issuecomment-1922116065
+Solving this might best be done with a solution to MultiDevice q.v.
+
+The Tox project does not follow semantic versioning of its main structures
+in C so the project may break the underlying ctypes wrapper at any time;
+it's not possible to use Tox version numbers to tell what the API will be.
+The last git version this code was tested with is
+``1623e3ee5c3a5837a92f959f289fcef18bfa9c959``` of Feb 12 10:06:37 2024.
+In which case you may need to go into the tox.py file in
+https://git.plastiras.org/emdee/toxygen_wrapper to fix it yourself.
+
+## MultiDevice
+
+Work on this project is suspended until the
 [MultiDevice](https://git.plastiras.org/emdee/tox_profile/wiki/MultiDevice-Announcements-POC) problem is solved. Fork me!

ToDo.md

@@ -4,14 +4,14 @@
 
 1. There is an agravating bug  where new messages are not put in the
    current window, and a messages waiting indicator appears. You have
-   to focus out of the window and then back in the window.
+   to focus out of the window and then back in the window. this may be
-
+   fixed already
 
+2. The tray icon is flaky and has been disabled - look in app.py
+   for bSHOW_TRAY
 
 ## Fix history
 
-The code is in there but it's not working.
-
 ## Fix Audio
 
 The code is in there but it's not working. It looks like audio input
@@ -25,7 +25,7 @@ The code is in there but it's not working.  I may have broken it
 trying to wire up the ability to set the video device from the command
 line.
 
-## Groups
+## NGC Groups
 
 1. peer_id There has been a change of API on a field named
    ```group.peer_id``` The code is broken in places because I have not
@@ -50,3 +50,21 @@ line.
 
 2. https://git.plastiras.org/emdee/toxygen_wrapper needs packaging
    and making a dependency.
+
+## Migration
+
+Migrate PyQt5 to qtpy - done, but I'm not sure qtpy supports PyQt6.
+https://github.com/spyder-ide/qtpy/
+
+Maybe migrate gevent to asyncio, and migrate to
+[qasync](https://github.com/CabbageDevelopment/qasync)
+(see https://git.plastiras.org/emdee/phantompy ).
+
+(Also look at https://pypi.org/project/asyncio-gevent/ but it's dead).
+
+## Standards
+
+There's a standard for Tox clients that this has not been tested against:
+https://tox.gitbooks.io/tox-client-standard/content/general_requirements/general_requirements.html
+https://github.com/Tox/Tox-Client-Standard
+

build/Dockerfile

@@ -1,13 +0,0 @@
-FROM ubuntu:16.04
-
-RUN apt-get update && \
-apt-get install build-essential libtool autotools-dev automake checkinstall cmake check git yasm libsodium-dev libopus-dev libvpx-dev pkg-config -y && \
-git clone https://github.com/ingvar1995/toxcore.git --branch=ngc_rebase && \
-cd toxcore && mkdir _build && cd _build && \
-cmake .. && make && make install
-
-RUN apt-get install portaudio19-dev python3-pyqt5 python3-pyaudio python3-pip -y && \
-pip3 install numpy pydenticon opencv-python pyinstaller
-
-RUN useradd -ms /bin/bash toxygen
-USER toxygen

build/build.sh

@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-
-cd ~
-git clone https://github.com/toxygen-project/toxygen.git --branch=next_gen
-cd toxygen/toxygen
-
-pyinstaller --windowed --icon=images/icon.ico main.py
-
-cp -r styles dist/main/
-find . -type f ! -name '*.qss' -delete
-cp -r plugins dist/main/
-mkdir -p dist/main/ui/views
-cp -r ui/views dist/main/ui/
-cp -r sounds dist/main/
-cp -r smileys dist/main/
-cp -r stickers dist/main/
-cp -r bootstrap dist/main/
-find . -type f ! -name '*.json' -delete
-cp -r images dist/main/
-cp -r translations dist/main/
-find . -name "*.ts" -type f -delete
-
-cd dist
-mv main toxygen
-cd toxygen
-mv main toxygen
-wget -O updater https://github.com/toxygen-project/toxygen_updater/releases/download/v0.1/toxygen_updater_linux_64
-echo "[Paths]" >> qt.conf
-echo "Prefix = PyQt5/Qt" >> qt.conf
-cd ..
-
-tar -zcvf toxygen_linux_64.tar.gz toxygen > /dev/null
-rm -rf toxygen

docs/ToxygenWeechat.md

@@ -0,0 +1,171 @@
+## Toxygen Weechat
+
+You can have a [weechat](https://github.com/weechat/qweechat)
+console so that you can have IRC and jabber in a window as well as Tox.
+There's a copy of qweechat in ```thirdparty/qweechat``` backported to
+PyQt5 and integrated into toxygen. Follow the normal instructions for
+adding a ```relay``` to [weechat](https://github.com/weechat/weechat)
+```
+/relay add ipv4.ssl.weechat 9000
+/relay start ipv4.ssl.weechat
+```
+or
+```
+/set relay.network.ipv6 off
+/set relay.network.password password
+/relay add weechat 9000
+/relay start weechat
+```
+and use the Plugins/Weechat Console to start weechat under Toxygen.
+Then use the File/Connect menu item of the Console to connect to weechat.
+
+Weechat has a Jabber plugin to enable XMPP:
+```
+/python load jabber.el
+/help jabber
+```
+so you can have Tox, IRC and XMPP in the same application!
+
+### Creating servers for IRC over Tor
+
+Create a proxy called tor
+```
+/proxy add tor socks5 127.0.0.1 9050
+```
+
+It should now show up in the list of proxies.
+```
+/proxy list
+```
+
+```
+/nick NickName
+```
+
+## TLS certificates
+
+[Create a Self-signed Certificate](https://www.oftc.net/NickServ/CertFP/)
+
+Choose a NickName you will identify as.
+
+Create a directory for your certificates ~/.config/weechat/ssl/ 
+and make a subdirectory for each server ~/.config/weechat/ssl/irc.oftc.net/ 
+
+Change to the server directory and use openssl to make a keypair and answer the questions:
+```
+openssl req -nodes -newkey rsa:2048 -keyout NickName.key -x509 -days 3650 -out NickName.cer
+chmod 400 NickName.key
+```
+We now combine certificate and key to a single file NickName.pem 
+```
+cat NickName.cer NickName.key > NickName.pem
+chmod 400 NickName.pem
+```
+
+Do this for each server you want to connect to, or just use one for all of them.
+
+### Libera TokTok channel
+
+The main discussion forum for Tox is the #TokTok channel on libera.
+
+https://mox.sh/sysadmin/secure-irc-connection-to-freenode-with-tor-and-weechat/
+We have to create an account without Tor, this is a requirement to use TOR:
+Connect to irc.libera.chat without Tor and register 
+```
+/msg NickServ identify NickName password
+/msg NickServ REGISTER mypassword mycoolemail@example.com
+/msg NickServ SET PRIVATE ON
+```
+You'll get an email with a registration code.
+Confirm registration after getting the mail with the code:
+```
+/msg NickServ VERIFY REGISTER NickName code1235678
+```
+
+Libera has an onion server so we can map an address in tor. Add this
+to your /etc/tor/torrc
+```
+MapAddress palladium.libera.chat libera75jm6of4wxpxt4aynol3xjmbtxgfyjpu34ss4d7r7q2v5zrpyd.onion
+```
+Or without the MapAddress just use
+libera75jm6of4wxpxt4aynol3xjmbtxgfyjpu34ss4d7r7q2v5zrpyd.onion
+as the server address below, but set tls_verify to off.
+
+Define the server in weechat
+https://www.weechat.org/files/doc/stable/weechat_user.en.html#irc_sasl_authentication
+```
+/server remove libera
+/server add libera palladium.libera.chat/6697 -tls -tls_verify
+/set irc.server.libera.ipv6 off
+/set irc.server.libera.proxy tor
+/set irc.server.libera.username NickName
+/set irc.server.libera.password password
+/set irc.server.libera.nicks NickName
+/set irc.server.libera.tls on
+/set irc.server.libera.tls_cert "${weechat_config_dir}/ssl/libera.chat/NickName.pem"
+```
+
+```
+/set irc.server.libera.sasl_mechanism ecdsa-nist256p-challenge
+/set irc.server.libera.sasl_username "NickName"
+/set irc.server.libera.sasl_key "${weechat_config_dir}/ssl/libera.chat/NickName.pem"
+```
+
+Disconnect and connect back to the server. 
+```
+/disconnect libera
+/connect libera
+```
+
+/msg nickserv identify password NickName
+
+
+### oftc.net
+
+To use oftc.net over tor, you need to authenticate by SSL certificates.
+
+
+Define the server in weechat
+```
+/server remove irc.oftc.net
+/server add OFTC irc.oftc.net/6697  -tls -tls_verify
+/set irc.server.OFTC.ipv6 off
+/set irc.server.OFTC.proxy tor
+/set irc.server.OFTC.username NickName
+/set irc.server.OFTC.nicks NickName
+/set irc.server.OFTC.tls on
+/set irc.server.OFTC.tls_cert "${weechat_config_dir}/ssl/irc.oftc.chat/NickName.pem"
+
+# Disconnect and connect back to the server. 
+/disconnect OFTC
+/connect OFTC
+``` 
+You must be identified in order to validate using certs
+```
+/msg nickserv identify password NickName
+```
+To allow NickServ to identify you based on this certificate you need
+to associate the certificate fingerprint with your nick. To do this
+issue the command cert add to Nickserv (try /msg nickserv helpcert).
+```
+/msg nickserv cert add
+```
+
+### Privacy
+
+[Add somes settings bellow to weechat](https://szorfein.github.io/weechat/tor/configure-weechat/).
+Detail from [faq](https://weechat.org/files/doc/weechat_faq.en.html#security).
+
+```
+/set irc.server_default.msg_part ""
+/set irc.server_default.msg_quit ""
+/set irc.ctcp.clientinfo ""
+/set irc.ctcp.finger ""
+/set irc.ctcp.source ""
+/set irc.ctcp.time ""
+/set irc.ctcp.userinfo ""
+/set irc.ctcp.version ""
+/set irc.ctcp.ping ""
+/plugin unload xfer
+/set weechat.plugin.autoload "*,!xfer"
+```

docs/install.md

@@ -21,8 +21,8 @@ Note: 32-bit Python isn't supported due to bug with videocalls. It is strictly r
 3. Install PyAudio: ``pip install pyaudio``
 4. Install numpy: ``pip install numpy``
 5. Install OpenCV: ``pip install opencv-python``
-6. [Download toxygen](https://github.com/toxygen-project/toxygen/archive/master.zip)
+6. git clone --depth=1 https://git.plastiras.org/emdee/toxygen/
-7. Unpack archive
+7. I don't know
 8. Download latest libtox.dll build, download latest libsodium.a build, put it into \toxygen\libs\
 9. Run \toxygen\main.py.
 
@@ -30,15 +30,22 @@ Note: 32-bit Python isn't supported due to bug with videocalls. It is strictly r
 
 1. Install latest Python3: 
 ``sudo apt-get install python3``
-2. Install PyQt5: ``sudo apt-get install python3-pyqt5`` or ``sudo pip3 install pyqt5``
+2. Install PyQt5: ``sudo apt-get install python3-pyqt5``
 3. Install [toxcore](https://github.com/TokTok/c-toxcore) with toxav support)
-4. Install PyAudio: 
+4. Install PyAudio: ``sudo apt-get install portaudio19-dev python3-pyaudio`` (or ``sudo pip3 install pyaudio``)
-``sudo apt-get install portaudio19-dev`` and ``sudo apt-get install python3-pyaudio`` (or ``sudo pip3 install pyaudio``)
+5. Install toxygen_wrapper https://git.plastiras.org/emdee/toxygen_wrapper
-5. Install NumPy: ``sudo pip3 install numpy``
+6. Install the rest of the requirements: ``sudo pip3 install -m requirements.txt``
-6. Install [OpenCV](http://docs.opencv.org/trunk/d7/d9f/tutorial_linux_install.html) or via ``sudo pip3 install opencv-python``
+7. git clone --depth=1 [toxygen](https://git.plastiras.org/emdee/toxygen/)
-7. [Download toxygen](https://git.plastiras.org/emdee/toxygen/)
+8. Look in the Makefile for the install target and type
-8. Unpack archive
+``
+make install
+``
+You should set the PIP_EXE_MSYS and PYTHON_EXE_MSYS variables and it does
+``
+	${PIP_EXE_MSYS} --python ${PYTHON_EXE_MSYS} install \
+		--target ${PREFIX}/lib/python${PYTHON_MINOR}/site-packages/ \
+		--upgrade .
+``
 9. Run app:
-``python3 main.py``
+``python3 ${PREFIX}/lib/python${PYTHON_MINOR}/site-packages/bin/toxygen``
 
-Optional: install toxygen using setup.py: ``python3 setup.py install``

docs/plugin_api.md

@@ -53,5 +53,5 @@ Plugin's methods MUST NOT raise exceptions.
 
 # Examples
 
-You can find examples in [official repo](https://github.com/toxygen-project/toxygen_plugins)
+You can find examples in [official repo](https://git.plastiras.org/emdee/toxygen_plugins)
 

docs/todo.md

@@ -0,0 +1,70 @@
+# Toxygen ToDo List
+
+## Bugs
+
+1. There is an agravating bug  where new messages are not put in the
+   current window, and a messages waiting indicator appears. You have
+   to focus out of the window and then back in the window. this may be
+   fixed already
+
+2. The tray icon is flaky and has been disabled - look in app.py
+   for bSHOW_TRAY
+
+## Fix history
+
+## Fix Audio
+
+The code is in there but it's not working. It looks like audio input
+is working but not output. The code is all in there; I may have broken
+it trying to wire up the ability to set the audio device from the
+command line.
+
+## Fix Video
+
+The code is in there but it's not working.  I may have broken it
+trying to wire up the ability to set the video device from the command
+line.
+
+## NGC Groups
+
+1. peer_id There has been a change of API on a field named
+   ```group.peer_id``` The code is broken in places because I have not
+   seen the path to change from the old API ro the new one.
+
+
+## Plugin system
+
+1. Needs better documentation and checking.
+
+2. There's something broken in the way some of them plug into Qt menus.
+
+3. Should the plugins be in toxygen or a separate repo?
+
+4. There needs to be a uniform way for plugins to wire into callbacks.
+
+## check toxygen_wrapper
+
+1. I've broken out toxygen_wrapper to be standalone,
+   https://git.plastiras.org/emdee/toxygen_wrapper but the tox.py
+   needs each call double checking.
+
+2. https://git.plastiras.org/emdee/toxygen_wrapper needs packaging
+   and making a dependency.
+
+## Migration
+
+Migrate PyQt5 to qtpy - done, but I'm not sure qtpy supports PyQt6.
+https://github.com/spyder-ide/qtpy/
+
+Maybe migrate gevent to asyncio, and migrate to
+[qasync](https://github.com/CabbageDevelopment/qasync)
+(see https://git.plastiras.org/emdee/phantompy ).
+
+(Also look at https://pypi.org/project/asyncio-gevent/ but it's dead).
+
+## Standards
+
+There's a standard for Tox clients that this has not been tested against:
+https://tox.gitbooks.io/tox-client-standard/content/general_requirements/general_requirements.html
+https://github.com/Tox/Tox-Client-Standard
+

pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "toxygen"
+description = "examples of using stem"
+authors = [{ name = "emdee", email = "emdee@spm.plastiras.org" } ]
+requires-python = ">=3.7"
+keywords = ["stem", "python3", "tox"]
+classifiers = [
+  # How mature is this project? Common values are
+  #   3 - Alpha
+  #   4 - Beta
+  #   5 - Production/Stable
+  "Development Status :: 4 - Beta",
+
+  # Indicate who your project is intended for
+  "Intended Audience :: Developers",
+
+  # Specify the Python versions you support here.
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved",
+  "Operating System :: POSIX :: BSD :: FreeBSD",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.6",
+  "Programming Language :: Python :: 3.7",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: Implementation :: CPython",
+]
+#
+dynamic = ["version", "readme", "dependencies"] # cannot be dynamic ['license']
+
+[project.gui-scripts]
+toxygen = "toxygen.__main__:main"
+
+[project.optional-dependencies]
+weechat = ["weechat"]
+
+#[project.license]
+#file = "LICENSE.md"
+
+[project.urls]
+repository = "https://git.plastiras.org/emdee/toxygen"
+
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = {attr = "toxygen.app.__version__"} 
+readme = {file = ["README.md", "ToDo.txt"]}
+dependencies = {file = ["requirements.txt"]}
+
+[tool.setuptools]
+packages = ["toxygen"]

requirements.txt

@@ -1,6 +1,26 @@
-PyQt5
+# the versions are the current ones tested - may work with earlier versions
-PyAudio
+# choose one of PyQt5 PyQt6 PySide2 PySide6
-numpy
+# for now PyQt5 and PyQt6 is working, and most of the testing is PyQt5
-opencv-python
+# usually this is installed by your OS package manager and pip may not
-pydenticon
+# detect the right version, so we leave these commented
-cv2
+# PyQt5 >= 5.15.10
+# this is not on pypi yet but is required - get it from
+# https://git.plastiras.org/emdee/toxygen_wrapper
+# toxygen_wrapper == 1.0.0
+QtPy >= 2.4.1
+PyAudio >= 0.2.13
+numpy >= 1.26.1
+opencv_python >= 4.8.0
+pillow >= 10.2.0
+gevent >= 23.9.1
+pydenticon >= 0.3.1
+greenlet >= 2.0.2
+sounddevice >= 0.3.15
+# this is optional
+coloredlogs >= 15.0.1
+# this is optional
+# qtconsole >= 5.4.3
+# this is not on pypi yet but is optional for qweechat - get it from
+# https://git.plastiras.org/emdee/qweechat
+# qweechat_wrapper == 0.0.1
+

setup.cfg

@@ -0,0 +1,54 @@
+[metadata]
+classifiers =
+    License :: OSI Approved
+    License :: OSI Approved :: BSD 1-clause
+    Intended Audience :: Web Developers
+    Operating System :: Microsoft :: Windows
+    Operating System :: POSIX :: BSD :: FreeBSD
+    Operating System :: POSIX :: Linux
+    Programming Language :: Python :: 3 :: Only
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3.11
+    Programming Language :: Python :: Implementation :: CPython
+
+[options]
+zip_safe = false
+python_requires = ~=3.7
+include_package_data =
+    "*" = ["*.ui", "*.txt", "*.png", "*.ico", "*.gif", "*.wav"]
+
+[options.entry_points]
+console_scripts =
+    toxygen = toxygen.__main__:iMain
+
+[easy_install]
+zip_ok = false
+
+[flake8]
+jobs = 1
+max-line-length = 88
+ignore =
+    E111
+    E114
+    E128
+    E225
+    E261
+    E302
+    E305
+    E402
+    E501
+    E502
+    E541
+    E701
+    E702
+    E704
+    E722
+    E741
+    F508
+    F541
+    W503
+    W601

setup.py

@@ -1,93 +0,0 @@
-from setuptools import setup
-from setuptools.command.install import install
-from platform import system
-from subprocess import call
-import main
-import sys
-import os
-from utils.util import curr_directory, join_path
-
-
-version = main.__version__ + '.0'
-
-
-if system() == 'Windows':
-    MODULES = ['PyQt5', 'PyAudio', 'numpy', 'opencv-python', 'pydenticon', 'cv2']
-else:
-    MODULES = ['pydenticon']
-    MODULES.append('PyQt5')
-    try:
-        import pyaudio
-    except ImportError:
-        MODULES.append('PyAudio')
-    try:
-        import numpy
-    except ImportError:
-        MODULES.append('numpy')
-    try:
-        import cv2
-    except ImportError:
-        MODULES.append('opencv-python')
-    try:
-        import coloredlogs
-    except ImportError:
-        MODULES.append('coloredlogs')
-    try:
-        import pyqtconsole
-    except ImportError:
-        MODULES.append('pyqtconsole')
-
-
-def get_packages():
-    directory = join_path(curr_directory(__file__), 'toxygen')
-    for root, dirs, files in os.walk(directory):
-        packages = map(lambda d: 'toxygen.' + d, dirs)
-        packages = ['toxygen'] + list(packages)
-        return packages
-
-class InstallScript(install):
-    """This class configures Toxygen after installation"""
-
-    def run(self):
-        install.run(self)
-        try:
-            if system() != 'Windows':
-                call(["toxygen", "--clean"])
-        except:
-            try:
-                params = list(filter(lambda x: x.startswith('--prefix='), sys.argv))
-                if params:
-                    path = params[0][len('--prefix='):]
-                    if path[-1] not in ('/', '\\'):
-                        path += '/'
-                    path += 'bin/toxygen'
-                    if system() != 'Windows':
-                        call([path, "--clean"])
-            except:
-                pass
-
-
-setup(name='Toxygen',
-      version=version,
-      description='Toxygen - Tox client',
-      long_description='Toxygen is powerful Tox client written in Python3',
-      url='https://git.plastiras.org/emdee/toxygen/',
-      keywords='toxygen Tox messenger',
-      author='Ingvar',
-      maintainer='',
-      license='GPL3',
-      packages=get_packages(),
-      install_requires=MODULES,
-      include_package_data=True,
-      classifiers=[
-          'Programming Language :: Python :: 3 :: Only',
-          'Programming Language :: Python :: 3.9',
-      ],
-      entry_points={
-          'console_scripts': ['toxygen=toxygen.main:main']
-      },
-      cmdclass={
-          'install': InstallScript
-      },
-      zip_safe=False
-      )

setup.py.dst

@@ -0,0 +1,53 @@
+import sys
+import os
+from setuptools import setup
+from setuptools.command.install import install
+
+version = '1.0.0'
+
+MODULES = open('requirements.txt', 'rt').readlines()
+
+def get_packages():
+    directory = os.path.join(os.path.dirname(__file__), 'tox_wrapper')
+    for root, dirs, files in os.walk(directory):
+        packages = map(lambda d: 'toxygen.' + d, dirs)
+        packages = ['toxygen'] + list(packages)
+        return packages
+
+class InstallScript(install):
+    """This class configures Toxygen after installation"""
+
+    def run(self):
+        install.run(self)
+
+setup(name='Toxygen',
+      version=version,
+      description='Toxygen - Tox client',
+      long_description='Toxygen is powerful Tox client written in Python3',
+      url='https://git.plastiras.org/emdee/toxygen/',
+      keywords='toxygen Tox messenger',
+      author='Ingvar',
+      maintainer='',
+      license='GPL3',
+      packages=get_packages(),
+      install_requires=MODULES,
+      include_package_data=True,
+      classifiers=[
+          'Programming Language :: Python :: 3 :: Only',
+    "Programming Language :: Python :: 3.6",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+          'Programming Language :: Python :: 3.11',
+      ],
+      entry_points={
+          'console_scripts': ['toxygen=toxygen.main:main']
+      },
+      package_data={"": ["*.ui"],},
+      cmdclass={
+          'install': InstallScript,
+      },
+      zip_safe=False
+      )

tests/travis.py

@@ -1,4 +1,4 @@
 class TestToxygen:
 
     def test_main(self):
-        import toxygen.main  # check for syntax errors
+        import toxygen.__main__  # check for syntax errors

toxygen/.pylint.sh

@@ -3,3 +3,12 @@
 ROLE=logging
 /var/local/bin/pydev_pylint.bash -E -f text *py [a-nr-z]*/*py  >.pylint.err
 /var/local/bin/pydev_pylint.bash *py [a-nr-z]*/*py  >.pylint.out
+
+sed -e "/Module 'os' has no/d" \
+    -e "/Undefined variable 'app'/d" \
+    -e '/tests\//d' \
+    -e "/Instance of 'Curl' has no /d" \
+    -e "/No name 'path' in module 'os' /d" \
+    -e "/ in module 'os'/d" \
+    -e "/.bak\//d" \
+	-i .pylint.err .pylint.out

toxygen/__init__.py

@@ -1,8 +1,3 @@
 import os
 import sys
 
-path = os.path.dirname(os.path.realpath(__file__))  # curr dir
-
-sys.path.insert(0, os.path.join(path, 'styles'))
-sys.path.insert(0, os.path.join(path, 'plugins'))
-sys.path.insert(0, path)

toxygen/__main__.py

@@ -1,22 +1,22 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 import sys
 import os
-import app
-import argparse
 import logging
 import signal
-
+import time
-import faulthandler
-faulthandler.enable()
-
 import warnings
+import faulthandler
+
+from gevent import monkey; monkey.patch_all(); del monkey   # noqa
+
+faulthandler.enable()
 warnings.filterwarnings('ignore')
 
-import wrapper_tests.support_testing as ts
+import toxygen_wrapper.tests.support_testing as ts
 try:
     from trepan.interfaces import server as Mserver
     from trepan.api import debug
-except:
+except Exception as e:
     print('trepan3 TCP server NOT enabled.')
 else:
     import signal
@@ -25,6 +25,7 @@ else:
         print('trepan3 TCP server enabled on port 6666.')
     except: pass
 
+import app
 from user_data.settings import *
 from user_data.settings import Settings
 from user_data import settings
@@ -33,21 +34,28 @@ with ts.ignoreStderr():
     import pyaudio
 
 __maintainer__ = 'Ingvar'
-__version__ = '0.5.0+'
+__version__ = '1.0.0' # was 0.5.0+
+
+path = os.path.dirname(os.path.realpath(__file__))  # curr dir
+sys.path.insert(0, os.path.join(path, 'styles'))
+sys.path.insert(0, os.path.join(path, 'plugins'))
+# sys.path.insert(0, os.path.join(path, 'third_party'))
+sys.path.insert(0, path)
 
-import time
 sleep = time.sleep
 
-def reset():
+os.environ['QT_API'] = os.environ.get('QT_API', 'pyqt5')
+
+def reset() -> None:
     Settings.reset_auto_profile()
 
-def clean():
+def clean() -> None:
     """Removes libs folder"""
     directory = util.get_libs_directory()
     util.remove(directory)
 
-def print_toxygen_version():
+def print_toxygen_version() -> None:
-    print('Toxygen ' + __version__)
+    print('toxygen ' + __version__)
 
 def setup_default_audio():
     # need:
@@ -73,8 +81,15 @@ def setup_default_audio():
 
 def setup_video(oArgs):
     video = setup_default_video()
-    if oArgs.video_input == '-1':
+    # this is messed up - no video_input in oArgs
-        video['device'] = video['output_devices'][1]
+    #     parser.add_argument('--video_input', type=str,)
+    print(video)
+    if not video or not video['output_devices']:
+        video['device'] = -1
+    if not hasattr(oArgs, 'video_input'):
+        video['device'] = video['output_devices'][0]
+    elif oArgs.video_input == '-1':
+        video['device'] = video['output_devices'][-1]
     else:
         video['device'] = oArgs.video_input
     return video
@@ -166,13 +181,12 @@ def setup_audio(oArgs):
 def setup_default_video():
     default_video = ["-1"]
     default_video.extend(ts.get_video_indexes())
-    LOG.info(f"Video input choices: {default_video!r}")
+    LOG.info(f"Video input choices: {default_video}")
     video = {'device': -1, 'width': 320, 'height': 240, 'x': 0, 'y': 0}
     video['output_devices'] = default_video
     return video
 
 def main_parser(_=None, iMode=2):
-    import cv2
     if not os.path.exists('/proc/sys/net/ipv6'):
         bIpV6 = 'False'
     else:
@@ -180,9 +194,8 @@ def main_parser(_=None, iMode=2):
     lIpV6Choices=[bIpV6, 'False']
 
     audio = setup_default_audio()
-    default_video = setup_default_video()
+    default_video = setup_default_video()['output_devices']
 
-#    parser = argparse.ArgumentParser()
     parser = ts.oMainArgparser()
     parser.add_argument('--version', action='store_true', help='Prints Toxygen version')
     parser.add_argument('--clean', action='store_true', help='Delete toxcore libs from libs folder')
@@ -227,7 +240,7 @@ def main_parser(_=None, iMode=2):
                         help='Update program (broken)')
     parser.add_argument('--video_input', type=str,
                         default=-1,
-                        choices=default_video['output_devices'],
+                        choices=default_video,
                         help="Video input device number - /dev/video?")
     parser.add_argument('--audio_input', type=str,
                         default=oPYA.get_default_input_device_info()['name'],
@@ -240,10 +253,10 @@ def main_parser(_=None, iMode=2):
     parser.add_argument('--theme', type=str, default='default',
                         choices=['dark', 'default'],
                         help='Theme - style of UI')
-    parser.add_argument('--sleep', type=str, default='time',
+#    parser.add_argument('--sleep', type=str, default='time',
-                        # could expand this to tk, gtk, gevent...
+#                        # could expand this to tk, gtk, gevent...
-                        choices=['qt','gevent','time'],
+#                        choices=['qt','gevent','time'],
-                        help='Sleep method - one of qt, gevent , time')
+#                        help='Sleep method - one of qt, gevent , time')
     supported_languages = settings.supported_languages()
     parser.add_argument('--language', type=str, default='English',
                         choices=supported_languages,
@@ -268,6 +281,8 @@ lKEEP_SETTINGS = ['uri',
                   'ipv6_enabled',
                   'udp_enabled',
                   'local_discovery_enabled',
+                  'trace_enabled',
+
                   'theme',
                   'network',
                   'message_font_size',
@@ -285,9 +300,11 @@ lKEEP_SETTINGS = ['uri',
 
 class A(): pass
 
-def main(lArgs):
+def main(lArgs=None) -> int:
     global oPYA
     from argparse import Namespace
+    if lArgs is None:
+        lArgs = sys.argv[1:]
     parser = main_parser()
     default_ns = parser.parse_args([])
     oArgs = parser.parse_args(lArgs)
@@ -318,6 +335,7 @@ def main(lArgs):
     aArgs = A()
     for key in oArgs.__dict__.keys():
         setattr(aArgs, key, getattr(oArgs, key))
+
     #setattr(aArgs, 'video', setup_video(oArgs))
     aArgs.video = setup_video(oArgs)
     assert 'video' in aArgs.__dict__
@@ -327,10 +345,13 @@ def main(lArgs):
     assert 'audio' in aArgs.__dict__
     oArgs = aArgs
 
-    toxygen = app.App(__version__, oArgs)
+    oApp = app.App(__version__, oArgs)
     # for pyqtconsole
-    __builtins__.app = toxygen
+    try:
-    i = toxygen.iMain()
+        setattr(__builtins__, 'app', oApp)
+    except Exception as e:
+        pass
+    i = oApp.iMain()
     return i
 
 if __name__ == '__main__':

toxygen/app.py

@@ -2,17 +2,21 @@
 import os
 import sys
 import traceback
+import logging
 from random import shuffle
 import threading
 from time import sleep, time
+from copy import deepcopy
 
-from gevent import monkey; monkey.patch_all(); del monkey   # noqa
+# used only in loop
 import gevent
 
-from PyQt5 import QtWidgets, QtGui, QtCore
+from qtpy import QtWidgets, QtGui, QtCore
 from qtpy.QtCore import QTimer
 from qtpy.QtWidgets import QApplication
 
+__version__ = "1.0.0"
+
 try:
     import coloredlogs
     if 'COLOREDLOGS_LEVEL_STYLES' not in os.environ:
@@ -36,7 +40,7 @@ from middleware import threads
 import middleware.callbacks as callbacks
 import updater.updater as updater
 from middleware.tox_factory import tox_factory
-import wrapper.toxencryptsave as tox_encrypt_save
+import toxygen_wrapper.toxencryptsave as tox_encrypt_save
 import user_data.toxes
 from user_data import settings
 from user_data.settings import get_user_config_path, merge_args_into_settings
@@ -74,16 +78,16 @@ from ui.widgets_factory import WidgetsFactory
 from user_data.backup_service import BackupService
 import styles.style  # TODO: dynamic loading
 
-import wrapper_tests.support_testing as ts
+import toxygen_wrapper.tests.support_testing as ts
 
 global LOG
-import logging
 LOG = logging.getLogger('app')
 
 IDLE_PERIOD = 0.10
 iNODES=8
+bSHOW_TRAY=False
 
-def setup_logging(oArgs):
+def setup_logging(oArgs) -> None:
     global LOG
     logging._defaultFormatter = logging.Formatter(datefmt='%m-%d %H:%M:%S',
                                                   fmt='%(levelname)s:%(name)s %(message)s')
@@ -111,7 +115,7 @@ def setup_logging(oArgs):
 
     LOG.setLevel(oArgs.loglevel)
     LOG.trace = lambda l: LOG.log(0, repr(l))
-    LOG.info(f"Setting loglevel to {oArgs.loglevel!s}")
+    LOG.info(f"Setting loglevel to {oArgs.loglevel}")
 
     if oArgs.loglevel < 20:
         # opencv debug
@@ -147,7 +151,6 @@ sSTYLE = """
 .QTextSingleLine {font-family Courier; weight: 75; }
 .QToolBar { font-weight: bold; }
 """
-from copy import deepcopy
 class App:
 
     def __init__(self, version, oArgs):
@@ -162,7 +165,7 @@ class App:
         setup_logging(oArgs)
         # sys.stderr.write( 'Command line args: ' +repr(oArgs) +'\n')
         LOG.info("Command line: " +' '.join(sys.argv[1:]))
-        LOG.debug(f'oArgs = {oArgs!r}')
+        LOG.debug(f'oArgs = {oArgs}')
         LOG.info("Starting toxygen version " +version)
 
         self._version = version
@@ -170,7 +173,8 @@ class App:
         self._app = self._settings = self._profile_manager = None
         self._plugin_loader = self._messenger = None
         self._tox = self._ms = self._init = self._main_loop = self._av_loop = None
-        self._uri = self._toxes = self._tray = self._file_transfer_handler = self._contacts_provider = None
+        self._uri = self._toxes = self._tray = None
+        self._file_transfer_handler = self._contacts_provider = None
         self._friend_factory = self._calls_manager = None
         self._contacts_manager = self._smiley_loader = None
         self._group_peer_factory = self._tox_dns = self._backup_service = None
@@ -178,17 +182,18 @@ class App:
         if uri is not None and uri.startswith('tox:'):
             self._uri = uri[4:]
         self._history = None
+        self.bAppExiting = False
 
     # Public methods
 
-    def set_trace(self):
+    def set_trace(self) -> None:
         """unused"""
         LOG.debug('pdb.set_trace ')
         sys.stdin = sys.__stdin__
         sys.stdout = sys.__stdout__
         import pdb; pdb.set_trace()
 
-    def ten(self, i=0):
+    def ten(self, i=0) -> None:
         """unused"""
         global iI
         iI += 1
@@ -200,14 +205,16 @@ class App:
         #sys.stderr.write(f"ten '+str(iI)+'  {i}"+' '+repr(LOG) +'\n')
         #LOG.debug('ten '+str(iI))
 
-    def iMain(self):
+    def iMain(self) -> int:
         """
         Main function of app. loads login screen if needed and starts main screen
         """
-        self._app = QtWidgets.QApplication([])
+        self._app = QApplication([])
         self._load_icon()
 
-        if util.get_platform() == 'Linux':
+        # is this still needed?
+        if util.get_platform() == 'Linux' and \
+          hasattr(QtCore.Qt, 'AA_X11InitThreads'):
             QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_X11InitThreads)
 
         self._load_base_style()
@@ -223,8 +230,6 @@ class App:
 
             self._load_app_styles()
             if self._args.language != 'English':
-                # > /var/local/src/toxygen/toxygen/app.py(303)_load_app_translations()->None
-                # -> self._app.translator = translator
                 # (Pdb) Fatal Python error: Segmentation fault
                 self._load_app_translations()
             self._create_dependencies()
@@ -234,8 +239,8 @@ class App:
             if self._uri is not None:
                 self._ms.add_contact(self._uri)
         except Exception as e:
-            LOG.error(f"Error loading profile: {e!s}")
+            LOG.error(f"Error loading profile: {e}")
-            sys.stderr.write(' iMain(): ' +f"Error loading profile: {e!s}" \
+            sys.stderr.write(' iMain(): ' +f"Error loading profile: {e}" \
                              +'\n' + traceback.format_exc()+'\n')
             util_ui.message_box(str(e),
                                 util_ui.tr('Error loading profile'))
@@ -255,7 +260,7 @@ class App:
 
     # App executing
 
-    def _execute_app(self):
+    def _execute_app(self) -> None:
         LOG.debug("_execute_app")
 
         while True:
@@ -266,11 +271,11 @@ class App:
             else:
                 break
 
-    def quit(self, retval=0):
+    def quit(self, retval=0) -> None:
         LOG.debug("quit")
         self._stop_app()
 
-        # failsafe: segfaults on exit
+        # failsafe: segfaults on exit - maybe it's Qt
         if hasattr(self, '_tox'):
             if self._tox and hasattr(self._tox, 'kill'):
                 LOG.debug(f"quit: Killing {self._tox}")
@@ -291,10 +296,10 @@ class App:
 
         raise SystemExit(retval)
 
-    def _stop_app(self):
+    def _stop_app(self) -> None:
         LOG.debug("_stop_app")
         self._save_profile()
-        #? self._history.save_history()
+        self._history.save_history()
 
         self._plugin_loader.stop()
         try:
@@ -302,10 +307,16 @@ class App:
         except (Exception, RuntimeError):
             # RuntimeError: cannot join current thread
             pass
+        # I think there are threads still running here leading to a SEGV
+        #   File "/usr/lib/python3.11/threading.py", line 1401 in run
+        #   File "/usr/lib/python3.11/threading.py", line 1045 in _bootstrap_inner
+        #   File "/usr/lib/python3.11/threading.py", line 1002 in _bootstrap
+
         if hasattr(self, '_tray') and self._tray:
             self._tray.hide()
         self._settings.close()
 
+        self.bAppExiting = True
         LOG.debug(f"stop_app: Killing {self._tox}")
         self._kill_toxav()
         self._kill_tox()
@@ -319,7 +330,7 @@ class App:
 
     # App loading
 
-    def _load_base_style(self):
+    def _load_base_style(self) -> None:
         if self._args.theme in ['', 'default']: return
 
         if qdarkstyle:
@@ -339,8 +350,8 @@ class App:
         style += '\n' +sSTYLE
         self._app.setStyleSheet(style)
 
-    def _load_app_styles(self):
+    def _load_app_styles(self) -> None:
-        LOG.debug(f"_load_app_styles {list(settings.built_in_themes().keys())!r}")
+        LOG.debug(f"_load_app_styles {list(settings.built_in_themes().keys())}")
         # application color scheme
         if self._settings['theme'] in ['', 'default']: return
         for theme in settings.built_in_themes().keys():
@@ -369,7 +380,7 @@ class App:
             LOG.info('_load_app_styles: loaded theme ' +self._args.theme)
             break
 
-    def _load_login_screen_translations(self):
+    def _load_login_screen_translations(self) -> None:
         LOG.debug("_load_login_screen_translations")
         current_language, supported_languages = self._get_languages()
         if current_language not in supported_languages:
@@ -380,13 +391,13 @@ class App:
         self._app.installTranslator(translator)
         self._app.translator = translator
 
-    def _load_icon(self):
+    def _load_icon(self) -> None:
         LOG.debug("_load_icon")
         icon_file = os.path.join(util.get_images_directory(), 'icon.png')
         self._app.setWindowIcon(QtGui.QIcon(icon_file))
 
     @staticmethod
-    def _get_languages():
+    def _get_languages() -> tuple:
         LOG.debug("_get_languages")
         current_locale = QtCore.QLocale()
         curr_language = current_locale.languageToString(current_locale.language())
@@ -394,7 +405,7 @@ class App:
 
         return curr_language, supported_languages
 
-    def _load_app_translations(self):
+    def _load_app_translations(self) -> None:
         LOG.debug("_load_app_translations")
         lang = settings.supported_languages()[self._settings['language']]
         translator = QtCore.QTranslator()
@@ -402,13 +413,13 @@ class App:
         self._app.installTranslator(translator)
         self._app.translator = translator
 
-    def _select_and_load_profile(self):
+    def _select_and_load_profile(self) -> bool:
         LOG.debug("_select_and_load_profile: " +repr(self._path))
 
         if self._path is not None:
             # toxygen was started with path to profile
             try:
-                assert os.path.exists(self._path), self._path
+                assert os.path.exists(self._path), f"FNF {self._path}"
                 self._load_existing_profile(self._path)
             except Exception as e:
                 LOG.error('_load_existing_profile failed: ' + str(e))
@@ -460,14 +471,15 @@ class App:
             if not reply:
                 return False
 
-        self._settings.set_active_profile()
+        # is self._path right - was pathless
+        self._settings.set_active_profile(self._path)
 
         return True
 
     # Threads
 
-    def _start_threads(self, initial_start=True):
+    def _start_threads(self, initial_start=True) -> None:
-        LOG.debug(f"_start_threads before: {threading.enumerate()!r}")
+        LOG.debug(f"_start_threads before: {threading.enumerate()}")
         # init thread
         self._init = threads.InitThread(self._tox,
                                         self._plugin_loader,
@@ -476,7 +488,7 @@ class App:
                                         initial_start)
         self._init.start()
         def te(): return [t.name for t in threading.enumerate()]
-        LOG.debug(f"_start_threads init: {te()!r}")
+        LOG.debug(f"_start_threads init: {te()}")
 
         # starting threads for tox iterate and toxav iterate
         self._main_loop = threads.ToxIterateThread(self._tox, app=self)
@@ -487,9 +499,9 @@ class App:
 
         if initial_start:
             threads.start_file_transfer_thread()
-        LOG.debug(f"_start_threads after: {[t.name for t in threading.enumerate()]!r}")
+        LOG.debug(f"_start_threads after: {[t.name for t in threading.enumerate()]}")
 
-    def _stop_threads(self, is_app_closing=True):
+    def _stop_threads(self, is_app_closing=True) -> None:
         LOG.debug("_stop_threads")
         self._init.stop_thread(1.0)
 
@@ -499,11 +511,13 @@ class App:
         if is_app_closing:
             threads.stop_file_transfer_thread()
 
-    def iterate(self, n=100):
+    def iterate(self, n=100) -> None:
         interval = self._tox.iteration_interval()
         for i in range(n):
             self._tox.iterate()
+            # Cooperative yield, allow gevent to monitor file handles via libevent
             gevent.sleep(interval / 1000.0)
+#?            sleep(interval / 1000.0)
 
     # Profiles
 
@@ -518,23 +532,27 @@ class App:
         self._app.exec_()
         return ls.result
 
-    def _load_existing_profile(self, profile_path):
+    def _load_existing_profile(self, profile_path) -> None:
+        profile_path = profile_path.replace('.json', '.tox')
         LOG.info("_load_existing_profile " +repr(profile_path))
         assert os.path.exists(profile_path), profile_path
-        self._profile_manager = ProfileManager(self._toxes, profile_path)
+        self._profile_manager = ProfileManager(self._toxes, profile_path, app=self)
         data = self._profile_manager.open_profile()
         if self._toxes.is_data_encrypted(data):
             LOG.debug("_entering password")
             data = self._enter_password(data)
             LOG.debug("_entered password")
         json_file = profile_path.replace('.tox', '.json')
-        assert os.path.exists(json_file), json_file
+        if os.path.exists(json_file):
-        LOG.debug("creating _settings from: " +json_file)
+            LOG.debug("creating _settings from: " +json_file)
-        self._settings = Settings(self._toxes, json_file, self)
+            self._settings = Settings(self._toxes, json_file, self)
+        else:
+             self._settings = Settings.get_default_settings()
+
         self._tox = self._create_tox(data, self._settings)
         LOG.debug("created _tox")
 
-    def _create_new_profile(self, profile_name):
+    def _create_new_profile(self, profile_name) -> bool:
         LOG.info("_create_new_profile " + profile_name)
         result = self._get_create_profile_screen_result()
         if result is None:
@@ -585,7 +603,7 @@ class App:
 
         return cps.result
 
-    def _save_profile(self, data=None):
+    def _save_profile(self, data=None) -> None:
         LOG.debug("_save_profile")
         data = data or self._tox.get_savedata()
         self._profile_manager.save_profile(data)
@@ -606,7 +624,7 @@ class App:
         self._force_exit(0)
         return None
 
-    def _reset(self):
+    def _reset(self) -> None:
         LOG.debug("_reset")
         """
         Create new tox instance (new network settings)
@@ -646,7 +664,7 @@ class App:
             text = util_ui.tr('Error:') + str(e)
             util_ui.message_box(text, title)
 
-    def _create_dependencies(self):
+    def _create_dependencies(self) -> None:
         LOG.info(f"_create_dependencies toxygen version {self._version}")
         if hasattr(self._args, 'update') and self._args.update:
             self._backup_service = BackupService(self._settings,
@@ -680,7 +698,8 @@ class App:
         self._contacts_provider = ContactProvider(self._tox,
                                                   self._friend_factory,
                                                   self._group_factory,
-                                                  self._group_peer_factory)
+                                                  self._group_peer_factory,
+                                                  app=self)
         self._profile = Profile(self._profile_manager,
                                 self._tox,
                                 self._ms,
@@ -739,7 +758,7 @@ class App:
                                          self._groups_service,
                                          history,
                                          self._contacts_provider)
-        if False:
+        if bSHOW_TRAY:
             self._tray = tray.init_tray(self._profile,
                                         self._settings,
                                         self._ms, self._toxes)
@@ -754,7 +773,7 @@ class App:
                                   self._calls_manager,
                                   self._groups_service, self._toxes, self)
 
-        if False:
+        if bSHOW_TRAY: # broken
             # the tray icon does not die with the app
             self._tray.show()
         self._ms.show()
@@ -792,11 +811,11 @@ class App:
         self._tox = retval
         return retval
 
-    def _force_exit(self, retval=0):
+    def _force_exit(self, retval=0) -> None:
         LOG.debug("_force_exit")
         sys.exit(0)
 
-    def _init_callbacks(self, ms=None):
+    def _init_callbacks(self, ms=None) -> None:
         LOG.debug("_init_callbacks")
         # this will block if you are not connected
         callbacks.init_callbacks(self._tox, self._profile, self._settings,
@@ -807,36 +826,38 @@ class App:
                                  self._messenger, self._groups_service,
                                  self._contacts_provider, self._ms)
 
-    def _init_profile(self):
+    def _init_profile(self) -> None:
         LOG.debug("_init_profile")
         if not self._profile.has_avatar():
             self._profile.reset_avatar(self._settings['identicons'])
 
-    def _kill_toxav(self):
+    def _kill_toxav(self) -> None:
 #        LOG_debug("_kill_toxav")
         self._calls_manager.set_toxav(None)
         self._tox.AV.kill()
 
-    def _kill_tox(self):
+    def _kill_tox(self) -> None:
 #        LOG.debug("_kill_tox")
         self._tox.kill()
 
-    def loop(self, n):
+    def loop(self, n) -> None:
         """
-        Im guessings - there are 3 sleeps - time, tox, and Qt
+        Im guessing - there are 4 sleeps - time, tox, and Qt gevent
         """
         interval = self._tox.iteration_interval()
         for i in range(n):
             self._tox.iterate()
-            QtCore.QThread.msleep(interval)
+            #? QtCore.QThread.msleep(interval)
-            # NO QtCore.QCoreApplication.processEvents()
+            # Cooperative yield, allow gevent to monitor file handles via libevent
-            sleep(interval / 1000.0)
+            gevent.sleep(interval / 1000.0)
+            # NO?
+            QtCore.QCoreApplication.processEvents()
 
-    def _test_tox(self):
+    def _test_tox(self) -> None:
         self.test_net(iMax=8)
         self._ms.log_console()
 
-    def test_net(self, lElts=None, oThread=None, iMax=4):
+    def test_net(self, lElts=None, oThread=None, iMax=4) -> None:
 
         # bootstrap
         LOG.debug('test_net: Calling generate_nodes: udp')
@@ -901,10 +922,9 @@ class App:
             if status > 0:
                 LOG.info(f"Connected # {i}" +' : ' +repr(status))
                 break
-            LOG.trace(f"Connected status #{i}: {status!r}")
+            LOG.trace(f"Connected status #{i}: {status}")
-            self.loop(2)
 
-    def _test_env(self):
+    def _test_env(self) -> None:
         _settings = self._settings
         if 'proxy_type' not in _settings or _settings['proxy_type'] == 0 or \
           not _settings['proxy_host'] or not _settings['proxy_port']:
@@ -927,7 +947,7 @@ class App:
 #        LOG.debug(f"test_env {len(lElts)}")
         return env
 
-    def _test_bootstrap(self, lElts=None):
+    def _test_bootstrap(self, lElts=None) -> None:
         if lElts is None:
             lElts = self._settings['current_nodes_udp']
         LOG.debug(f"_test_bootstrap #Elts={len(lElts)}")
@@ -937,14 +957,14 @@ class App:
         ts.bootstrap_udp(lElts[:iNODES], [self._tox])
         LOG.info("Connected status: " +repr(self._tox.self_get_connection_status()))
 
-    def _test_relays(self, lElts=None):
+    def _test_relays(self, lElts=None) -> None:
         if lElts is None:
             lElts = self._settings['current_nodes_tcp']
         shuffle(lElts)
         LOG.debug(f"_test_relays {len(lElts)}")
         ts.bootstrap_tcp(lElts[:iNODES], [self._tox])
 
-    def _test_nmap(self, lElts=None):
+    def _test_nmap(self, lElts=None) -> None:
         LOG.debug("_test_nmap")
         if not self._tox: return
         title = 'Extended Test Suite'
@@ -978,8 +998,8 @@ class App:
         # LOG.info("Connected status: " +repr(self._tox.self_get_connection_status()))
         self._ms.log_console()
 
-    def _test_main(self):
+    def _test_main(self) -> None:
-        from toxygen_wrapper.wrapper_tests.tests_wrapper import main as tests_main
+        from toxygen_toxygen_wrapper.toxygen_wrapper.tests.tests_wrapper import main as tests_main
         LOG.debug("_test_main")
         if not self._tox: return
         title = 'Extended Test Suite'
@@ -1003,6 +1023,7 @@ class App:
                 util_ui.message_box(text, title)
             self._ms.log_console()
 
+#? unused
 class GEventProcessing:
     """Interoperability class between Qt/gevent that allows processing gevent
     tasks during Qt idle periods."""
@@ -1015,12 +1036,15 @@ class GEventProcessing:
         self._timer = QTimer()
         self._timer.timeout.connect(self.process_events)
         self._timer.start(0)
-    def __enter__(self):
+    def __enter__(self) -> None:
         pass
-    def __exit__(self, *exc_info):
+
+    def __exit__(self, *exc_info) -> None:
         self._timer.stop()
-    def process_events(self, idle_period=None):
+
+    def process_events(self, idle_period=None) -> None:
         if idle_period is None:
             idle_period = self._idle_period
         # Cooperative yield, allow gevent to monitor file handles via libevent
         gevent.sleep(idle_period)
+        #? QtCore.QCoreApplication.processEvents()

toxygen/av/call.py

@@ -1,4 +1,4 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class Call:
 

toxygen/av/calls.py

@@ -1,40 +1,66 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-import pyaudio
 import time
 import threading
+import logging
 import itertools
 
-from wrapper.toxav_enums import *
+from toxygen_wrapper.toxav_enums import *
+from toxygen_wrapper.tests import support_testing as ts
+from toxygen_wrapper.tests.support_testing import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
+
+with ts.ignoreStderr():
+    import pyaudio
 from av import screen_sharing
 from av.call import Call
 import common.tox_save
+from middleware.threads import BaseQThread
 
 from utils import ui as util_ui
-import wrapper_tests.support_testing as ts
 from middleware.threads import invoke_in_main_thread
-from main import sleep
+# from middleware.threads import BaseThread
-from middleware.threads import BaseThread
+
+sleep = time.sleep
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
-# callbacks can be called in any thread so were being careful
-def LOG_ERROR(l): print('EROR< '+l)
-def LOG_WARN(l):  print('WARN< '+l)
-def LOG_INFO(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 20-1
-    if bIsVerbose: print('INFO< '+l)
-def LOG_DEBUG(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 10-1
-    if bIsVerbose: print('DBUG< '+l)
-def LOG_TRACE(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel < 10-1
-    pass # print('TRACE+ '+l)
 
 TIMER_TIMEOUT = 30.0
-bSTREAM_CALLBACK = False
 iFPS = 25
 
+class AudioThread(BaseQThread):
+    def __init__(self, av, name=''):
+        super().__init__()
+        self.av = av
+        self._name = name
+
+    def join(self, ito=ts.iTHREAD_TIMEOUT):
+        LOG_DEBUG(f"AudioThread join {self}")
+        # dunno
+
+    def run(self) -> None:
+        LOG_DEBUG('AudioThread run: ')
+        # maybe not needed
+        while not self._stop_thread:
+            self.av.send_audio()
+            sleep(100.0 / 1000.0)
+
+class VideoThread(BaseQThread):
+    def __init__(self, av, name=''):
+        super().__init__()
+        self.av = av
+        self._name = name
+
+    def join(self, ito=ts.iTHREAD_TIMEOUT):
+        LOG_DEBUG(f"VideoThread join {self}")
+        # dunno
+
+    def run(self) -> None:
+        LOG_DEBUG('VideoThread run: ')
+        # maybe not needed
+        while not self._stop_thread:
+            self.av.send_video()
+            sleep(100.0 / 1000.0)
+
 class AV(common.tox_save.ToxAvSave):
 
     def __init__(self, toxav, settings):
@@ -45,10 +71,10 @@ class AV(common.tox_save.ToxAvSave):
         s = settings
         if 'video' not in s:
             LOG.warn("AV.__init__ 'video' not in s" )
-            LOG.debug(f"AV.__init__ {s!r}" )
+            LOG.debug(f"AV.__init__ {s}" )
         elif 'device' not in s['video']:
             LOG.warn("AV.__init__ 'device' not in s.video" )
-            LOG.debug(f"AV.__init__ {s['video']!r}" )
+            LOG.debug(f"AV.__init__ {s['video']}" )
 
         self._calls = {}  # dict: key - friend number, value - Call instance
 
@@ -80,15 +106,17 @@ class AV(common.tox_save.ToxAvSave):
         self.lPaSampleratesI = ts.lSdSamplerates(iInput)
         iOutput = self._settings['audio']['output']
         self.lPaSampleratesO = ts.lSdSamplerates(iOutput)
+
         global oPYA
         oPYA = self._audio = pyaudio.PyAudio()
 
-    def stop(self):
+    def stop(self) -> None:
+        LOG_DEBUG(f"AV.CA stop {self._video_thread}")
         self._running = False
         self.stop_audio_thread()
         self.stop_video_thread()
 
-    def __contains__(self, friend_number):
+    def __contains__(self, friend_number:int) -> bool:
         return friend_number in self._calls
 
     # Calls
@@ -114,11 +142,12 @@ class AV(common.tox_save.ToxAvSave):
 
     def accept_call(self, friend_number, audio_enabled, video_enabled):
         # obsolete
-        return self.call_accept_call(friend_number, audio_enabled, video_enabled)
+        self.call_accept_call(friend_number, audio_enabled, video_enabled)
 
-    def call_accept_call(self, friend_number, audio_enabled, video_enabled):
+    def call_accept_call(self, friend_number, audio_enabled, video_enabled) -> None:
-        LOG.debug(f"call_accept_call from {friend_number} {self._running}" +
+        # called from CM.accept_call in a try:
-                  f"{audio_enabled} {video_enabled}")
+        LOG.debug(f"call_accept_call from F={friend_number} R={self._running}" +
+                  f" A={audio_enabled} V={video_enabled}")
         # import pdb; pdb.set_trace() - gets into q Qt exec_ problem
         # ts.trepan_handler()
 
@@ -132,21 +161,19 @@ class AV(common.tox_save.ToxAvSave):
                 self._toxav.answer(friend_number,
                                    self._audio_krate_tox_audio if audio_enabled else 0,
                                    self._audio_krate_tox_video if video_enabled else 0)
-            except ArgumentError as e:
+            except Exception as e:
-                LOG.debug(f"AV accept_call error from {friend_number} {self._running}" +
+                LOG.error(f"AV accept_call error from {friend_number} {self._running} {e}")
-                          f"{e}")
                 raise
-            if audio_enabled:
-                # may raise
-                self.start_audio_thread()
             if video_enabled:
                 # may raise
                 self.start_video_thread()
+            if audio_enabled:
+                LOG.debug(f"calls accept_call calling start_audio_thread F={friend_number}")
+                # may raise
+                self.start_audio_thread()
 
-    def finish_call(self, friend_number, by_friend=False):
+    def finish_call(self, friend_number, by_friend=False) -> None:
         LOG.debug(f"finish_call  {friend_number}")
-        if not by_friend:
-            self._toxav.call_control(friend_number, TOXAV_CALL_CONTROL['CANCEL'])
         if friend_number in self._calls:
             del self._calls[friend_number]
         try:
@@ -160,14 +187,18 @@ class AV(common.tox_save.ToxAvSave):
             # dunno
             self.stop_audio_thread()
             self.stop_video_thread()
+        if not by_friend:
+            LOG.debug(f"finish_call before call_control {friend_number}")
+            self._toxav.call_control(friend_number, TOXAV_CALL_CONTROL['CANCEL'])
+            LOG.debug(f"finish_call after call_control {friend_number}")
 
-    def finish_not_started_call(self, friend_number):
+    def finish_not_started_call(self, friend_number:int) -> None:
         if friend_number in self:
             call = self._calls[friend_number]
             if not call.is_active:
                 self.finish_call(friend_number)
 
-    def toxav_call_state_cb(self, friend_number, state):
+    def toxav_call_state_cb(self, friend_number, state) -> None:
         """
         New call state
         """
@@ -184,16 +215,17 @@ class AV(common.tox_save.ToxAvSave):
         if state | TOXAV_FRIEND_CALL_STATE['ACCEPTING_V'] and call.out_video:
             self.start_video_thread()
 
-    def is_video_call(self, number):
+    def is_video_call(self, number) -> bool:
         return number in self and self._calls[number].in_video
 
     # Threads
 
-    def start_audio_thread(self):
+    def start_audio_thread(self, bSTREAM_CALLBACK=False) -> None:
         """
         Start audio sending
         from a callback
         """
+        # called from call_accept_call in an try: from CM.accept_call
         global oPYA
         # was iInput = self._settings._args.audio['input']
         iInput = self._settings['audio']['input']
@@ -201,29 +233,39 @@ class AV(common.tox_save.ToxAvSave):
             LOG_WARN(f"start_audio_thread device={iInput}")
             return
         LOG_DEBUG(f"start_audio_thread device={iInput}")
-        lPaSamplerates = ts.lSdSamplerates(iInput)
+        lPaSamplerates =  ts.lSdSamplerates(iInput)
         if not(len(lPaSamplerates)):
-            e = f"No supported sample rates for device: audio[input]={iInput!r}"
+            e = f"No sample rates for device: audio[input]={iInput}"
-            LOG_ERROR(f"start_audio_thread {e}")
+            LOG_WARN(f"start_audio_thread {e}")
-            #?? dunno - cancel call?
+            #?? dunno - cancel call? - no let the user do it
-            return
+            # return
-        if not self._audio_rate_pa in lPaSamplerates:
+            # just guessing  here in case that's a false negative
-            LOG_WARN(f"{self._audio_rate_pa} not in {lPaSamplerates!r}")
+            lPaSamplerates = [round(oPYA.get_device_info_by_index(iInput)['defaultSampleRate'])]
-            if False:
+        if lPaSamplerates and self._audio_rate_pa in lPaSamplerates:
-                self._audio_rate_pa = oPYA.get_device_info_by_index(iInput)['defaultSampleRate']
+            pass
-            else:
+        elif lPaSamplerates:
-                LOG_WARN(f"Setting audio_rate to: {lPaSamplerates[0]}")
+            LOG_WARN(f"Setting audio_rate to: {lPaSamplerates[0]}")
-                self._audio_rate_pa = lPaSamplerates[0]
+            self._audio_rate_pa = lPaSamplerates[0]
-
+        elif 'defaultSampleRate' in oPYA.get_device_info_by_index(iInput):
+            self._audio_rate_pa = oPYA.get_device_info_by_index(iInput)['defaultSampleRate']
+            LOG_WARN(f"setting to defaultSampleRate")
+        else:
+            LOG_WARN(f"{self._audio_rate_pa} not in {lPaSamplerates}")
+        # a float is in here - must it be int?
+        if type(self._audio_rate_pa) == float:
+            self._audio_rate_pa = round(self._audio_rate_pa)
         try:
-            LOG_DEBUG( f"start_audio_thread framerate: {self._audio_rate_pa}" \
-                     +f" device: {iInput}"
-                     +f" supported: {lPaSamplerates!r}")
             if self._audio_rate_pa not in lPaSamplerates:
                 LOG_WARN(f"PAudio sampling rate was {self._audio_rate_pa} changed to {lPaSamplerates[0]}")
+                LOG_DEBUG(f"lPaSamplerates={lPaSamplerates}")
                 self._audio_rate_pa = lPaSamplerates[0]
+            else:
+                LOG_DEBUG( f"start_audio_thread framerate: {self._audio_rate_pa}" \
+                        +f" device: {iInput}"
+                        +f" supported: {lPaSamplerates}")
 
             if bSTREAM_CALLBACK:
+                # why would you not call a thread?
                 self._audio_stream = oPYA.open(format=pyaudio.paInt16,
                                                rate=self._audio_rate_pa,
                                                channels=self._audio_channels,
@@ -237,8 +279,8 @@ class AV(common.tox_save.ToxAvSave):
                     sleep(0.1)
                 self._audio_stream.stop_stream()
                 self._audio_stream.close()
-
             else:
+                LOG_DEBUG( f"start_audio_thread starting thread {self._audio_rate_pa}")
                 self._audio_stream = oPYA.open(format=pyaudio.paInt16,
                                                rate=self._audio_rate_pa,
                                                channels=self._audio_channels,
@@ -246,30 +288,35 @@ class AV(common.tox_save.ToxAvSave):
                                                input_device_index=iInput,
                                                frames_per_buffer=self._audio_sample_count_pa * 10)
                 self._audio_running = True
-                self._audio_thread = BaseThread(target=self.send_audio,
+                self._audio_thread = AudioThread(self,
-                                                      name='_audio_thread')
+                                                name='_audio_thread')
                 self._audio_thread.start()
+                LOG_DEBUG( f"start_audio_thread started thread name='_audio_thread'")
 
         except Exception as e:
-            LOG.error(f"Starting self._audio.open {e}")
+            LOG_ERROR(f"Starting self._audio.open {e}")
-            LOG.debug(repr(dict(format=pyaudio.paInt16,
+            LOG_DEBUG(repr(dict(format=pyaudio.paInt16,
                                 rate=self._audio_rate_pa,
                                 channels=self._audio_channels,
                                 input=True,
                                 input_device_index=iInput,
                                 frames_per_buffer=self._audio_sample_count_pa * 10)))
-            # catcher in place in calls_manager? not if from a callback
+            # catcher in place in calls_manager? yes accept_call
             # calls_manager._call.toxav_call_state_cb(friend_number, mask)
-            # raise RuntimeError(e)
+            invoke_in_main_thread(util_ui.message_box,
+                                  str(e),
+                                  util_ui.tr("Starting self._audio.open"))
             return
         else:
-            LOG_DEBUG(f"start_audio_thread {self._audio_stream!r}")
+            LOG_DEBUG(f"start_audio_thread {self._audio_stream}")
 
-    def stop_audio_thread(self):
+    def stop_audio_thread(self) -> None:
+        LOG_DEBUG(f"stop_audio_thread {self._audio_stream}")
 
         if self._audio_thread is None:
             return
         self._audio_running = False
+        self._audio_thread._stop_thread = True
 
         self._audio_thread = None
         self._audio_stream = None
@@ -280,30 +327,29 @@ class AV(common.tox_save.ToxAvSave):
             self._out_stream.close()
             self._out_stream = None
 
-    def start_video_thread(self):
+    def start_video_thread(self) -> None:
         if self._video_thread is not None:
             return
         s = self._settings
         if 'video' not in s:
             LOG.warn("AV.__init__ 'video' not in s" )
-            LOG.debug(f"start_video_thread {s!r}" )
+            LOG.debug(f"start_video_thread {s}" )
             raise RuntimeError("start_video_thread not 'video' in s)" )
-        elif 'device' not in s['video']:
+        if 'device' not in s['video']:
             LOG.error("start_video_thread not 'device' in s['video']" )
-            LOG.debug(f"start_video_thread {s['video']!r}" )
+            LOG.debug(f"start_video_thread {s['video']}" )
             raise RuntimeError("start_video_thread not 'device' ins s['video']" )
         self._video_width = s['video']['width']
         self._video_height = s['video']['height']
 
         # dunno
-        if True or s['video']['device'] == -1:
+        if s['video']['device'] == -1:
             self._video = screen_sharing.DesktopGrabber(s['video']['x'],
                                                         s['video']['y'],
                                                         s['video']['width'],
                                                         s['video']['height'])
         else:
-            with ts.ignoreStdout():
+            with ts.ignoreStdout(): import cv2
-                import cv2
             if s['video']['device'] == 0:
                 # webcam
                 self._video = cv2.VideoCapture(s['video']['device'], cv2.DSHOW)
@@ -323,14 +369,16 @@ class AV(common.tox_save.ToxAvSave):
                  +f" supported: {s['video']['width']} {s['video']['height']}")
 
         self._video_running = True
-        self._video_thread = BaseThread(target=self.send_video,
+        self._video_thread = VideoThread(self,
                                         name='_video_thread')
         self._video_thread.start()
 
-    def stop_video_thread(self):
+    def stop_video_thread(self) -> None:
+        LOG_DEBUG(f"stop_video_thread {self._video_thread}")
         if self._video_thread is None:
             return
 
+        self._video_thread._stop_thread = True
         self._video_running = False
         i = 0
         while i < ts.iTHREAD_JOINS:
@@ -338,30 +386,37 @@ class AV(common.tox_save.ToxAvSave):
             try:
                 if not self._video_thread.is_alive(): break
             except:
-                # AttributeError: 'NoneType' object has no attribute 'join'
                 break
             i = i + 1
         else:
             LOG.warn("self._video_thread.is_alive BLOCKED")
         self._video_thread = None
         self._video = None
-
     # Incoming chunks
 
-    def audio_chunk(self, samples, channels_count, rate):
+    def audio_chunk(self, samples, channels_count, rate) -> None:
         """
         Incoming chunk
         """
-
+        # from callback
         if self._out_stream is None:
             # was iOutput = self._settings._args.audio['output']
             iOutput = self._settings['audio']['output']
-            if not rate in self.lPaSampleratesO:
+            if self.lPaSampleratesO and rate in self.lPaSampleratesO:
-                LOG.warn(f"{rate} not in {self.lPaSampleratesO!r}")
+                LOG_DEBUG(f"Using rate {rate} in self.lPaSampleratesO")
-                if False:
+            elif self.lPaSampleratesO:
-                    rate = oPYA.get_device_info_by_index(iOutput)['defaultSampleRate']
+                LOG_WARN(f"{rate} not in {self.lPaSampleratesO}")
-                LOG.warn(f"Setting audio_rate to: {self.lPaSampleratesO[0]}")
+                LOG_WARN(f"Setting audio_rate to: {self.lPaSampleratesO[0]}")
                 rate = self.lPaSampleratesO[0]
+            elif 'defaultSampleRate' in oPYA.get_device_info_by_index(iOutput):
+                rate = round(oPYA.get_device_info_by_index(iOutput)['defaultSampleRate'])
+                LOG_WARN(f"Setting rate to {rate} empty self.lPaSampleratesO")
+            else:
+                LOG_WARN(f"Using rate {rate} empty self.lPaSampleratesO")
+            if type(rate) == float:
+                rate = round(rate)
+            # test output device?
+            # [Errno -9985] Device unavailable
             try:
                 with ts.ignoreStderr():
                     self._out_stream = oPYA.open(format=pyaudio.paInt16,
@@ -370,54 +425,61 @@ class AV(common.tox_save.ToxAvSave):
                                                  output_device_index=iOutput,
                                                  output=True)
             except Exception as e:
-                LOG.error(f"Error playing audio_chunk creating self._out_stream   {e}")
+                LOG_ERROR(f"Error playing audio_chunk creating self._out_stream  output_device_index={iOutput} {e}")
                 invoke_in_main_thread(util_ui.message_box,
-                                    str(e),
+                                      str(e),
-                                    util_ui.tr("Error Chunking audio"))
+                                      util_ui.tr("Error Chunking audio"))
                 # dunno
                 self.stop()
                 return
 
         iOutput = self._settings['audio']['output']
-        LOG.debug(f"audio_chunk output_device_index={iOutput} rate={rate} channels={channels_count}")
+#trace        LOG_DEBUG(f"audio_chunk output_device_index={iOutput} rate={rate} channels={channels_count}")
-        self._out_stream.write(samples)
+        try:
+            self._out_stream.write(samples)
+        except Exception as e:
+            # OSError: [Errno -9999] Unanticipated host error
+            LOG_WARN(f"audio_chunk output_device_index={iOutput} {e}")
 
     # AV sending
 
-    def send_audio_data(self, data, count, *largs, **kwargs):
+    def send_audio_data(self, data, count, *largs, **kwargs) -> None:
+        # callback
         pcm = data
         # :param sampling_rate: Audio sampling rate used in this frame.
-        if self._toxav is None:
+        try:
-            raise RuntimeError("_toxav not initialized")
+            if self._toxav is None:
-        if self._audio_rate_tox not in ts.lToxSamplerates:
+                LOG_ERROR("_toxav not initialized")
-            LOG.warn(f"ToxAudio sampling rate was {self._audio_rate_tox} changed to {ts.lToxSamplerates[0]}")
+                return
-            self._audio_rate_tox = ts.lToxSamplerates[0]
+            if self._audio_rate_tox not in ts.lToxSamplerates:
+                LOG_WARN(f"ToxAudio sampling rate was {self._audio_rate_tox} changed to {ts.lToxSamplerates[0]}")
+                self._audio_rate_tox = ts.lToxSamplerates[0]
 
-        for friend_num in self._calls:
+            for friend_num in self._calls:
-            if self._calls[friend_num].out_audio:
+                if self._calls[friend_num].out_audio:
-                try:
-                    # app.av.calls ERROR Error send_audio:   One of the frame parameters was invalid. E.g. the resolution may be too small or too large, or the audio sampling rate may be unsupported
                     # app.av.calls ERROR Error send_audio audio_send_frame: This client is currently not in a call with the friend.
                     self._toxav.audio_send_frame(friend_num,
                                                  pcm,
                                                  count,
                                                  self._audio_channels,
                                                  self._audio_rate_tox)
-                except Exception as e:
-                   LOG.error(f"Error send_audio audio_send_frame: {e}")
-                   LOG.debug(f"send_audio self._audio_rate_tox={self._audio_rate_tox} self._audio_channels={self._audio_channels}")
-#                   invoke_in_main_thread(util_ui.message_box,
-#                                    str(e),
-#                                    util_ui.tr("Error send_audio audio_send_frame"))
-                   pass
 
-    def send_audio(self):
+        except Exception as e:
+           LOG.error(f"Error send_audio_data audio_send_frame: {e}")
+           LOG.debug(f"send_audio_data self._audio_rate_tox={self._audio_rate_tox} self._audio_channels={self._audio_channels}")
+           self.stop_audio_thread()
+           invoke_in_main_thread(util_ui.message_box,
+                            str(e),
+                            util_ui.tr("Error send_audio_data audio_send_frame"))
+           #? stop ? endcall?
+
+    def send_audio(self) -> None:
         """
         This method sends audio to friends
         """
         i=0
         count = self._audio_sample_count_tox
-        LOG.debug(f"send_audio stream={self._audio_stream}")
+        LOG_DEBUG(f"send_audio stream={self._audio_stream}")
         while self._audio_running:
             try:
                 pcm = self._audio_stream.read(count, exception_on_overflow=False)
@@ -432,48 +494,48 @@ class AV(common.tox_save.ToxAvSave):
             i += 1
             sleep(0.01)
 
-    def send_video(self):
+    def send_video(self) -> None:
         """
         This method sends video to friends
         """
-        LOG.debug(f"send_video thread={threading.current_thread().name}"
+#        LOG_DEBUG(f"send_video thread={threading.current_thread().name}"
-                  +f" self._video_running={self._video_running}"
+#                  +f" self._video_running={self._video_running}"
-                  +f" device: {self._settings['video']['device']}" )
+#                  +f" device: {self._settings['video']['device']}" )
         while self._video_running:
             try:
                 result, frame = self._video.read()
                 if not result:
-                    LOG.warn(f"send_video video_send_frame _video.read result={result}")
+                    LOG_WARN(f"send_video video_send_frame _video.read result={result}")
                     break
                 if frame is None:
-                    LOG.warn(f"send_video video_send_frame _video.read result={result} frame={frame}")
+                    LOG_WARN(f"send_video video_send_frame _video.read result={result} frame={frame}")
                     continue
+
+                LOG_TRACE(f"send_video video_send_frame _video.read result={result}")
+                height, width, channels = frame.shape
+                friends = []
+                for friend_num in self._calls:
+                    if self._calls[friend_num].out_video:
+                        friends.append(friend_num)
+                if len(friends) == 0:
+                    LOG_WARN(f"send_video video_send_frame no friends")
                 else:
-                    LOG_TRACE(f"send_video video_send_frame _video.read result={result}")
+                    LOG_TRACE(f"send_video video_send_frame {friends}")
-                    height, width, channels = frame.shape
+                    friend_num = friends[0]
-                    friends = []
+                    try:
-                    for friend_num in self._calls:
+                        y, u, v = self.convert_bgr_to_yuv(frame)
-                        if self._calls[friend_num].out_video:
+                        self._toxav.video_send_frame(friend_num, width, height, y, u, v)
-                            friends.append(friend_num)
+                    except Exception as e:
-                    if len(friends) == 0:
+                        LOG_WARN(f"send_video video_send_frame ERROR {e}")
-                        LOG.warn(f"send_video video_send_frame no friends")
+                        pass
-                    else:
-                        LOG_TRACE(f"send_video video_send_frame {friends}")
-                        friend_num = friends[0]
-                        try:
-                            y, u, v = self.convert_bgr_to_yuv(frame)
-                            self._toxav.video_send_frame(friend_num, width, height, y, u, v)
-                        except Exception as e:
-                            LOG.debug(f"send_video video_send_frame ERROR {e}")
-                            pass
 
             except Exception as e:
-                LOG.error(f"send_video video_send_frame {e}")
+                LOG_ERROR(f"send_video video_send_frame {e}")
                 pass
 
             sleep( 1.0/iFPS)
 
-    def convert_bgr_to_yuv(self, frame):
+    def convert_bgr_to_yuv(self, frame) -> tuple:
         """
         :param frame: input bgr frame
         :return y, u, v: y, u, v values of frame
@@ -512,11 +574,12 @@ class AV(common.tox_save.ToxAvSave):
         y = list(itertools.chain.from_iterable(y))
 
         import numpy as np
-        u = np.zeros((self._video_height // 2, self._video_width // 2), dtype=np.int)
+        # was np.int
+        u = np.zeros((self._video_height // 2, self._video_width // 2), dtype=np.int32)
         u[::2, :] = frame[self._video_height:self._video_height * 5 // 4, :self._video_width // 2]
         u[1::2, :] = frame[self._video_height:self._video_height * 5 // 4, self._video_width // 2:]
         u = list(itertools.chain.from_iterable(u))
-        v = np.zeros((self._video_height // 2, self._video_width // 2), dtype=np.int)
+        v = np.zeros((self._video_height // 2, self._video_width // 2), dtype=np.int32)
         v[::2, :] = frame[self._video_height * 5 // 4:, :self._video_width // 2]
         v[1::2, :] = frame[self._video_height * 5 // 4:, self._video_width // 2:]
         v = list(itertools.chain.from_iterable(v))

toxygen/av/calls_manager.py

@@ -2,15 +2,19 @@
 
 import sys
 import threading
+import traceback
+import logging
+
+from  qtpy import QtCore
 
 import av.calls
 from messenger.messages import *
 from ui import av_widgets
 import common.event as event
 import utils.ui as util_ui
+from toxygen_wrapper.tests import support_testing as ts
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 
 class CallsManager:
@@ -27,7 +31,7 @@ class CallsManager:
         self._call_finished_event = event.Event()  # friend_number, is_declined
         self._app = app
 
-    def set_toxav(self, toxav):
+    def set_toxav(self, toxav) -> None:
         self._callav.set_toxav(toxav)
 
     # Events
@@ -44,7 +48,7 @@ class CallsManager:
 
     # AV support
 
-    def call_click(self, audio=True, video=False):
+    def call_click(self, audio=True, video=False) -> None:
         """User clicked audio button in main window"""
         num = self._contacts_manager.get_active_number()
         if not self._contacts_manager.is_active_a_friend():
@@ -58,11 +62,11 @@ class CallsManager:
         elif num in self._callav:  # finish or cancel call if you call with active friend
             self.stop_call(num, False)
 
-    def incoming_call(self, audio, video, friend_number):
+    def incoming_call(self, audio, video, friend_number) -> None:
         """
         Incoming call from friend.
         """
-        LOG.debug(__name__ +f" incoming_call  {friend_number}")
+        LOG.debug(f"CM incoming_call  {friend_number}")
         # if not self._settings['audio']['enabled']: return
         friend = self._contacts_manager.get_friend_by_number(friend_number)
         self._call_started_event(friend_number, audio, video, False)
@@ -76,19 +80,27 @@ class CallsManager:
         self._call_widgets[friend_number].set_pixmap(friend.get_pixmap())
         self._call_widgets[friend_number].show()
 
-    def accept_call(self, friend_number, audio, video):
+    def accept_call(self, friend_number, audio, video) -> None:
         """
         Accept incoming call with audio or video
         Called from a thread
         """
 
-        LOG.debug(f"CM accept_call from {friend_number} {audio} {video}")
+        LOG.debug(f"CM accept_call from friend_number={friend_number} {audio} {video}")
         sys.stdout.flush()
 
         try:
+            self._main_screen.active_call()
+            # failsafe added somewhere this was being left up
+            self.close_call(friend_number)
+            QtCore.QCoreApplication.processEvents()
+
             self._callav.call_accept_call(friend_number, audio, video)
+            LOG.debug(f"accept_call _call.accept_call CALLED f={friend_number}")
         except Exception as e:
+            #
             LOG.error(f"accept_call _call.accept_call ERROR for {friend_number} {e}")
+            LOG.debug(traceback.print_exc())
             self._main_screen.call_finished()
             if hasattr(self._main_screen, '_settings') and \
               'audio' in self._main_screen._settings and \
@@ -100,58 +112,69 @@ class CallsManager:
             elif hasattr(self._main_screen, '_settings') and \
               hasattr(self._main_screen._settings, 'audio') and \
               'input' not in self._main_screen._settings['audio']:
-                LOG.warn(f"'audio' not in {self._main_screen._settings!r}")
+                LOG.warn(f"'audio' not in {self._main_screen._settings}")
             elif hasattr(self._main_screen, '_settings') and \
               hasattr(self._main_screen._settings, 'audio') and \
               'input' not in self._main_screen._settings['audio']:
-                LOG.warn(f"'audio' not in {self._main_screen._settings!r}")
+                LOG.warn(f"'audio' not in {self._main_screen._settings}")
             else:
                 LOG.warn(f"_settings not in self._main_screen")
             util_ui.message_box(str(e),
                             util_ui.tr('ERROR Accepting call from {friend_number}'))
-        else:
-            self._main_screen.active_call()
-
         finally:
             # does not terminate call - just the av_widget
-            if friend_number in self._incoming_calls:
+            LOG.debug(f"CM.accept_call close av_widget")
-                self._incoming_calls.remove(friend_number)
+            self.close_call(friend_number)
-            try:
-                self._call_widgets[friend_number].close()
-                del self._call_widgets[friend_number]
-            except:
-                # RuntimeError: wrapped C/C++ object of type IncomingCallWidget has been deleted
-
-                pass
             LOG.debug(f" closed self._call_widgets[{friend_number}]")
 
-    def stop_call(self, friend_number, by_friend):
+    def close_call(self, friend_number:int) -> None:
+        # refactored out from above because the accept window not getting
+        # taken down in some accept audio calls
+        LOG.debug(f"close_call {friend_number}")
+        try:
+            if friend_number in self._call_widgets:
+                self._call_widgets[friend_number].close()
+                del self._call_widgets[friend_number]
+            if friend_number in self._incoming_calls:
+                self._incoming_calls.remove(friend_number)
+        except Exception as e:
+            # RuntimeError: wrapped C/C++ object of type IncomingCallWidget has been deleted
+
+            LOG.warn(f" closed self._call_widgets[{friend_number}] {e}")
+        # invoke_in_main_thread(QtCore.QCoreApplication.processEvents)
+        QtCore.QCoreApplication.processEvents()
+
+
+    def stop_call(self, friend_number, by_friend) -> None:
         """
         Stop call with friend
         """
-        LOG.debug(__name__+f" stop_call {friend_number}")
+        LOG.debug(f"CM.stop_call friend={friend_number}")
         if friend_number in self._incoming_calls:
             self._incoming_calls.remove(friend_number)
             is_declined = True
         else:
             is_declined = False
+        if friend_number in self._call_widgets:
+            LOG.debug(f"CM.stop_call _call_widgets close")
+            self.close_call(friend_number)
+
+        LOG.debug(f"CM.stop_call _main_screen.call_finished")
         self._main_screen.call_finished()
         self._callav.finish_call(friend_number, by_friend)  # finish or decline call
-        if friend_number in self._call_widgets:
+        is_video = self._callav.is_video_call(friend_number)
-            self._call_widgets[friend_number].close()
+        if is_video:
-            del self._call_widgets[friend_number]
+            def destroy_window():
-
+                #??? FixMe
-        def destroy_window():
+                with ts.ignoreStdout(): import cv2
-            #??? FixMed
-            is_video = self._callav.is_video_call(friend_number)
-            if is_video:
-                import cv2
                 cv2.destroyWindow(str(friend_number))
+            LOG.debug(f"CM.stop_call destroy_window")
+            threading.Timer(2.0, destroy_window).start()
 
-        threading.Timer(2.0, destroy_window).start()
+        LOG.debug(f"CM.stop_call _call_finished_event")
         self._call_finished_event(friend_number, is_declined)
 
-    def friend_exit(self, friend_number):
+    def friend_exit(self, friend_number:int) -> None:
         if friend_number in self._callav:
             self._callav.finish_call(friend_number, True)
 

toxygen/av/screen_sharing.py

@@ -1,5 +1,6 @@
-from PyQt5 import QtWidgets
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
+from  qtpy import QtWidgets
 
 class DesktopGrabber:
 
@@ -12,7 +13,7 @@ class DesktopGrabber:
         self._height -= height % 4
         self._screen = QtWidgets.QApplication.primaryScreen()
 
-    def read(self):
+    def read(self) -> tuple:
         pixmap = self._screen.grabWindow(0, self._x, self._y, self._width, self._height)
         image = pixmap.toImage()
         s = image.bits().asstring(self._width * self._height * 4)

toxygen/bootstrap/bootstrap.py

@@ -1,9 +1,8 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 import random
-import urllib.request
+import logging
-from utils.util import *
+
-from PyQt5 import QtNetwork
+from  qtpy import QtCore
-from PyQt5 import QtCore
 try:
     import certifi
     from io import BytesIO
@@ -11,15 +10,16 @@ except ImportError:
     certifi = None
 
 from user_data.settings import get_user_config_path
-from wrapper_tests.support_testing import _get_nodes_path
+from utils.util import *
-from wrapper_tests.support_http import download_url
+
-import wrapper_tests.support_testing as ts
+from toxygen_wrapper.tests.support_testing import _get_nodes_path
+from toxygen_wrapper.tests.support_http import download_url
+import toxygen_wrapper.tests.support_testing as ts
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+'bootstrap')
 
-def download_nodes_list(settings, oArgs):
+def download_nodes_list(settings, oArgs) -> str:
     if not settings['download_nodes_list']:
         return ''
     if not ts.bAreWeConnected():
@@ -40,7 +40,7 @@ def download_nodes_list(settings, oArgs):
     _save_nodes(result, settings._app)
     return result
 
-def _save_nodes(nodes, app):
+def _save_nodes(nodes, app) -> None:
     if not nodes:
         return
     with open(_get_nodes_path(app._args), 'wb') as fl:

toxygen/common/event.py

@@ -1,4 +1,4 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class Event:
 

toxygen/common/provider.py

@@ -1,4 +1,4 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class Provider:
 

toxygen/common/tox_save.py

@@ -1,4 +1,4 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class ToxSave:
 

toxygen/contacts/basecontact.py

@@ -1,7 +1,7 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 from user_data.settings import *
-from PyQt5 import QtCore, QtGui
+from  qtpy import QtCore, QtGui
-from wrapper.toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
+from toxygen_wrapper.toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
 import utils.util as util
 import common.event as event
 import contacts.common as common
@@ -117,7 +117,7 @@ class BaseContact:
             self._avatar_changed_event(avatar_path)
         except Exception as e:
             pass
-        
+
     def reset_avatar(self, generate_new):
         avatar_path = self.get_avatar_path()
         if os.path.isfile(avatar_path) and not avatar_path == self._get_default_avatar_path():
@@ -161,6 +161,12 @@ class BaseContact:
     # Widgets
 
     def init_widget(self):
+        # File "/mnt/o/var/local/src/toxygen/toxygen/contacts/contacts_manager.py", line 252, in filtration_and_sorting
+        # contact.set_widget(item_widget)
+        # File "/mnt/o/var/local/src/toxygen/toxygen/contacts/contact.py", line 320, in set_widget
+        if not self._widget:
+            LOG.warn("BC.init_widget self._widget is NULL")
+            return
         self._widget.name.setText(self._name)
         self._widget.status_message.setText(self._status_message)
         if hasattr(self._widget, 'kind'):

toxygen/contacts/common.py

@@ -1,6 +1,8 @@
-from pydenticon import Generator
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import hashlib
 
+from pydenticon import Generator
 
 # Typing notifications
 
@@ -17,7 +19,7 @@ class BaseTypingNotificationHandler:
 
 class FriendTypingNotificationHandler(BaseTypingNotificationHandler):
 
-    def __init__(self, friend_number):
+    def __init__(self, friend_number:int):
         super().__init__()
         self._friend_number = friend_number
 

toxygen/contacts/contact.py

@@ -134,7 +134,7 @@ class Contact(basecontact.BaseContact):
         """
 #                               and m.tox_message_id == tox_message_id,
         messages = filter(lambda m: m.author is not None
-                              and m.author.type == MESSAGE_AUTHOR['NOT_SENT']
+                              and m.author.type == MESSAGE_AUTHOR['NOT_SENT'],
                               self._corr)
         # was message = list(...)[0]
         return list(messages)
@@ -146,7 +146,7 @@ class Contact(basecontact.BaseContact):
             message.mark_as_sent()
         except Exception as ex:
             #   wrapped C/C++ object of type QLabel has been deleted
-            LOG.error(f"Mark as sent:  {ex!s}")
+            LOG.error(f"Mark as sent:  {ex}")
 
     # Message deletion
 

toxygen/contacts/contact_menu.py

@@ -1,8 +1,8 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from PyQt5 import QtWidgets
+from  qtpy import QtWidgets
 
 import utils.ui as util_ui
-from wrapper.toxcore_enums_and_consts import *
+from toxygen_wrapper.toxcore_enums_and_consts import *
 
 global LOG
 import logging

toxygen/contacts/contact_provider.py

@@ -7,30 +7,21 @@ import logging
 LOG = logging.getLogger(__name__)
 
 # callbacks can be called in any thread so were being careful
-def LOG_ERROR(l): print('EROR< '+l)
+from av.calls import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
-def LOG_WARN(l):  print('WARN< '+l)
-def LOG_INFO(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 20-1
-    if bIsVerbose: print('INFO< '+l)
-def LOG_DEBUG(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 10-1
-    if bIsVerbose: print('DBUG< '+l)
-def LOG_TRACE(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel < 10-1
-    pass # print('TRACE+ '+l)
 
 class ContactProvider(tox_save.ToxSave):
 
-    def __init__(self, tox, friend_factory, group_factory, group_peer_factory):
+    def __init__(self, tox, friend_factory, group_factory, group_peer_factory, app=None):
         super().__init__(tox)
         self._friend_factory = friend_factory
         self._group_factory = group_factory
         self._group_peer_factory = group_peer_factory
         self._cache = {}  # key - contact's public key, value - contact instance
+        self._app = app
 
     # Friends
 
-    def get_friend_by_number(self, friend_number):
+    def get_friend_by_number(self, friend_number:int):
         try:
             public_key = self._tox.friend_get_public_key(friend_number)
         except Exception as e:
@@ -43,19 +34,22 @@ class ContactProvider(tox_save.ToxSave):
         if friend is not None:
             return friend
         friend = self._friend_factory.create_friend_by_public_key(public_key)
-        self._add_to_cache(public_key, friend)
+        if friend is None:
-        LOG_INFO(f"CP.get_friend_by_public_key ADDED {friend} ")
+            LOG_WARN(f"CP.get_friend_by_public_key NULL {friend} ")
-
+        else:
+            self._add_to_cache(public_key, friend)
+            LOG_DEBUG(f"CP.get_friend_by_public_key ADDED {friend} ")
         return friend
 
-    def get_all_friends(self):
+    def get_all_friends(self) -> list:
+        if self._app and self._app.bAppExiting:
+            return []
         try:
             friend_numbers = self._tox.self_get_friend_list()
         except Exception as e:
-            LOG_WARN(f"CP.get_all_friends NO {friend_numbers} {e} ")
+            LOG_WARN(f"CP.get_all_friends EXCEPTION {e} ")
-            return None
+            return []
         friends = map(lambda n: self.get_friend_by_number(n), friend_numbers)
-
         return list(friends)
 
     # Groups
@@ -83,7 +77,7 @@ class ContactProvider(tox_save.ToxSave):
     def get_group_by_number(self, group_number):
         group = None
         try:
-            LOG_INFO(f"CP.CP.group_get_number {group_number} ")
+#            LOG_DEBUG(f"CP.CP.group_get_number {group_number} ")
             # original code
             chat_id = self._tox.group_get_chat_id(group_number)
             if chat_id is None:
@@ -121,7 +115,7 @@ class ContactProvider(tox_save.ToxSave):
             return group
         group = self._group_factory.create_group_by_public_key(public_key)
         if group is None:
-            LOG_ERROR(f"get_group_by_public_key NULL group public_key={get_group_by_chat_id}")
+            LOG_WARN(f"get_group_by_public_key NULL group public_key={public_key}")
         else:
             self._add_to_cache(public_key, group)
 
@@ -130,17 +124,21 @@ class ContactProvider(tox_save.ToxSave):
     # Group peers
 
     def get_all_group_peers(self):
-        return list()
+        return []
 
     def get_group_peer_by_id(self, group, peer_id):
         peer = group.get_peer_by_id(peer_id)
-        if peer:
+        if peer is not None:
             return self._get_group_peer(group, peer)
+        LOG_WARN(f"get_group_peer_by_id peer_id={peer_id}")
+        return None
 
     def get_group_peer_by_public_key(self, group, public_key):
         peer = group.get_peer_by_public_key(public_key)
-
+        if peer is not None:
-        return self._get_group_peer(group, peer)
+            return self._get_group_peer(group, peer)
+        LOG_WARN(f"get_group_peer_by_public_key public_key={public_key}")
+        return None
 
     # All contacts
 

toxygen/contacts/contacts_manager.py

@@ -1,6 +1,6 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
-import traceback
+import logging
 
 from contacts.friend import Friend
 from contacts.group_chat import GroupChat
@@ -8,23 +8,17 @@ from messenger.messages import *
 from common.tox_save import ToxSave
 from contacts.group_peer_contact import GroupPeerContact
 from groups.group_peer import GroupChatPeer
+from middleware.callbacks import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
+import toxygen_wrapper.toxcore_enums_and_consts as enums
 
 # LOG=util.log
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 
-def LOG_ERROR(l): print('ERROR_: '+l)
-def LOG_WARN(l): print('WARN_: '+l)
-def LOG_INFO(l): print('INFO_: '+l)
-def LOG_DEBUG(l): print('DEBUG_: '+l)
-def LOG_TRACE(l): pass # print('TRACE+ '+l)
-
-
 UINT32_MAX = 2 ** 32 -1
 
-def set_contact_kind(contact):
+def set_contact_kind(contact) -> None:
-    bInvite = len(contact.name) == TOX_PUBLIC_KEY_SIZE * 2 and \
+    bInvite = len(contact.name) == enums.TOX_PUBLIC_KEY_SIZE * 2 and \
       contact.status_message == ''
     bBot = not bInvite and contact.name.lower().endswith(' bot')
     if type(contact) == Friend and bInvite:
@@ -63,7 +57,7 @@ class ContactsManager(ToxSave):
         self._history = history
         self._load_contacts()
 
-    def _log(self, s):
+    def _log(self, s) -> None:
         try:
             self._ms._log(s)
         except: pass
@@ -76,23 +70,23 @@ class ContactsManager(ToxSave):
     def get_curr_contact(self):
         return self._contacts[self._active_contact] if self._active_contact + 1 else None
 
-    def save_profile(self):
+    def save_profile(self) -> None:
         data = self._tox.get_savedata()
         self._profile_manager.save_profile(data)
 
-    def is_friend_active(self, friend_number):
+    def is_friend_active(self, friend_number:int) -> bool:
         if not self.is_active_a_friend():
             return False
 
         return self.get_curr_contact().number == friend_number
 
-    def is_group_active(self, group_number):
+    def is_group_active(self, group_number) -> bool:
         if self.is_active_a_friend():
             return False
 
         return self.get_curr_contact().number == group_number
 
-    def is_contact_active(self, contact):
+    def is_contact_active(self, contact) -> bool:
         if self._active_contact == -1:
 #            LOG.debug("No self._active_contact")
             return False
@@ -103,11 +97,15 @@ class ContactsManager(ToxSave):
             LOG.warn(f"ERROR NULL {self._contacts[self._active_contact]}  {contact.tox_id}")
             return False
 
+        if not hasattr(contact, 'tox_id'):
+            LOG.warn(f"ERROR is_contact_active no contact.tox_id {type(contact)}  contact={contact}")
+            return False
+
         return self._contacts[self._active_contact].tox_id == contact.tox_id
 
     # Reconnection support
 
-    def reset_contacts_statuses(self):
+    def reset_contacts_statuses(self) -> None:
         for contact in self._contacts:
             contact.status = None
 
@@ -146,7 +144,11 @@ class ContactsManager(ToxSave):
                     current_contact.curr_text = self._screen.messageEdit.toPlainText()
                 except:
                     pass
+
             # IndexError: list index out of range
+            if value >= len(self._contacts):
+                LOG.warn("CM.set_active value too big: {{self._contacts}}")
+                return
             contact = self._contacts[value]
             self._subscribe_to_events(contact)
             contact.remove_invalid_unsent_files()
@@ -175,9 +177,8 @@ class ContactsManager(ToxSave):
             #     self._screen.call_finished()
             self._set_current_contact_data(contact)
             self._active_contact_changed(contact)
-        except Exception as ex:  # no friend found. ignore
+        except Exception as e:  # no friend found. ignore
-            LOG.warn(f"no friend found. Friend value: {value!s}")
+            LOG.warn(f"CM.set_active EXCEPTION  value:{value} len={len(self._contacts)} {e}")
-            LOG.error('in set active: ' + str(ex))
             # gulp raise
 
     active_contact = property(get_active, set_active)
@@ -253,6 +254,9 @@ class ContactsManager(ToxSave):
         for index, contact in enumerate(self._contacts):
             list_item = self._screen.friends_list.item(index)
             item_widget = self._screen.friends_list.itemWidget(list_item)
+            if not item_widget:
+                LOG_WARN("CM.filtration_and_sorting( item_widget is NULL")
+                continue
             contact.set_widget(item_widget)
 
         for index, friend in enumerate(self._contacts):
@@ -291,15 +295,16 @@ class ContactsManager(ToxSave):
     def get_or_create_group_peer_contact(self, group_number, peer_id):
         group = self.get_group_by_number(group_number)
         peer = group.get_peer_by_id(peer_id)
-        if peer: # broken?
+        if peer is None:
-            if not hasattr(peer, 'public_key') or not peer.public_key:
+            LOG.warn(f'get_or_create_group_peer_contact group_number={group_number} peer_id={peer_id} peer={peer}')
-                LOG.error(f'no peer public_key ' + repr(dir(peer)))
+            return None
-            else:
+        LOG.debug(f'get_or_create_group_peer_contact group_number={group_number} peer_id={peer_id} peer={peer}')
-                if not self.check_if_contact_exists(peer.public_key):
+        if not self.check_if_contact_exists(peer.public_key):
-                    self.add_group_peer(group, peer)
+            contact = self.add_group_peer(group, peer)
-                return self.get_contact_by_tox_id(peer.public_key)
+            # dunno
-        else:
+            return contact
-            LOG.warn(f'no peer group_number={group_number} peer_id={peer_id}')
+        # me - later wrong kind of object?
+        return self.get_contact_by_tox_id(peer.public_key)
 
     def check_if_contact_exists(self, tox_id):
         return any(filter(lambda c: c.tox_id == tox_id, self._contacts))
@@ -376,8 +381,8 @@ class ContactsManager(ToxSave):
         """
         Block user with specified tox id (or public key) - delete from friends list and ignore friend requests
         """
-        tox_id = tox_id[:TOX_PUBLIC_KEY_SIZE * 2]
+        tox_id = tox_id[:enums.TOX_PUBLIC_KEY_SIZE * 2]
-        if tox_id == self._tox.self_get_address()[:TOX_PUBLIC_KEY_SIZE * 2]:
+        if tox_id == self._tox.self_get_address()[:enums.TOX_PUBLIC_KEY_SIZE * 2]:
             return
         if tox_id not in self._settings['blocked']:
             self._settings['blocked'].append(tox_id)
@@ -434,11 +439,12 @@ class ContactsManager(ToxSave):
     def add_group_peer(self, group, peer):
         contact = self._contact_provider.get_group_peer_by_id(group, peer.id)
         if self.check_if_contact_exists(contact.tox_id):
-            return
+            return contact
         contact._kind = 'grouppeer'
         self._contacts.append(contact)
         contact.reset_avatar(self._settings['identicons'])
         self._save_profile()
+        return contact
 
     def remove_group_peer_by_id(self, group, peer_id):
         peer = group.get_peer_by_id(peer_id)
@@ -483,14 +489,14 @@ class ContactsManager(ToxSave):
         retval = ''
         try:
             message = message or 'Hello! Add me to your contact list please'
-            if len(sToxPkOrId) == TOX_PUBLIC_KEY_SIZE * 2:  # public key
+            if len(sToxPkOrId) == enums.TOX_PUBLIC_KEY_SIZE * 2:  # public key
                 self.add_friend(sToxPkOrId)
                 title = 'Friend added'
                 text = 'Friend added without sending friend request'
             else:
                 num = self._tox.friend_add(sToxPkOrId, message.encode('utf-8'))
                 if num < UINT32_MAX:
-                    tox_pk = sToxPkOrId[:TOX_PUBLIC_KEY_SIZE * 2]
+                    tox_pk = sToxPkOrId[:enums.TOX_PUBLIC_KEY_SIZE * 2]
                     self._add_friend(tox_pk)
                     self.update_filtration()
                     title = 'Friend added'
@@ -643,7 +649,7 @@ class ContactsManager(ToxSave):
         try:
             index = list(map(lambda x: x[0], self._settings['friends_aliases'])).index(contact.tox_id)
             del self._settings['friends_aliases'][index]
-        except:
+        except Exception as e:
             pass
         if contact.tox_id in self._settings['notes']:
             del self._settings['notes'][contact.tox_id]

toxygen/contacts/friend.py

@@ -1,9 +1,11 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
+import os
+
 from contacts import contact, common
 from messenger.messages import *
-import os
 from contacts.contact_menu import *
 
-
 class Friend(contact.Contact):
     """
     Friend in list of friends.
@@ -27,7 +29,7 @@ class Friend(contact.Contact):
                 self._corr.insert(i, inline)
             return i - len(self._corr)
         except:
-            pass
+            return -1
 
     def get_unsent_files(self):
         messages = filter(lambda m: type(m) is UnsentFileMessage, self._corr)

toxygen/contacts/friend_factory.py

@@ -1,7 +1,8 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 from contacts.friend import Friend
 from common.tox_save import ToxSave
 
-
 class FriendFactory(ToxSave):
 
     def __init__(self, profile_manager, settings, tox, db, items_factory):
@@ -15,7 +16,7 @@ class FriendFactory(ToxSave):
         friend_number = self._tox.friend_by_public_key(public_key)
         return self.create_friend_by_number(friend_number)
 
-    def create_friend_by_number(self, friend_number):
+    def create_friend_by_number(self, friend_number:int):
         aliases = self._settings['friends_aliases']
         sToxPk = self._tox.friend_get_public_key(friend_number)
         assert sToxPk, sToxPk

toxygen/contacts/group_chat.py

@@ -4,18 +4,14 @@ from contacts import contact
 from contacts.contact_menu import GroupMenuGenerator
 import utils.util as util
 from groups.group_peer import GroupChatPeer
-from wrapper import toxcore_enums_and_consts as constants
+from toxygen_wrapper import toxcore_enums_and_consts as constants
 from common.tox_save import ToxSave
 from groups.group_ban import GroupBan
 
 global LOG
 import logging
 LOG = logging.getLogger(__name__)
-def LOG_ERROR(l): print('ERROR_: '+l)
+from av.calls import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
-def LOG_WARN(l): print('WARN_: '+l)
-def LOG_INFO(l): print('INFO_: '+l)
-def LOG_DEBUG(l): print('DEBUG_: '+l)
-def LOG_TRACE(l): pass # print('TRACE+ '+l)
 
 class GroupChat(contact.Contact, ToxSave):
 
@@ -84,13 +80,15 @@ class GroupChat(contact.Contact, ToxSave):
             LOG_WARN(f"add_peer id={peer_id} > {self._peers_limit}")
             return
 
-        LOG_TRACE(f"add_peer id={peer_id}")
+        status_message = f"Private in {self.name}"
+        LOG_TRACE(f"GC.add_peer id={peer_id} status_message={status_message}")
         peer = GroupChatPeer(peer_id,
                              self._tox.group_peer_get_name(self._number, peer_id),
                              self._tox.group_peer_get_status(self._number, peer_id),
                              self._tox.group_peer_get_role(self._number, peer_id),
                              self._tox.group_peer_get_public_key(self._number, peer_id),
-                             is_current_user)
+                             is_current_user,
+                             status_message=status_message)
         self._peers.append(peer)
 
     def remove_peer(self, peer_id):
@@ -109,7 +107,7 @@ class GroupChat(contact.Contact, ToxSave):
             return peers[0]
         else:
             LOG_WARN(f"get_peer_by_id empty peers for {peer_id}")
-            return []
+            return None
 
     def get_peer_by_public_key(self, public_key):
         peers = list(filter(lambda p: p.public_key == public_key, self._peers))
@@ -119,7 +117,7 @@ class GroupChat(contact.Contact, ToxSave):
             return peers[0]
         else:
             LOG_WARN(f"get_peer_by_public_key empty peers for {public_key}")
-            return []
+            return None
 
     def remove_all_peers_except_self(self):
         self._peers = self._peers[:1]

toxygen/contacts/group_factory.py

@@ -2,7 +2,7 @@
 
 from contacts.group_chat import GroupChat
 from common.tox_save import ToxSave
-import wrapper.toxcore_enums_and_consts as constants
+import toxygen_wrapper.toxcore_enums_and_consts as constants
 
 global LOG
 import logging

toxygen/contacts/group_peer_contact.py

@@ -1,11 +1,13 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import contacts.contact
 from contacts.contact_menu import GroupPeerMenuGenerator
 
-
 class GroupPeerContact(contacts.contact.Contact):
 
-    def __init__(self, profile_manager, message_getter, peer_number, name, widget, tox_id, group_pk):
+    def __init__(self, profile_manager, message_getter, peer_number, name, widget, tox_id, group_pk, status_message=None):
-        super().__init__(profile_manager, message_getter, peer_number, name, str(), widget, tox_id)
+        if status_message is None: status_message=str()
+        super().__init__(profile_manager, message_getter, peer_number, name, status_message, widget, tox_id)
         self._group_pk = group_pk
 
     def get_group_pk(self):

toxygen/contacts/group_peer_factory.py

@@ -1,7 +1,7 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 from common.tox_save import ToxSave
 from contacts.group_peer_contact import GroupPeerContact
 
-
 class GroupPeerFactory(ToxSave):
 
     def __init__(self, tox, profile_manager, db, items_factory):
@@ -14,7 +14,10 @@ class GroupPeerFactory(ToxSave):
         item = self._create_group_peer_item()
         message_getter = self._db.messages_getter(peer.public_key)
         group_peer_contact = GroupPeerContact(self._profile_manager, message_getter, peer.id, peer.name,
-                                              item, peer.public_key, group.tox_id)
+                                              item,
+                                              peer.public_key,
+                                              group.tox_id,
+                                              status_message=peer.status_message)
         group_peer_contact.status = peer.status
 
         return group_peer_contact

toxygen/contacts/profile.py

@@ -6,6 +6,7 @@ import common.tox_save as tox_save
 from middleware.threads import invoke_in_main_thread
 
 iUMAXINT = 4294967295
+iRECONNECT = 50
 
 global LOG
 import logging
@@ -15,7 +16,7 @@ class Profile(basecontact.BaseContact, tox_save.ToxSave):
     """
     Profile of current toxygen user.
     """
-    def __init__(self, profile_manager, tox, screen, contacts_provider, reset_action):
+    def __init__(self, profile_manager, tox, screen, contacts_provider, reset_action, app=None):
         """
         :param tox: tox instance
         :param screen: ref to main screen
@@ -34,32 +35,33 @@ class Profile(basecontact.BaseContact, tox_save.ToxSave):
         self._reset_action = reset_action
         self._waiting_for_reconnection = False
         self._timer = None
+        self._app = app
 
     # Edit current user's data
 
-    def change_status(self):
+    def change_status(self) -> None:
         """
         Changes status of user (online, away, busy)
         """
         if self._status is not None:
             self.set_status((self._status + 1) % 3)
 
-    def set_status(self, status):
+    def set_status(self, status) -> None:
         super().set_status(status)
         if status is not None:
             self._tox.self_set_status(status)
         elif not self._waiting_for_reconnection:
             self._waiting_for_reconnection = True
-            self._timer = threading.Timer(50, self._reconnect)
+            self._timer = threading.Timer(iRECONNECT, self._reconnect)
             self._timer.start()
 
-    def set_name(self, value):
+    def set_name(self, value) -> None:
         if self.name == value:
             return
         super().set_name(value)
         self._tox.self_set_name(self._name)
 
-    def set_status_message(self, value):
+    def set_status_message(self, value) -> None:
         super().set_status_message(value)
         self._tox.self_set_status_message(self._status_message)
 
@@ -72,19 +74,34 @@ class Profile(basecontact.BaseContact, tox_save.ToxSave):
 
     # Reset
 
-    def restart(self):
+    def restart(self) -> None:
         """
         Recreate tox instance
         """
         self.status = None
         invoke_in_main_thread(self._reset_action)
 
-    def _reconnect(self):
+    def _reconnect(self) -> None:
         self._waiting_for_reconnection = False
+        if self._app and self._app.bAppExiting:
+            # dont do anything after the app has been shipped
+            # there's a segv that results
+            return
         contacts = self._contacts_provider.get_all_friends()
         all_friends_offline = all(list(map(lambda x: x.status is None, contacts)))
         if self.status is None or (all_friends_offline and len(contacts)):
             self._waiting_for_reconnection = True
             self.restart()
-            self._timer = threading.Timer(50, self._reconnect)
+            self._timer = threading.Timer(iRECONNECT, self._reconnect)
             self._timer.start()
+
+# Current thread 0x00007901a13ccb80 (most recent call first):
+#   File "/usr/local/lib/python3.11/site-packages/toxygen_wrapper/tox.py", line 826 in self_get_friend_list_size
+#   File "/usr/local/lib/python3.11/site-packages/toxygen_wrapper/tox.py", line 838 in self_get_friend_list
+#   File "/mnt/o/var/local/src/toxygen/toxygen/contacts/contact_provider.py", line 45 in get_all_friends
+#   File "/mnt/o/var/local/src/toxygen/toxygen/contacts/profile.py", line 90 in _reconnect
+#   File "/usr/lib/python3.11/threading.py", line 1401 in run
+#   File "/usr/lib/python3.11/threading.py", line 1045 in _bootstrap_inner
+#   File "/usr/lib/python3.11/threading.py", line 1002 in _bootstrap
+#
+

toxygen/file_transfers/file_transfers.py

@@ -1,11 +1,15 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
+import os
 from os import chdir, remove, rename
 from os.path import basename, getsize, exists, dirname
 from time import time
 
 from common.event import Event
 from middleware.threads import invoke_in_main_thread
-from wrapper.tox import Tox
+from toxygen_wrapper.tox import Tox
-from wrapper.toxcore_enums_and_consts import TOX_FILE_KIND, TOX_FILE_CONTROL
+from toxygen_wrapper.toxcore_enums_and_consts import TOX_FILE_KIND, TOX_FILE_CONTROL
+from middleware.callbacks import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
 
 FILE_TRANSFER_STATE = {
     'RUNNING': 0,
@@ -78,9 +82,7 @@ class FileTransfer:
 
     def get_file_id(self):
         return self._file_id
-    # WTF
+#?        return self._tox.file_get_file_id(self._friend_number, self._file_number)
-    def get_file_id(self):
-        return self._tox.file_get_file_id(self._friend_number, self._file_number)
 
     file_id = property(get_file_id)
 
@@ -172,11 +174,14 @@ class SendAvatar(SendTransfer):
     """
 
     def __init__(self, path, tox, friend_number):
-        if path is None:
+        LOG_DEBUG(f"SendAvatar path={path} friend_number={friend_number}")
+        if path is None or not os.path.exists(path):
             avatar_hash = None
         else:
             with open(path, 'rb') as fl:
-                avatar_hash = Tox.hash(fl.read())
+                data=fl.read()
+            LOG_DEBUG(f"SendAvatar data={data} type={type(data)}")
+            avatar_hash = tox.hash(data, None)
         super().__init__(path, tox, friend_number, TOX_FILE_KIND['AVATAR'], avatar_hash)
 
 
@@ -218,8 +223,8 @@ class SendFromFileBuffer(SendTransfer):
     def send_chunk(self, position, size):
         super().send_chunk(position, size)
         if not size:
-            chdir(dirname(self._path))
+            os.chdir(dirname(self._path))
-            remove(self._path)
+            os.remove(self._path)
 
 # Receive file
 
@@ -311,7 +316,6 @@ class ReceiveAvatar(ReceiveTransfer):
     Get friend's avatar. Doesn't need file transfer item
     """
     MAX_AVATAR_SIZE = 512 * 1024
-
     def __init__(self, path, tox, friend_number, size, file_number):
         full_path = path + '.tmp'
         super().__init__(full_path, tox, friend_number, size, file_number)
@@ -324,11 +328,11 @@ class ReceiveAvatar(ReceiveTransfer):
             self._file.close()
             remove(full_path)
         elif exists(path):
-            hash = self.get_file_id()
+            ihash = self.get_file_id()
             with open(path, 'rb') as fl:
                 data = fl.read()
             existing_hash = Tox.hash(data)
-            if hash == existing_hash:
+            if ihash == existing_hash:
                 self.send_control(TOX_FILE_CONTROL['CANCEL'])
                 self._file.close()
                 remove(full_path)

toxygen/file_transfers/file_transfers_handler.py

@@ -1,14 +1,17 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
+import logging
+
 from messenger.messages import *
+from file_transfers.file_transfers import SendAvatar, is_inline
 from ui.contact_items import *
 import utils.util as util
 from common.tox_save import ToxSave
-from wrapper_tests.support_testing import assert_main_thread
+
-from copy import deepcopy
+from middleware.callbacks import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
 
 # LOG=util.log
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 log = lambda x: LOG.info(x)
 
@@ -29,13 +32,14 @@ class FileTransfersHandler(ToxSave):
         profile.avatar_changed_event.add_callback(self._send_avatar_to_contacts)
         self. lBlockAvatars = []
 
-    def stop(self):
+    def stop(self) -> None:
         self._settings['paused_file_transfers'] = self._paused_file_transfers if self._settings['resend_files'] else {}
         self._settings.save()
 
     # File transfers support
 
-    def incoming_file_transfer(self, friend_number, file_number, size, file_name):
+    def incoming_file_transfer(self, friend_number, file_number, size, file_name) -> None:
+        # main thread
         """
         New transfer
         :param friend_number: number of friend who sent file
@@ -44,12 +48,15 @@ class FileTransfersHandler(ToxSave):
         :param file_name: file name without path
         """
         friend = self._get_friend_by_number(friend_number)
-        if friend is None: return None
+        if friend is None:
+            LOG.info(f'incoming_file_handler Friend NULL friend_number={friend_number}')
+            return
         auto = self._settings['allow_auto_accept'] and friend.tox_id in self._settings['auto_accept_from_friends']
-        inline = is_inline(file_name) and self._settings['allow_inline']
+        inline = False # ?is_inline(file_name) and self._settings['allow_inline']
         file_id = self._tox.file_get_file_id(friend_number, file_number)
         accepted = True
         if file_id in self._paused_file_transfers:
+            LOG_INFO(f'incoming_file_handler paused friend_number={friend_number}')
             (path, ft_friend_number, is_incoming, start_position) = self._paused_file_transfers[file_id]
             pos = start_position if os.path.exists(path) else 0
             if pos >= size:
@@ -60,26 +67,33 @@ class FileTransfersHandler(ToxSave):
                 friend, accepted, size, file_name, file_number)
             self.accept_transfer(path, friend_number, file_number, size, False, pos)
         elif inline and size < 1024 * 1024:
+            LOG_INFO(f'incoming_file_handler small friend_number={friend_number}')
             self._file_transfers_message_service.add_incoming_transfer_message(
                 friend, accepted, size, file_name, file_number)
             self.accept_transfer('', friend_number, file_number, size, True)
         elif auto:
+            # accepted is really started
+            LOG_INFO(f'incoming_file_handler auto friend_number={friend_number}')
             path = self._settings['auto_accept_path'] or util.curr_directory()
             self._file_transfers_message_service.add_incoming_transfer_message(
                 friend, accepted, size, file_name, file_number)
             self.accept_transfer(path + '/' + file_name, friend_number, file_number, size)
         else:
+            LOG_INFO(f'incoming_file_handler reject friend_number={friend_number}')
             accepted = False
+            # FixME: need GUI ask
+            # accepted is really started
             self._file_transfers_message_service.add_incoming_transfer_message(
                 friend, accepted, size, file_name, file_number)
 
-    def cancel_transfer(self, friend_number, file_number, already_cancelled=False):
+    def cancel_transfer(self, friend_number, file_number, already_cancelled=False) -> None:
         """
         Stop transfer
         :param friend_number: number of friend
         :param file_number: file number
         :param already_cancelled: was cancelled by friend
         """
+        # callback
         if (friend_number, file_number) in self._file_transfers:
             tr = self._file_transfers[(friend_number, file_number)]
             if not already_cancelled:
@@ -92,19 +106,19 @@ class FileTransfersHandler(ToxSave):
         elif not already_cancelled:
             self._tox.file_control(friend_number, file_number, TOX_FILE_CONTROL['CANCEL'])
 
-    def cancel_not_started_transfer(self, friend_number, message_id):
+    def cancel_not_started_transfer(self, friend_number, message_id) -> None:
         friend = self._get_friend_by_number(friend_number)
         if friend is None: return None
         friend.delete_one_unsent_file(message_id)
 
-    def pause_transfer(self, friend_number, file_number, by_friend=False):
+    def pause_transfer(self, friend_number, file_number, by_friend=False) -> None:
         """
         Pause transfer with specified data
         """
         tr = self._file_transfers[(friend_number, file_number)]
         tr.pause(by_friend)
 
-    def resume_transfer(self, friend_number, file_number, by_friend=False):
+    def resume_transfer(self, friend_number, file_number, by_friend=False) -> None:
         """
         Resume transfer with specified data
         """
@@ -114,7 +128,7 @@ class FileTransfersHandler(ToxSave):
         else:
             tr.send_control(TOX_FILE_CONTROL['RESUME'])
 
-    def accept_transfer(self, path, friend_number, file_number, size, inline=False, from_position=0):
+    def accept_transfer(self, path, friend_number, file_number, size, inline=False, from_position=0) -> None:
         """
         :param path: path for saving
         :param friend_number: friend number
@@ -141,7 +155,7 @@ class FileTransfersHandler(ToxSave):
         if inline:
             self._insert_inline_before[(friend_number, file_number)] = message.message_id
 
-    def send_screenshot(self, data, friend_number):
+    def send_screenshot(self, data, friend_number) -> None:
         """
         Send screenshot
         :param data: raw data - png format
@@ -149,23 +163,26 @@ class FileTransfersHandler(ToxSave):
         """
         self.send_inline(data, 'toxygen_inline.png', friend_number)
 
-    def send_sticker(self, path, friend_number):
+    def send_sticker(self, path, friend_number) -> None:
         with open(path, 'rb') as fl:
             data = fl.read()
         self.send_inline(data, 'sticker.png', friend_number)
 
-    def send_inline(self, data, file_name, friend_number, is_resend=False):
+    def send_inline(self, data, file_name, friend_number, is_resend=False) -> None:
         friend = self._get_friend_by_number(friend_number)
-        if friend is None: return None
+        if friend is None:
+            LOG_WARN("fsend_inline Error friend is None file_name: {file_name}")
+            return
         if friend.status is None and not is_resend:
             self._file_transfers_message_service.add_unsent_file_message(friend, file_name, data)
             return
         elif friend.status is None and is_resend:
-            raise RuntimeError()
+            LOG_WARN("fsend_inline Error friend.status is None file_name: {file_name}")
+            return
         st = SendFromBuffer(self._tox, friend.number, data, file_name)
         self._send_file_add_set_handlers(st, friend, file_name, True)
 
-    def send_file(self, path, friend_number, is_resend=False, file_id=None):
+    def send_file(self, path, friend_number, is_resend=False, file_id=None) -> None:
         """
         Send file to current active friend
         :param path: file path
@@ -179,25 +196,25 @@ class FileTransfersHandler(ToxSave):
             self._file_transfers_message_service.add_unsent_file_message(friend, path, None)
             return
         elif friend.status is None and is_resend:
-            LOG.error('Error in sending')
+            LOG_WARN('Error in sending')
             return
         st = SendTransfer(path, self._tox, friend_number, TOX_FILE_KIND['DATA'], file_id)
         file_name = os.path.basename(path)
         self._send_file_add_set_handlers(st, friend, file_name)
 
-    def incoming_chunk(self, friend_number, file_number, position, data):
+    def incoming_chunk(self, friend_number, file_number, position, data) -> None:
         """
         Incoming chunk
         """
         self._file_transfers[(friend_number, file_number)].write_chunk(position, data)
 
-    def outgoing_chunk(self, friend_number, file_number, position, size):
+    def outgoing_chunk(self, friend_number, file_number, position, size) -> None:
         """
         Outgoing chunk
         """
         self._file_transfers[(friend_number, file_number)].send_chunk(position, size)
 
-    def transfer_finished(self, friend_number, file_number):
+    def transfer_finished(self, friend_number, file_number) -> None:
         transfer = self._file_transfers[(friend_number, file_number)]
         friend = self._get_friend_by_number(friend_number)
         if friend is None: return None
@@ -214,10 +231,10 @@ class FileTransfersHandler(ToxSave):
             self._file_transfers_message_service.add_inline_message(transfer, index)
         del self._file_transfers[(friend_number, file_number)]
 
-    def send_files(self, friend_number):
+    def send_files(self, friend_number:int) -> None:
         try:
             friend = self._get_friend_by_number(friend_number)
-            if friend is None: return None
+            if friend is None: return
             friend.remove_invalid_unsent_files()
             files = friend.get_unsent_files()
             for fl in files:
@@ -236,9 +253,9 @@ class FileTransfersHandler(ToxSave):
                     self.send_file(path, friend_number, True, key)
                     del self._paused_file_transfers[key]
         except Exception as ex:
-            LOG.error('Exception in file sending: ' + str(ex))
+            LOG_ERROR('send_files EXCEPTION in file sending: ' + str(ex))
 
-    def friend_exit(self, friend_number):
+    def friend_exit(self, friend_number:int) -> None:
         # RuntimeError: dictionary changed size during iteration
         lMayChangeDynamically = self._file_transfers.copy()
         for friend_num, file_num in lMayChangeDynamically:
@@ -248,30 +265,51 @@ class FileTransfersHandler(ToxSave):
                 continue
             ft = self._file_transfers[(friend_num, file_num)]
             if type(ft) is SendTransfer:
-                self._paused_file_transfers[ft.file_id] = [ft.path, friend_num, False, -1]
+                try:
+                    file_id = ft.file_id
+                except Exception as e:
+                    LOG_WARN("friend_exit SendTransfer Error getting file_id: {e}")
+                    # drop through
+                else:
+                    self._paused_file_transfers[file_id] = [ft.path, friend_num, False, -1]
             elif type(ft) is ReceiveTransfer and ft.state != FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
-                self._paused_file_transfers[ft.file_id] = [ft.path, friend_num, True, ft.total_size()]
+                try:
+                    file_id = ft.file_id
+                except Exception as e:
+                    LOG_WARN("friend_exit ReceiveTransfer Error getting file_id: {e}")
+                    # drop through
+                else:
+                    self._paused_file_transfers[file_id] = [ft.path, friend_num, True, ft.total_size()]
             self.cancel_transfer(friend_num, file_num, True)
 
     # Avatars support
 
-    def send_avatar(self, friend_number, avatar_path=None):
+    def send_avatar(self, friend_number, avatar_path=None) -> None:
         """
         :param friend_number: number of friend who should get new avatar
         :param avatar_path: path to avatar or None if reset
         """
+        return
         if (avatar_path, friend_number,) in self.lBlockAvatars:
             return
-
+        if friend_number is None:
+            LOG_WARN(f"send_avatar friend_number NULL {friend_number}")
+            return
+        if avatar_path and type(avatar_path) != str:
+            LOG_WARN(f"send_avatar avatar_path type {type(avatar_path)}")
+            return
+        LOG_INFO(f"send_avatar avatar_path={avatar_path} friend_number={friend_number}")
         try:
+            #  self NOT missing - who's self?
             sa = SendAvatar(avatar_path, self._tox, friend_number)
+            LOG_INFO(f"send_avatar avatar_path={avatar_path} sa={sa}")
             self._file_transfers[(friend_number, sa.file_number)] = sa
         except Exception as e:
             # ArgumentError('This client is currently not connected to the friend.')
-            LOG.error(f"send_avatar {e}")
+            LOG_WARN(f"send_avatar EXCEPTION {e}")
             self.lBlockAvatars.append( (avatar_path, friend_number,) )
 
-    def incoming_avatar(self, friend_number, file_number, size):
+    def incoming_avatar(self, friend_number, file_number, size) -> None:
         """
         Friend changed avatar
         :param friend_number: friend number
@@ -279,7 +317,7 @@ class FileTransfersHandler(ToxSave):
         :param size: size of avatar or 0 (default avatar)
         """
         friend = self._get_friend_by_number(friend_number)
-        if friend is None: return None
+        if friend is None: return
         ra = ReceiveAvatar(friend.get_contact_avatar_path(), self._tox, friend_number, size, file_number)
         if ra.state != FILE_TRANSFER_STATE['CANCELLED']:
             self._file_transfers[(friend_number, file_number)] = ra
@@ -287,7 +325,7 @@ class FileTransfersHandler(ToxSave):
         elif not size:
             friend.reset_avatar(self._settings['identicons'])
 
-    def _send_avatar_to_contacts(self, _):
+    def _send_avatar_to_contacts(self, _) -> None:
         # from a callback
         friends = self._get_all_friends()
         for friend in filter(self._is_friend_online, friends):
@@ -295,13 +333,13 @@ class FileTransfersHandler(ToxSave):
 
     # Private methods
 
-    def _is_friend_online(self, friend_number):
+    def _is_friend_online(self, friend_number:int) -> bool:
         friend = self._get_friend_by_number(friend_number)
         if friend is None: return None
 
         return friend.status is not None
 
-    def _get_friend_by_number(self, friend_number):
+    def _get_friend_by_number(self, friend_number:int):
         return self._contact_provider.get_friend_by_number(friend_number)
 
     def _get_all_friends(self):

toxygen/file_transfers/file_transfers_messages_service.py

@@ -1,16 +1,15 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
+import logging
+
 from messenger.messenger import *
 import utils.util as util
 from file_transfers.file_transfers import *
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 
-def LOG_ERROR(l): print('ERROR_: '+l)
+from av.calls import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
-def LOG_WARN(l): print('WARN_: '+l)
-def LOG_INFO(l): print('INFO_: '+l)
-def LOG_DEBUG(l): print('DEBUG_: '+l)
-def LOG_TRACE(l): pass # print('TRACE+ '+l)
 
 class FileTransfersMessagesService:
 
@@ -23,6 +22,7 @@ class FileTransfersMessagesService:
     def add_incoming_transfer_message(self, friend, accepted, size, file_name, file_number):
         assert friend
         author = MessageAuthor(friend.name, MESSAGE_AUTHOR['FRIEND'])
+        # accepted is really started
         status = FILE_TRANSFER_STATE['RUNNING'] if accepted else FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']
         tm = TransferMessage(author, util.get_unix_time(), status, size, file_name, friend.number, file_number)
 
@@ -50,7 +50,7 @@ class FileTransfersMessagesService:
 
         return tm
 
-    def add_inline_message(self, transfer, index):
+    def add_inline_message(self, transfer, index) -> None:
         """callback"""
         if not self._is_friend_active(transfer.friend_number):
             return
@@ -60,7 +60,8 @@ class FileTransfersMessagesService:
             return
         count = self._messages.count()
         if count + index + 1 >= 0:
-            self._create_inline_item(transfer.data, count + index + 1)
+            # assumes .data
+            self._create_inline_item(transfer, count + index + 1)
 
     def add_unsent_file_message(self, friend, file_path, data):
         assert friend
@@ -77,7 +78,7 @@ class FileTransfersMessagesService:
 
     # Private methods
 
-    def _is_friend_active(self, friend_number):
+    def _is_friend_active(self, friend_number:int) -> bool:
         if not self._contacts_manager.is_active_a_friend():
             return False
 

toxygen/groups/group_ban.py

@@ -1,4 +1,4 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class GroupBan:
 

toxygen/groups/group_invite.py

@@ -1,4 +1,4 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class GroupInvite:
 

toxygen/groups/group_peer.py

@@ -1,20 +1,21 @@
-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 class GroupChatPeer:
     """
     Represents peer in group chat.
     """
 
-    def __init__(self, peer_id, name, status, role, public_key, is_current_user=False, is_muted=False):
+    def __init__(self, peer_id, name, status, role, public_key, is_current_user=False, is_muted=False, status_message=None):
         self._peer_id = peer_id
         self._name = name
         self._status = status
+        self._status_message = status_message
         self._role = role
         self._public_key = public_key
         self._is_current_user = is_current_user
         self._is_muted = is_muted
-        # unused?
         self._kind = 'grouppeer'
+
     # Readonly properties
 
     def get_id(self):
@@ -32,6 +33,11 @@ class GroupChatPeer:
 
     is_current_user = property(get_is_current_user)
 
+    def get_status_message(self):
+        return self._status_message
+
+    status_message = property(get_status_message)
+
     # Read-write properties
 
     def get_name(self):

toxygen/groups/groups_service.py

@@ -1,15 +1,15 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+import logging
 
 import common.tox_save as tox_save
 import utils.ui as util_ui
 from groups.peers_list import PeersListGenerator
 from groups.group_invite import GroupInvite
-import wrapper.toxcore_enums_and_consts as constants
+import toxygen_wrapper.toxcore_enums_and_consts as constants
-from wrapper.toxcore_enums_and_consts import *
+from toxygen_wrapper.toxcore_enums_and_consts import *
-from wrapper.tox import UINT32_MAX
+from toxygen_wrapper.tox import UINT32_MAX
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+'gs')
 
 class GroupsService(tox_save.ToxSave):
@@ -26,14 +26,14 @@ class GroupsService(tox_save.ToxSave):
         # maybe just use self
         self._tox = tox
 
-    def set_tox(self, tox):
+    def set_tox(self, tox) -> None:
         super().set_tox(tox)
         for group in self._get_all_groups():
             group.set_tox(tox)
 
     # Groups creation
 
-    def create_new_gc(self, name, privacy_state, nick, status):
+    def create_new_gc(self, name, privacy_state, nick, status) -> None:
         try:
             group_number = self._tox.group_new(privacy_state, name, nick, status)
         except Exception as e:
@@ -47,7 +47,7 @@ class GroupsService(tox_save.ToxSave):
         group.status = constants.TOX_USER_STATUS['NONE']
         self._contacts_manager.update_filtration()
 
-    def join_gc_by_id(self, chat_id, password, nick, status):
+    def join_gc_by_id(self, chat_id, password, nick, status) -> None:
         try:
             group_number = self._tox.group_join(chat_id, password, nick, status)
             assert type(group_number) == int, group_number
@@ -74,18 +74,18 @@ class GroupsService(tox_save.ToxSave):
 
     # Groups reconnect and leaving
 
-    def leave_group(self, group_number):
+    def leave_group(self, group_number) -> None:
         if type(group_number) == int:
             self._tox.group_leave(group_number)
             self._contacts_manager.delete_group(group_number)
 
-    def disconnect_from_group(self, group_number):
+    def disconnect_from_group(self, group_number) -> None:
         self._tox.group_disconnect(group_number)
         group = self._get_group_by_number(group_number)
         group.status = None
         self._clear_peers_list(group)
 
-    def reconnect_to_group(self, group_number):
+    def reconnect_to_group(self, group_number) -> None:
         self._tox.group_reconnect(group_number)
         group = self._get_group_by_number(group_number)
         group.status = constants.TOX_USER_STATUS['NONE']
@@ -93,7 +93,7 @@ class GroupsService(tox_save.ToxSave):
 
     # Group invites
 
-    def invite_friend(self, friend_number, group_number):
+    def invite_friend(self, friend_number, group_number) -> None:
         if self._tox.friend_get_connection_status(friend_number) == TOX_CONNECTION['NONE']:
             title = f"Error in group_invite_friend {friend_number}"
             e = f"Friend not connected friend_number={friend_number}"
@@ -106,7 +106,7 @@ class GroupsService(tox_save.ToxSave):
             title = f"Error in group_invite_friend {group_number} {friend_number}"
             util_ui.message_box(title +'\n' +str(e), title)
 
-    def process_group_invite(self, friend_number, group_name, invite_data):
+    def process_group_invite(self, friend_number, group_name, invite_data) -> None:
         friend = self._get_friend_by_number(friend_number)
         # binary  {invite_data}
         LOG.debug(f"process_group_invite {friend_number} {group_name}")
@@ -114,7 +114,7 @@ class GroupsService(tox_save.ToxSave):
         self._group_invites.append(invite)
         self._update_invites_button_state()
 
-    def accept_group_invite(self, invite, name, status, password):
+    def accept_group_invite(self, invite, name, status, password) -> None:
         pk = invite.friend_public_key
         friend = self._get_friend_by_public_key(pk)
         LOG.debug(f"accept_group_invite {name}")
@@ -122,7 +122,7 @@ class GroupsService(tox_save.ToxSave):
         self._delete_group_invite(invite)
         self._update_invites_button_state()
 
-    def decline_group_invite(self, invite):
+    def decline_group_invite(self, invite) -> None:
         self._delete_group_invite(invite)
         self._main_screen.update_gc_invites_button_state()
 
@@ -142,7 +142,7 @@ class GroupsService(tox_save.ToxSave):
         group.name = self._tox.group_get_name(group.number)
         group.status_message = self._tox.group_get_topic(group.number)
 
-    def set_group_topic(self, group):
+    def set_group_topic(self, group) -> None:
         if not group.is_self_moderator_or_founder():
             return
         text = util_ui.tr('New topic for group "{}":'.format(group.name))
@@ -153,29 +153,29 @@ class GroupsService(tox_save.ToxSave):
         self._tox.group_set_topic(group.number, topic)
         group.status_message = topic
 
-    def show_group_management_screen(self, group):
+    def show_group_management_screen(self, group) -> None:
         widgets_factory = self._get_widgets_factory()
         self._screen = widgets_factory.create_group_management_screen(group)
         self._screen.show()
 
-    def show_group_settings_screen(self, group):
+    def show_group_settings_screen(self, group) -> None:
         widgets_factory = self._get_widgets_factory()
         self._screen = widgets_factory.create_group_settings_screen(group)
         self._screen.show()
 
-    def set_group_password(self, group, password):
+    def set_group_password(self, group, password) -> None:
         if group.password == password:
             return
         self._tox.group_founder_set_password(group.number, password)
         group.password = password
 
-    def set_group_peers_limit(self, group, peers_limit):
+    def set_group_peers_limit(self, group, peers_limit) -> None:
         if group.peers_limit == peers_limit:
             return
         self._tox.group_founder_set_peer_limit(group.number, peers_limit)
         group.peers_limit = peers_limit
 
-    def set_group_privacy_state(self, group, privacy_state):
+    def set_group_privacy_state(self, group, privacy_state) -> None:
         is_private = privacy_state == constants.TOX_GROUP_PRIVACY_STATE['PRIVATE']
         if group.is_private == is_private:
             return
@@ -184,13 +184,13 @@ class GroupsService(tox_save.ToxSave):
 
     # Peers list
 
-    def generate_peers_list(self):
+    def generate_peers_list(self) -> None:
         if not self._contacts_manager.is_active_a_group():
             return
         group = self._contacts_manager.get_curr_contact()
         PeersListGenerator().generate(group.peers, self, self._peers_list_widget, group.tox_id)
 
-    def peer_selected(self, chat_id, peer_id):
+    def peer_selected(self, chat_id, peer_id) -> None:
         widgets_factory = self._get_widgets_factory()
         group = self._get_group_by_public_key(chat_id)
         self_peer = group.get_self_peer()
@@ -202,16 +202,16 @@ class GroupsService(tox_save.ToxSave):
 
     # Peers actions
 
-    def set_new_peer_role(self, group, peer, role):
+    def set_new_peer_role(self, group, peer, role) -> None:
         self._tox.group_mod_set_role(group.number, peer.id, role)
         peer.role = role
         self.generate_peers_list()
 
-    def toggle_ignore_peer(self, group, peer, ignore):
+    def toggle_ignore_peer(self, group, peer, ignore) -> None:
         self._tox.group_toggle_ignore(group.number, peer.id, ignore)
         peer.is_muted = ignore
 
-    def set_self_info(self, group, name, status):
+    def set_self_info(self, group, name, status) -> None:
         self._tox.group_self_set_name(group.number, name)
         self._tox.group_self_set_status(group.number, status)
         self_peer = group.get_self_peer()
@@ -221,24 +221,24 @@ class GroupsService(tox_save.ToxSave):
 
     # Bans support
 
-    def show_bans_list(self, group):
+    def show_bans_list(self, group) -> None:
         return
         widgets_factory = self._get_widgets_factory()
         self._screen = widgets_factory.create_groups_bans_screen(group)
         self._screen.show()
 
-    def ban_peer(self, group, peer_id, ban_type):
+    def ban_peer(self, group, peer_id, ban_type) -> None:
         self._tox.group_mod_ban_peer(group.number, peer_id, ban_type)
 
-    def kick_peer(self, group, peer_id):
+    def kick_peer(self, group, peer_id) -> None:
         self._tox.group_mod_remove_peer(group.number, peer_id)
 
-    def cancel_ban(self, group_number, ban_id):
+    def cancel_ban(self, group_number, ban_id) -> None:
         self._tox.group_mod_remove_ban(group_number, ban_id)
 
     # Private methods
 
-    def _add_new_group_by_number(self, group_number):
+    def _add_new_group_by_number(self, group_number) -> None:
         LOG.debug(f"_add_new_group_by_number group_number={group_number}")
         self._contacts_manager.add_group(group_number)
 
@@ -251,22 +251,22 @@ class GroupsService(tox_save.ToxSave):
     def _get_all_groups(self):
         return self._contacts_provider.get_all_groups()
 
-    def _get_friend_by_number(self, friend_number):
+    def _get_friend_by_number(self, friend_number:int):
         return self._contacts_provider.get_friend_by_number(friend_number)
 
     def _get_friend_by_public_key(self, public_key):
         return self._contacts_provider.get_friend_by_public_key(public_key)
 
-    def _clear_peers_list(self, group):
+    def _clear_peers_list(self, group) -> None:
         group.remove_all_peers_except_self()
         self.generate_peers_list()
 
-    def _delete_group_invite(self, invite):
+    def _delete_group_invite(self, invite) -> None:
         if invite in self._group_invites:
             self._group_invites.remove(invite)
 
     # status should be dropped
-    def _join_gc_via_invite(self, invite_data, friend_number, nick, status='', password=''):
+    def _join_gc_via_invite(self, invite_data, friend_number, nick, status='', password='') -> None:
         LOG.debug(f"_join_gc_via_invite friend_number={friend_number} nick={nick} datalen={len(invite_data)}")
         if nick is None:
             nick = ''
@@ -284,8 +284,8 @@ class GroupsService(tox_save.ToxSave):
             LOG.error(f"_join_gc_via_invite group_number={group_number} {e}")
             return
 
-    def _update_invites_button_state(self):
+    def _update_invites_button_state(self) -> None:
         self._main_screen.update_gc_invites_button_state()
 
-    def _get_widgets_factory(self):
+    def _get_widgets_factory(self) -> None:
         return self._widgets_factory_provider.get_item()

toxygen/groups/peers_list.py

@@ -1,7 +1,8 @@
-from ui.group_peers_list import PeerItem, PeerTypeItem
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from wrapper.toxcore_enums_and_consts import *
-from ui.widgets import *
 
+from ui.group_peers_list import PeerItem, PeerTypeItem
+from toxygen_wrapper.toxcore_enums_and_consts import *
+from ui.widgets import *
 
 # Builder
 

toxygen/history/database.py

@@ -5,7 +5,7 @@ import utils.util as util
 
 global LOG
 import logging
-LOG = logging.getLogger('app.db')
+LOG = logging.getLogger('h.database')
 
 TIMEOUT = 11
 SAVE_MESSAGES = 500
@@ -86,7 +86,7 @@ class Database:
             db.commit()
             return True
         except Exception as e:
-            LOG.error("dd_friend_to_db " +self._name +' Database exception! ' +str(e))
+            LOG.error("dd_friend_to_db " +self._name +f" Database exception! {e}")
             db.rollback()
             return False
         finally:
@@ -101,7 +101,7 @@ class Database:
             db.commit()
             return True
         except Exception as e:
-            LOG.error("delete_friend_from_db " +self._name +' Database exception! ' +str(e))
+            LOG.error("delete_friend_from_db " +self._name +f" Database exception! {e}")
             db.rollback()
             return False
         finally:
@@ -118,7 +118,7 @@ class Database:
             db.commit()
             return True
         except Exception as e:
-            LOG.error("" +self._name +' Database exception! ' +str(e))
+            LOG.error("save_messages_to_db" +self._name +f" Database exception! {e}")
             db.rollback()
             return False
         finally:
@@ -134,7 +134,7 @@ class Database:
             db.commit()
             return True
         except Exception as e:
-            LOG.error("" +self._name +' Database exception! ' +str(e))
+            LOG.error("update_messages" +self._name +f" Database exception! {e}")
             db.rollback()
             return False
         finally:
@@ -149,7 +149,7 @@ class Database:
             db.commit()
             return True
         except Exception as e:
-            LOG.error("" +self._name +' Database exception! ' +str(e))
+            LOG.error("delete_message" +self._name +f" Database exception! {e}")
             db.rollback()
             return False
         finally:
@@ -164,7 +164,7 @@ class Database:
             db.commit()
             return True
         except Exception as e:
-            LOG.error("" +self._name +' Database exception! ' +str(e))
+            LOG.error("delete_messages" +self._name +f" Database exception! {e}")
             db.rollback()
             return False
         finally:

toxygen/history/history_logs_generators.py

@@ -1,3 +1,5 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import utils.util as util
 from messenger.messages import *
 

toxygen/messenger/messages.py

@@ -1,3 +1,5 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import os.path
 
 from history.database import MESSAGE_AUTHOR
@@ -67,7 +69,7 @@ class Message:
 
     def get_widget(self, *args):
         # FixMe
-        self._widget = self._create_widget(*args)
+        self._widget = self._create_widget(*args) # pylint: disable=assignment-from-none
 
         return self._widget
 
@@ -83,10 +85,10 @@ class Message:
 
     def _create_widget(self, *args):
         # overridden
-        pass
+        return None
 
     @staticmethod
-    def _get_id():
+    def _get_id() -> int:
         Message.MESSAGE_ID += 1
 
         return int(Message.MESSAGE_ID)
@@ -102,7 +104,7 @@ class TextMessage(Message):
         self._message = message
         self._id = message_id
 
-    def get_text(self):
+    def get_text(self) -> str:
         return self._message
 
     text = property(get_text)
@@ -136,8 +138,8 @@ class OutgoingTextMessage(TextMessage):
 
 class GroupChatMessage(TextMessage):
 
-    def __init__(self, id, message, owner, iTime, message_type, name):
+    def __init__(self, cid, message, owner, iTime, message_type, name):
-        super().__init__(id, message, owner, iTime, message_type)
+        super().__init__(cid, message, owner, iTime, message_type)
         self._user_name = name
 
 
@@ -153,13 +155,13 @@ class TransferMessage(Message):
         self._file_name = file_name
         self._friend_number, self._file_number = friend_number, file_number
 
-    def is_active(self, file_number):
+    def is_active(self, file_number) -> bool:
         if self._file_number != file_number:
             return False
 
         return self._state not in (FILE_TRANSFER_STATE['FINISHED'], FILE_TRANSFER_STATE['CANCELLED'])
 
-    def get_friend_number(self):
+    def get_friend_number(self) -> int:
         return self._friend_number
 
     friend_number = property(get_friend_number)

toxygen/messenger/messenger.py

@@ -1,13 +1,13 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+import logging
 import common.tox_save as tox_save
 import utils.ui as util_ui
 
 from messenger.messages import *
-from wrapper_tests.support_testing import assert_main_thread
+from toxygen_wrapper.tests.support_testing import assert_main_thread
-from wrapper.toxcore_enums_and_consts import TOX_MAX_MESSAGE_LENGTH
+from toxygen_wrapper.toxcore_enums_and_consts import TOX_MAX_MESSAGE_LENGTH
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 log = lambda x: LOG.info(x)
 
@@ -31,7 +31,7 @@ class Messenger(tox_save.ToxSave):
     def __repr__(self):
         return "<Messenger>"
 
-    def get_last_message(self):
+    def get_last_message(self) -> str:
         contact = self._contacts_manager.get_curr_contact()
         if contact is None:
             return str()
@@ -40,7 +40,7 @@ class Messenger(tox_save.ToxSave):
 
     # Messaging - friends
 
-    def new_message(self, friend_number, message_type, message):
+    def new_message(self, friend_number, message_type, message) -> None:
         """
         Current user gets new message
         :param friend_number: friend_num of friend who sent message
@@ -52,7 +52,7 @@ class Messenger(tox_save.ToxSave):
         text_message = TextMessage(message, MessageAuthor(friend.name, MESSAGE_AUTHOR['FRIEND']), t, message_type)
         self._add_message(text_message, friend)
 
-    def send_message(self):
+    def send_message(self) -> None:
         text = self._screen.messageEdit.toPlainText()
 
         plugin_command_prefix = '/plugin '
@@ -88,7 +88,7 @@ class Messenger(tox_save.ToxSave):
             assert_main_thread()
             util_ui.message_box(text, title)
 
-    def send_message_to_friend(self, text, message_type, friend_number=None):
+    def send_message_to_friend(self, text, message_type, friend_number=None) -> None:
         """
         Send message
         :param text: message text
@@ -124,7 +124,7 @@ class Messenger(tox_save.ToxSave):
             self._screen.messageEdit.clear()
             self._screen.messages.scrollToBottom()
 
-    def send_messages(self, friend_number):
+    def send_messages(self, friend_number:int) -> None:
         """
         Send 'offline' messages to friend
         """
@@ -140,7 +140,7 @@ class Messenger(tox_save.ToxSave):
 
     # Messaging - groups
 
-    def send_message_to_group(self, text, message_type, group_number=None):
+    def send_message_to_group(self, text, message_type, group_number=None) -> None:
         if group_number is None:
             group_number = self._contacts_manager.get_active_number()
 
@@ -161,7 +161,7 @@ class Messenger(tox_save.ToxSave):
             self._screen.messageEdit.clear()
             self._screen.messages.scrollToBottom()
 
-    def new_group_message(self, group_number, message_type, message, peer_id):
+    def new_group_message(self, group_number, message_type, message, peer_id) -> None:
         """
         Current user gets new message
         :param message_type: message type - plain text or action message (/me)
@@ -181,7 +181,7 @@ class Messenger(tox_save.ToxSave):
 
     # Messaging - group peers
 
-    def send_message_to_group_peer(self, text, message_type, group_number=None, peer_id=None):
+    def send_message_to_group_peer(self, text, message_type, group_number=None, peer_id=None) -> None:
         if group_number is None or peer_id is None:
             group_peer_contact = self._contacts_manager.get_curr_contact()
             peer_id = group_peer_contact.number
@@ -192,28 +192,40 @@ class Messenger(tox_save.ToxSave):
             return
         if group.number < 0:
             return
-        if peer_id and peer_id < 0:
+        if peer_id is not None and peer_id < 0:
             return
 
         assert_main_thread()
-        # FixMe: peer_id is None?
-        group_peer_contact = self._contacts_manager.get_or_create_group_peer_contact(group_number, peer_id)
-        # group_peer_contact now may be None
         group = self._get_group_by_number(group_number)
         messages = self._split_message(text.encode('utf-8'))
+
+        # FixMe: peer_id is None?
+        group_peer_contact = self._contacts_manager.get_or_create_group_peer_contact(group_number, peer_id)
+        if group_peer_contact is None:
+            LOG.warn("M.group_send_private_message group_peer_contact is None")
+            return
+        # group_peer_contact now may be None
+
         t = util.get_unix_time()
         for message in messages:
-            self._tox.group_send_private_message(group_number, peer_id, message_type, message)
+            bRet = self._tox.group_send_private_message(group_number, peer_id, message_type, message)
+            if not bRet:
+                LOG.warn("M.group_send_private_messag failed")
+                continue
             message_author = MessageAuthor(group.get_self_name(), MESSAGE_AUTHOR['GC_PEER'])
             message = OutgoingTextMessage(text, message_author, t, message_type)
-            group_peer_contact.append_message(message)
+            # AttributeError: 'GroupChatPeer' object has no attribute 'append_message'
+            if not hasattr(group_peer_contact, 'append_message'):
+                LOG.warn("M. group_peer_contact has no append_message group_peer_contact={group_peer_contact}")
+            else:
+                group_peer_contact.append_message(message)
             if not self._contacts_manager.is_contact_active(group_peer_contact):
                 return
             self._create_message_item(message)
             self._screen.messageEdit.clear()
             self._screen.messages.scrollToBottom()
 
-    def new_group_private_message(self, group_number, message_type, message, peer_id):
+    def new_group_private_message(self, group_number, message_type, message, peer_id) -> None:
         """
         Current user gets new message
         :param message: text of message
@@ -234,13 +246,13 @@ class Messenger(tox_save.ToxSave):
 
     # Message receipts
 
-    def receipt(self, friend_number, message_id):
+    def receipt(self, friend_number, message_id) -> None:
         friend = self._get_friend_by_number(friend_number)
         friend.mark_as_sent(message_id)
 
     # Typing notifications
 
-    def send_typing(self, typing):
+    def send_typing(self, typing) -> None:
         """
         Send typing notification to a friend
         """
@@ -249,7 +261,7 @@ class Messenger(tox_save.ToxSave):
         contact = self._contacts_manager.get_curr_contact()
         contact.typing_notification_handler.send(self._tox, typing)
 
-    def friend_typing(self, friend_number, typing):
+    def friend_typing(self, friend_number, typing) -> None:
         """
         Display incoming typing notification
         """
@@ -258,7 +270,7 @@ class Messenger(tox_save.ToxSave):
 
     # Contact info updated
 
-    def new_friend_name(self, friend, old_name, new_name):
+    def new_friend_name(self, friend, old_name, new_name) -> None:
         if old_name == new_name or friend.has_alias():
             return
         message = util_ui.tr('User {} is now known as {}')
@@ -270,7 +282,7 @@ class Messenger(tox_save.ToxSave):
     # Private methods
 
     @staticmethod
-    def _split_message(message):
+    def _split_message(message) -> list:
         messages = []
         while len(message) > TOX_MAX_MESSAGE_LENGTH:
             size = TOX_MAX_MESSAGE_LENGTH * 4 // 5
@@ -291,7 +303,7 @@ class Messenger(tox_save.ToxSave):
 
         return messages
 
-    def _get_friend_by_number(self, friend_number):
+    def _get_friend_by_number(self, friend_number:int):
         return self._contacts_provider.get_friend_by_number(friend_number)
 
     def _get_group_by_number(self, group_number):
@@ -300,7 +312,7 @@ class Messenger(tox_save.ToxSave):
     def _get_group_by_public_key(self, public_key):
         return self._contacts_provider.get_group_by_public_key( public_key)
 
-    def _on_profile_name_changed(self, new_name):
+    def _on_profile_name_changed(self, new_name) -> None:
         if self._profile_name == new_name:
             return
         message = util_ui.tr('User {} is now known as {}')
@@ -309,18 +321,18 @@ class Messenger(tox_save.ToxSave):
             self._add_info_message(friend.number, message)
         self._profile_name = new_name
 
-    def _on_call_started(self, friend_number, audio, video, is_outgoing):
+    def _on_call_started(self, friend_number, audio, video, is_outgoing) -> None:
         if is_outgoing:
             text = util_ui.tr("Outgoing video call") if video else util_ui.tr("Outgoing audio call")
         else:
             text = util_ui.tr("Incoming video call") if video else util_ui.tr("Incoming audio call")
         self._add_info_message(friend_number, text)
 
-    def _on_call_finished(self, friend_number, is_declined):
+    def _on_call_finished(self, friend_number, is_declined) -> None:
         text = util_ui.tr("Call declined") if is_declined else util_ui.tr("Call finished")
         self._add_info_message(friend_number, text)
 
-    def _add_info_message(self, friend_number, text):
+    def _add_info_message(self, friend_number, text) -> None:
         friend = self._get_friend_by_number(friend_number)
         assert friend
         message = InfoMessage(text, util.get_unix_time())
@@ -328,12 +340,12 @@ class Messenger(tox_save.ToxSave):
         if self._contacts_manager.is_friend_active(friend_number):
             self._create_info_message_item(message)
 
-    def _create_info_message_item(self, message):
+    def _create_info_message_item(self, message) -> None:
         assert_main_thread()
         self._items_factory.create_message_item(message)
         self._screen.messages.scrollToBottom()
 
-    def _add_message(self, text_message, contact):
+    def _add_message(self, text_message, contact) -> None:
         assert_main_thread()
         if not contact:
             LOG.warn("_add_message null contact")
@@ -350,6 +362,6 @@ class Messenger(tox_save.ToxSave):
             if not contact.visibility:
                 self._contacts_manager.update_filtration()
 
-    def _create_message_item(self, text_message):
+    def _create_message_item(self, text_message) -> None:
         # pixmap = self._contacts_manager.get_curr_contact().get_pixmap()
         self._items_factory.create_message_item(text_message)

toxygen/middleware/callbacks.py

@@ -2,10 +2,10 @@
 import sys
 import os
 import threading
-from PyQt5 import QtGui
+from  qtpy import QtGui
-from wrapper.toxcore_enums_and_consts import *
+from toxygen_wrapper.toxcore_enums_and_consts import *
-from wrapper.toxav_enums import *
+from toxygen_wrapper.toxav_enums import *
-from wrapper.tox import bin_to_string
+from toxygen_wrapper.tox import bin_to_string
 import utils.ui as util_ui
 import utils.util as util
 from middleware.threads import invoke_in_main_thread, execute
@@ -15,17 +15,17 @@ from datetime import datetime
 
 iMAX_INT32 = 4294967295
 # callbacks can be called in any thread so were being careful
-def LOG_ERROR(l): print('EROR< '+l)
+def LOG_ERROR(l): print(f"EROR. {l}")
-def LOG_WARN(l):  print('WARN< '+l)
+def LOG_WARN(l):  print(f"WARN. {l}")
 def LOG_INFO(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 20-1
+    bIsVerbose = not hasattr(__builtins__, 'app') or app.oArgs.loglevel <= 20-1 # pylint dusable=undefined-variable
-    if bIsVerbose: print('INFO< '+l)
+    if bIsVerbose: print(f"INFO. {l}")
 def LOG_DEBUG(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 10-1
+    bIsVerbose = not hasattr(__builtins__, 'app') or app.oArgs.loglevel <= 10-1 # pylint dusable=undefined-variable
-    if bIsVerbose: print('DBUG< '+l)
+    if bIsVerbose: print(f"DBUG. {l}")
 def LOG_TRACE(l):
-    bIsVerbose = hasattr(__builtins__, 'app') and app.oArgs.loglevel < 10-1
+    bIsVerbose = not hasattr(__builtins__, 'app') or app.oArgs.loglevel < 10-1 # pylint dusable=undefined-variable
-    pass # print('TRACE+ '+l)
+    pass # print(f"TRACE. {l}")
 
 global aTIMES
 aTIMES=dict()
@@ -102,7 +102,7 @@ def friend_status(contacts_manager, file_transfer_handler, profile, settings):
         """
         Check friend's status (none, busy, away)
         """
-        LOG_DEBUG(f"Friend's #{friend_number} status changed")
+        LOG_INFO(f"Friend's #{friend_number} status changed")
         key = f"friend_number {friend_number}"
         if bTooSoon(key, sSlot, 10): return
         friend = contacts_manager.get_friend_by_number(friend_number)
@@ -240,7 +240,7 @@ def tox_file_recv(window, tray, profile, file_transfer_handler, contacts_manager
     """
     def wrapped(tox, friend_number, file_number, file_type, size, file_name, file_name_size, user_data):
         if file_type == TOX_FILE_KIND['DATA']:
-            LOG_DEBUG(f'file_transfer_handler File')
+            LOG_INFO(f'file_transfer_handler File friend_number={friend_number}')
             try:
                 file_name = str(file_name[:file_name_size], 'utf-8')
             except:
@@ -365,7 +365,7 @@ def callback_audio(calls_manager):
         """
         New audio chunk
         """
-        LOG_DEBUG(f"callback_audio #{friend_number}")
+#trace        LOG_DEBUG(f"callback_audio #{friend_number}")
         # dunno was .call
         calls_manager._call.audio_chunk(
             bytes(samples[:audio_samples_per_channel * 2 * audio_channels_count]),
@@ -402,7 +402,7 @@ def video_receive_frame(toxav, friend_number, width, height, y, u, v, ystride, u
     It can be created from initial y, u, v using slices
     """
     LOG_DEBUG(f"video_receive_frame from toxav_video_receive_frame_cb={friend_number}")
-    import cv2
+    with ts.ignoreStdout(): import cv2
     import numpy as np
     try:
         y_size = abs(max(width, abs(ystride)))
@@ -425,9 +425,9 @@ def video_receive_frame(toxav, friend_number, width, height, y, u, v, ystride, u
         frame[height * 5 // 4:, :width // 2] = v[:height // 2:2, :width // 2]
         frame[height * 5 // 4:, width // 2:] = v[1:height // 2:2, :width // 2]
 
-        frame = cv2.cvtColor(frame, cv2.COLOR_YUV2BGR_I420)
+        frame = cv2.cvtColor(frame, cv2.COLOR_YUV2BGR_I420) # pylint: disable=no-member
-
+        # imshow
-        invoke_in_main_thread(cv2.imshow, str(friend_number), frame)
+        invoke_in_main_thread(cv2.imshow, str(friend_number), frame) # pylint: disable=no-member
     except Exception as ex:
         LOG_ERROR(f"video_receive_frame  {ex} #{friend_number}")
         pass
@@ -473,7 +473,11 @@ def group_private_message(window, tray, tox, messenger, settings, profile):
         if window.isActiveWindow():
             return
         bl = settings['notify_all_gc'] or profile.name in message
-        name = tox.group_peer_get_name(group_number, peer_id)
+        try:
+            name = tox.group_peer_get_name(group_number, peer_id)
+        except Exception as e:
+            LOG_WARN("tox.group_peer_get_name {group_number} {peer_id}")
+            name = ''
         if settings['notifications'] and settings['tray_icon'] \
            and profile.status != TOX_USER_STATUS['BUSY'] \
            and (not settings.locked) and bl:
@@ -578,7 +582,7 @@ def group_peer_name(contacts_provider, groups_service):
         else:
             # FixMe: known signal to revalidate roles...
             #_peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_TRACE(f"remove_peer group {group!r} has no peer_id={peer_id} in _peers!r")
+            LOG_TRACE(f"remove_peer group {group} has no peer_id={peer_id} in _peers!r")
             return
 
     return wrapped
@@ -593,7 +597,7 @@ def group_peer_status(contacts_provider, groups_service):
             peer.status = peer_status
         else:
             # _peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_TRACE(f"remove_peer group {group!r} has no peer_id={peer_id} in _peers!r")
+            LOG_TRACE(f"remove_peer group {group} has no peer_id={peer_id} in _peers!r")
         # TODO: add info message
         invoke_in_main_thread(groups_service.generate_peers_list)
 
@@ -609,7 +613,7 @@ def group_topic(contacts_provider):
             invoke_in_main_thread(group.set_status_message, topic)
         else:
             _peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_WARN(f"group_topic {group!r} has no peer_id={peer_id} in {_peers!r}")
+            LOG_WARN(f"group_topic {group} has no peer_id={peer_id} in {_peers}")
         # TODO: add info message
 
     return wrapped
@@ -623,7 +627,7 @@ def group_moderation(groups_service, contacts_provider, contacts_manager, messen
         else:
             # FixMe: known signal to revalidate roles...
             # _peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_TRACE(f"update_peer_role group {group!r} has no peer_id={peer_id} in _peers!r")
+            LOG_TRACE(f"update_peer_role group {group} has no peer_id={peer_id} in _peers!r")
         # TODO: add info message
 
     def remove_peer(group, mod_peer_id, peer_id, is_ban):
@@ -634,7 +638,7 @@ def group_moderation(groups_service, contacts_provider, contacts_manager, messen
         else:
             # FixMe: known signal to revalidate roles...
             #_peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_TRACE(f"remove_peer group {group!r} has no peer_id={peer_id} in _peers!r")
+            LOG_TRACE(f"remove_peer group {group} has no peer_id={peer_id} in _peers!r")
         # TODO: add info message
 
     # source_peer_number, target_peer_number,
@@ -647,13 +651,13 @@ def group_moderation(groups_service, contacts_provider, contacts_manager, messen
         mod_peer = group.get_peer_by_id(mod_peer_id)
         if not mod_peer:
             #_peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_TRACE(f"remove_peer group {group!r} has no mod_peer_id={mod_peer_id} in _peers!r")
+            LOG_TRACE(f"remove_peer group {group} has no mod_peer_id={mod_peer_id} in _peers!r")
             return
         peer = group.get_peer_by_id(peer_id)
         if not peer:
             # FixMe: known signal to revalidate roles...
             #_peers = [(p._name, p._peer_id) for p in group.get_peers()]
-            LOG_TRACE(f"remove_peer group {group!r} has no peer_id={peer_id} in _peers!r")
+            LOG_TRACE(f"remove_peer group {group} has no peer_id={peer_id} in _peers!r")
             return
 
         if event_type == TOX_GROUP_MOD_EVENT['KICK']:

toxygen/middleware/threads.py

@@ -2,12 +2,12 @@
 import sys
 import threading
 import queue
-from PyQt5 import QtCore
+from  qtpy import QtCore
 
 from bootstrap.bootstrap import *
 from bootstrap.bootstrap import download_nodes_list
-from wrapper.toxcore_enums_and_consts import TOX_USER_STATUS, TOX_CONNECTION
+from toxygen_wrapper.toxcore_enums_and_consts import TOX_USER_STATUS, TOX_CONNECTION
-import wrapper_tests.support_testing as ts
+import toxygen_wrapper.tests.support_testing as ts
 from utils import util
 
 import time
@@ -23,7 +23,7 @@ def LOG_ERROR(l): print('EROR+ '+l)
 def LOG_WARN(l):  print('WARN+ '+l)
 def LOG_INFO(l):  print('INFO+ '+l)
 def LOG_DEBUG(l): print('DBUG+ '+l)
-def LOG_TRACE(l): pass # print('TRACE+ '+l)
+def LOG_TRACE(l): pass # print('TRAC+ '+l)
 
 iLAST_CONN = 0
 iLAST_DELTA = 60
@@ -86,7 +86,7 @@ class InitThread(BaseThread):
 
     def run(self):
         # DBUG+ InitThread run: ERROR name 'ts' is not defined
-        import wrapper_tests.support_testing as ts
+        import toxygen_wrapper.tests.support_testing as ts
         LOG_DEBUG('InitThread run: ')
         try:
             if self._is_first_start and ts.bAreWeConnected() and \

toxygen/middleware/tox_factory.py

@@ -1,59 +1,25 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-import user_data.settings
+
-import wrapper.tox
-import wrapper.toxcore_enums_and_consts as enums
 import ctypes
 import traceback
 import os
+from ctypes import *
+
+import user_data.settings
+import toxygen_wrapper.tox
+import toxygen_wrapper.toxcore_enums_and_consts as enums
+from toxygen_wrapper.tests import support_testing as ts
+# callbacks can be called in any thread so were being careful
+# tox.py can be called by callbacks
+from toxygen_wrapper.tests.support_testing import LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG, LOG_TRACE
 
 global LOG
 import logging
 LOG = logging.getLogger('app.'+'tox_factory')
 
-from ctypes import *
 from utils import util
 from utils import ui as util_ui
 
-# callbacks can be called in any thread so were being careful
-# tox.py can be called by callbacks
-def LOG_ERROR(a): print('EROR> '+a)
-def LOG_WARN(a): print('WARN> '+a)
-def LOG_INFO(a):
-    bVERBOSE = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 20
-    if bVERBOSE: print('INFO> '+a)
-def LOG_DEBUG(a):
-    bVERBOSE = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 10
-    if bVERBOSE: print('DBUG> '+a)
-def LOG_TRACE(a):
-    bVERBOSE = hasattr(__builtins__, 'app') and app.oArgs.loglevel < 10
-    if bVERBOSE: print('TRAC> '+a)
-def LOG_LOG(a): print('TRAC> '+a)
-
-def tox_log_cb(iTox, level, file, line, func, message, *args):
-    """
-    * @param level The severity of the log message.
-    * @param file The source file from which the message originated.
-    * @param line The source line from which the message originated.
-    * @param func The function from which the message originated.
-    * @param message The log message.
-    * @param user_data The user data pointer passed to tox_new in options.
-    """
-    try:
-        file = str(file, 'UTF-8')
-        # root WARNING 3network.c#944:b'send_packet'attempted to send message with network family 10 (probably IPv6) on IPv4 socket
-        if file == 'network.c' and line in [944, 660]: return
-        func = str(func, 'UTF-8')
-        message = str(message, 'UTF-8')
-        message = f"{file}#{line}:{func} {message}"
-        LOG_LOG(message)
-    except Exception as e:
-        LOG_ERROR(f"tox_log_cb {e}")
-
-#tox_log_handler (context=0x24763d0,
-#    level=LOGGER_LEVEL_TRACE, file=0x7fffe599fb99 "TCP_common.c", line=203,
-#    func=0x7fffe599fc50 <__func__.2> "read_TCP_packet",
-#    message=0x7fffba7fabd0 "recv buffer has 0 bytes, but requested 10 bytes",
-#    userdata=0x0) at /var/local/src/c-toxcore/toxcore/tox.c:78
 
 def tox_factory(data=None, settings=None, args=None, app=None):
     """
@@ -68,7 +34,7 @@ def tox_factory(data=None, settings=None, args=None, app=None):
         user_data.settings.clean_settings(settings)
 
     try:
-        tox_options = wrapper.tox.Tox.options_new()
+        tox_options = toxygen_wrapper.tox.Tox.options_new()
         tox_options.contents.ipv6_enabled = settings['ipv6_enabled']
         tox_options.contents.udp_enabled = settings['udp_enabled']
         tox_options.contents.proxy_type = int(settings['proxy_type'])
@@ -99,27 +65,25 @@ def tox_factory(data=None, settings=None, args=None, app=None):
         tox_options.contents.ipv6_enabled = False
         tox_options.contents.hole_punching_enabled = False
 
-        LOG.debug("wrapper.tox.Tox settings: " +repr(settings))
+        LOG.debug("toxygen_wrapper.tox.Tox settings: " +repr(settings))
 
-        if 'trace_enabled' in settings and settings['trace_enabled']:
+        if 'trace_enabled' in settings and not settings['trace_enabled']:
-            LOG_INFO("settings['trace_enabled' disabled" )
+            LOG_DEBUG("settings['trace_enabled' disabled" )
-        elif tox_options._options_pointer:
+        elif tox_options._options_pointer and \
-            c_callback = CFUNCTYPE(None, c_void_p, c_int, c_char_p, c_int, c_char_p, c_char_p, c_void_p)
+          'trace_enabled' in settings and settings['trace_enabled']:
-            tox_options.self_logger_cb = c_callback(tox_log_cb)
+            ts.vAddLoggerCallback(tox_options)
-            wrapper.tox.Tox.libtoxcore.tox_options_set_log_callback(
+            LOG_INFO("c-toxcore trace_enabled enabled" )
-                tox_options._options_pointer,
-                tox_options.self_logger_cb)
         else:
             LOG_WARN("No tox_options._options_pointer to add self_logger_cb" )
 
-        retval = wrapper.tox.Tox(tox_options)
+        retval = toxygen_wrapper.tox.Tox(tox_options)
     except Exception as e:
         if app and hasattr(app, '_log'):
             pass
-        LOG_ERROR(f"wrapper.tox.Tox failed:  {e}")
+        LOG_ERROR(f"toxygen_wrapper.tox.Tox failed:  {e}")
         LOG_WARN(traceback.format_exc())
         raise
 
     if app and hasattr(app, '_log'):
-        app._log("DEBUG: wrapper.tox.Tox succeeded")
+        app._log("DEBUG: toxygen_wrapper.tox.Tox succeeded")
     return retval

toxygen/network/tox_dns.py

@@ -1,15 +1,19 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 import json
 import urllib.request
-import utils.util as util
+import logging
-from PyQt5 import QtNetwork, QtCore
+
 try:
     import requests
 except ImportError:
     requests = None
+from  qtpy import QtNetwork, QtCore
+
+import utils.util as util
 
 global LOG
-import logging
+
+iTIMEOUT=60
 LOG = logging.getLogger('app.'+__name__)
 
 class ToxDns:
@@ -55,7 +59,7 @@ class ToxDns:
                 try:
                     headers = dict()
                     headers['Content-Type'] = 'application/json'
-                    req = requests.get(url, headers=headers)
+                    req = requests.get(url, headers=headers, timeout=iTIMEOUT)
                     if req.status_code < 300:
                         result = req.content
                         return result

toxygen/notifications/sound.py

@@ -1,7 +1,13 @@
-import utils.util
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-import wave
+
-import pyaudio
 import os.path
+import wave
+
+import utils.util
+
+import toxygen_wrapper.tests.support_testing as ts
+with ts.ignoreStderr():
+    import pyaudio
 
 global LOG
 import logging
@@ -33,7 +39,7 @@ class AudioFile:
                 self.stream.write(data)
                 data = self.wf.readframes(self.chunk)
         except Exception as e:
-            LOG.error(f"Error during AudioFile play {e!s}")
+            LOG.error(f"Error during AudioFile play {e}")
             LOG.debug("Error during AudioFile play " \
                       +' rate=' +str(self.wf.getframerate()) \
                       + 'format=' +str(self.p.get_format_from_width(self.wf.getsampwidth())) \

toxygen/notifications/tray.py

@@ -1,5 +1,6 @@
-from PyQt5 import QtCore, QtWidgets
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
+from  qtpy import QtCore, QtWidgets
 
 def tray_notification(title, text, tray, window):
     """

toxygen/plugin_support/plugin_support.py

@@ -1,14 +1,15 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-import utils.util as util
 import os
 import importlib
 import inspect
-import plugins.plugin_super_class as pl
 import sys
+import logging
+
+import utils.util as util
+import plugins.plugin_super_class as pl
 
 # LOG=util.log
 global LOG
-import logging
 LOG = logging.getLogger('plugin_support')
 def trace(msg, *args, **kwargs): LOG._log(0, msg, [])
 LOG.trace = trace
@@ -42,14 +43,14 @@ class PluginLoader:
         self._app = app
         self._plugins = {}  # dict. key - plugin unique short name, value - Plugin instance
 
-    def set_tox(self, tox):
+    def set_tox(self, tox) -> None:
         """
         New tox instance
         """
         for plugin in self._plugins.values():
             plugin.instance.set_tox(tox)
 
-    def load(self):
+    def load(self) -> None:
         """
         Load all plugins in plugins folder
         """
@@ -100,7 +101,7 @@ class PluginLoader:
                 LOG.info('Added plugin: ' +short_name +' from file: ' +fl)
                 break
 
-    def callback_lossless(self, friend_number, data):
+    def callback_lossless(self, friend_number, data) -> None:
         """
         New incoming custom lossless packet (callback)
         """
@@ -118,7 +119,7 @@ class PluginLoader:
         if name in self._plugins and self._plugins[name].is_active:
             self._plugins[name].instance.lossy_packet(''.join(chr(x) for x in data[l + 1:]), friend_number)
 
-    def friend_online(self, friend_number):
+    def friend_online(self, friend_number:int) -> None:
         """
         Friend with specified number is online
         """
@@ -126,7 +127,7 @@ class PluginLoader:
             if plugin.is_active:
                 plugin.instance.friend_connected(friend_number)
 
-    def get_plugins_list(self):
+    def get_plugins_list(self) -> list:
         """
         Returns list of all plugins
         """
@@ -154,7 +155,7 @@ class PluginLoader:
 
         return None
 
-    def toggle_plugin(self, key):
+    def toggle_plugin(self, key) -> None:
         """
         Enable/disable plugin
         :param key: plugin short name
@@ -171,7 +172,7 @@ class PluginLoader:
             self._settings['plugins'].remove(key)
         self._settings.save()
 
-    def command(self, text):
+    def command(self, text) -> None:
         """
         New command for plugin
         """
@@ -210,7 +211,7 @@ class PluginLoader:
                 pass
         return result
 
-    def stop(self):
+    def stop(self) -> None:
         """
         App is closing, stop all plugins
         """
@@ -219,7 +220,7 @@ class PluginLoader:
                 self._plugins[key].instance.close()
             del self._plugins[key]
 
-    def reload(self):
+    def reload(self) -> None:
         path = util.get_plugins_directory()
         if not os.path.exists(path):
             self._app._log('WARN: Plugin directory not found: ' + path)

toxygen/plugins/ae.py

@@ -1,9 +1,11 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-import plugin_super_class
 import json
-from user_data import settings
 import os
+from qtpy import QtWidgets
+
 from bootstrap.bootstrap import get_user_config_path
+from user_data import settings
+import plugin_super_class
 
 class AvatarEncryption(plugin_super_class.PluginSuperClass):
 
@@ -17,7 +19,7 @@ class AvatarEncryption(plugin_super_class.PluginSuperClass):
         self._contacts = self._profile._contacts_provider.get_all_friends()
 
     def get_description(self):
-        return QApplication.translate("AvatarEncryption", 'Encrypt all avatars using profile password.')
+        return QtWidgets.QApplication.translate("AvatarEncryption", 'Encrypt all avatars using profile password.')
 
     def close(self):
         if not self._encrypt_save.has_password():

toxygen/plugins/awayl.py

@@ -1,9 +1,12 @@
 import plugin_super_class
 import threading
-import time
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from PyQt5 import QtCore, QtWidgets
+
-from subprocess import check_output
 import json
+from subprocess import check_output
+import time
+
+from  qtpy import QtCore, QtWidgets
 
 
 class InvokeEvent(QtCore.QEvent):

toxygen/plugins/bday.py

@@ -1,8 +1,11 @@
-import plugin_super_class
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from PyQt5 import QtWidgets, QtCore
+
 import json
 import importlib
 
+from  qtpy import QtWidgets, QtCore
+
+import plugin_super_class
 
 class BirthDay(plugin_super_class.PluginSuperClass):
 
@@ -16,7 +19,7 @@ class BirthDay(plugin_super_class.PluginSuperClass):
         self._profile=self._app._ms._profile
         self._window = None
 
-    def start(self):
+    def start(self) -> None:
         now = self._datetime.datetime.now()
         today = {}
         x = self._profile.tox_id[:64]
@@ -34,9 +37,9 @@ class BirthDay(plugin_super_class.PluginSuperClass):
             msgbox.exec_()
 
     def get_description(self):
-        return QApplication.translate("BirthDay", "Send and get notifications on your friends' birthdays.")
+        return QtWidgets.QApplication.translate("BirthDay", "Send and get notifications on your friends' birthdays.")
 
-    def get_window(self):
+    def get_window(self) -> None:
         inst = self
         x = self._profile.tox_id[:64]
 
@@ -73,7 +76,7 @@ class BirthDay(plugin_super_class.PluginSuperClass):
             self._window = Window()
         return self._window
 
-    def lossless_packet(self, data, friend_number):
+    def lossless_packet(self, data, friend_number) -> None:
         if len(data):
             friend = self._profile.get_friend_by_number(friend_number)
             self._data[friend.tox_id] = data
@@ -81,13 +84,13 @@ class BirthDay(plugin_super_class.PluginSuperClass):
         elif self._data['send_date'] and self._profile.tox_id[:64] in self._data:
             self.send_lossless(self._data[self._profile.tox_id[:64]], friend_number)
 
-    def friend_connected(self, friend_number):
+    def friend_connected(self, friend_number:int) -> None:
         timer = QtCore.QTimer()
         timer.timeout.connect(lambda: self.timer(friend_number))
         timer.start(10000)
         self._timers.append(timer)
 
-    def timer(self, friend_number):
+    def timer(self, friend_number:int) -> None:
         timer = self._timers.pop()
         timer.stop()
         if self._profile.get_friend_by_number(friend_number).tox_id not in self._data:

toxygen/plugins/bot.py

@@ -1,7 +1,9 @@
-import plugin_super_class
-from PyQt5 import QtCore
 import time
 
+from  qtpy import QtCore, QtWidgets
+
+import plugin_super_class
+
 
 class InvokeEvent(QtCore.QEvent):
     EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
@@ -40,7 +42,7 @@ class Bot(plugin_super_class.PluginSuperClass):
         self._window = None
 
     def get_description(self):
-        return QApplication.translate("Bot", 'Plugin to answer bot to your friends.')
+        return QtWidgets.QApplication.translate("Bot", 'Plugin to answer bot to your friends.')
 
     def start(self):
         self._timer.start(10000)

toxygen/plugins/chess.py

@@ -1,16 +1,17 @@
-# -*- coding: utf-8 -*-
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 
 import collections
 import re
 import math
+
+from  qtpy import QtWidgets
+from  qtpy.QtCore import *
+from  qtpy.QtWidgets import *
+from  qtpy.QtGui import *
+from  qtpy.QtSvg import *
+
 import plugin_super_class
 
-from PyQt5.QtCore import *
-from PyQt5.QtWidgets import *
-from PyQt5.QtGui import *
-from PyQt5.QtSvg import *
-
-
 START_FEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
 
 
@@ -1621,7 +1622,7 @@ class Chess(plugin_super_class.PluginSuperClass):
         self._window = None
 
     def get_description(self):
-        return QApplication.translate("Chess", 'Plugin which allows you to play chess with your friends.')
+        return QtWidgets.QApplication.translate("Chess", 'Plugin which allows you to play chess with your friends.')
 
     def get_window(self):
         inst = self
@@ -1690,6 +1691,6 @@ class Chess(plugin_super_class.PluginSuperClass):
         QTimer.singleShot(1000, self.resend_move)
 
     def get_menu(self, menu, num):
-        act = QAction(QApplication.translate("Chess", "Start chess game"), menu)
+        act = QAction(QtWidgets.QApplication.translate("Chess", "Start chess game"), menu)
         act.triggered.connect(lambda: self.start_game(num))
         return [act]

toxygen/plugins/garland.py

@@ -1,8 +1,11 @@
-import plugin_super_class
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import threading
 import time
-from PyQt5 import QtCore
 
+from  qtpy import QtCore, QtWidgets
+
+from plugins.plugin_super_class import PluginSuperClass
 
 class InvokeEvent(QtCore.QEvent):
     EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
@@ -27,7 +30,7 @@ def invoke_in_main_thread(fn, *args, **kwargs):
     QtCore.QCoreApplication.postEvent(_invoker, InvokeEvent(fn, *args, **kwargs))
 
 
-class Garland(plugin_super_class.PluginSuperClass):
+class Garland(PluginSuperClass):
 
     def __init__(self, *args):
         super(Garland, self).__init__('Garland', 'grlnd', *args)
@@ -39,7 +42,7 @@ class Garland(plugin_super_class.PluginSuperClass):
         self._window = None
 
     def get_description(self):
-        return QApplication.translate("Garland", "Changes your status like it's garland.")
+        return QtWidgets.QApplication.translate("Garland", "Changes your status like it's garland.")
 
     def close(self):
         self.stop()

toxygen/plugins/mrq.py

@@ -1,9 +1,10 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-import plugin_super_class
 import threading
 import time
-from PyQt5 import QtCore
 
+from  qtpy import QtCore, QtWidgets
+
+import plugin_super_class
 
 class InvokeEvent(QtCore.QEvent):
     EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
@@ -40,7 +41,7 @@ class MarqueeStatus(plugin_super_class.PluginSuperClass):
         self._window = None
 
     def get_description(self):
-        return QApplication.translate("MarqueeStatus", 'Create ticker from your status message.')
+        return QtWidgets.QApplication.translate("MarqueeStatus", 'Create ticker from your status message.')
 
     def close(self):
         self.stop()

toxygen/plugins/plugin_super_class.py

@@ -1,17 +1,17 @@
 # -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
 import os
-from PyQt5 import QtCore, QtWidgets
+
+from  qtpy import QtCore, QtWidgets
+
 import utils.ui as util_ui
 import common.tox_save as tox_save
 
-
 MAX_SHORT_NAME_LENGTH = 5
 
 LOSSY_FIRST_BYTE = 200
 
 LOSSLESS_FIRST_BYTE = 160
 
-
 def path_to_data(name):
     """
     :param name: plugin unique name
@@ -180,7 +180,7 @@ class PluginSuperClass(tox_save.ToxSave):
         """
         pass
 
-    def friend_connected(self, friend_number):
+    def friend_connected(self, friend_number:int):
         """
         Friend with specified number is online now
         """

toxygen/plugins/srch.py

@@ -1,6 +1,8 @@
-import plugin_super_class
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from PyQt5 import QtGui, QtCore, QtWidgets
 
+from  qtpy import QtGui, QtCore, QtWidgets
+
+import plugin_super_class
 
 class SearchPlugin(plugin_super_class.PluginSuperClass):
 
@@ -8,7 +10,7 @@ class SearchPlugin(plugin_super_class.PluginSuperClass):
         super(SearchPlugin, self).__init__('SearchPlugin', 'srch', *args)
 
     def get_description(self):
-        return QApplication.translate("SearchPlugin", 'Plugin search with search engines.')
+        return QtWidgets.QApplication.translate("SearchPlugin", 'Plugin search with search engines.')
 
     def get_message_menu(self, menu, text):
         google = QtWidgets.QAction(

toxygen/plugins/toxid.py

@@ -1,9 +1,12 @@
-import plugin_super_class
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from PyQt5 import QtCore, QtWidgets
+
 import json
 
+from  qtpy import QtCore, QtWidgets
 
-class CopyableToxId(plugin_super_class.PluginSuperClass):
+from plugins.plugin_super_class import PluginSuperClass
+
+class CopyableToxId(PluginSuperClass):
 
     def __init__(self, *args):
         super(CopyableToxId, self).__init__('CopyableToxId', 'toxid', *args)
@@ -47,7 +50,7 @@ class CopyableToxId(plugin_super_class.PluginSuperClass):
             self._window = Window()
         return self._window
 
-    def lossless_packet(self, data, friend_number):
+    def lossless_packet(self, data, friend_number) -> None:
         if len(data):
             self._data['id'] = list(filter(lambda x: not x.startswith(data[:64]), self._data['id']))
             self._data['id'].append(data)
@@ -60,7 +63,7 @@ class CopyableToxId(plugin_super_class.PluginSuperClass):
         elif self._data['send_id']:
             self.send_lossless(self._tox.self_get_address(), friend_number)
 
-    def error(self):
+    def error(self) -> None:
         msgbox = QtWidgets.QMessageBox()
         title = QtWidgets.QApplication.translate("TOXID", "Error")
         msgbox.setWindowTitle(title.format(self._name))
@@ -68,7 +71,7 @@ class CopyableToxId(plugin_super_class.PluginSuperClass):
         msgbox.setText(text)
         msgbox.exec_()
 
-    def timer(self):
+    def timer(self) -> None:
         self._copy = False
         if self._curr + 1:
             public_key = self._tox.friend_get_public_key(self._curr)
@@ -83,10 +86,10 @@ class CopyableToxId(plugin_super_class.PluginSuperClass):
             self.error()
         self._timer.stop()
 
-    def friend_connected(self, friend_number):
+    def friend_connected(self, friend_number:int):
         self.send_lossless('', friend_number)
 
-    def command(self, text):
+    def command(self, text) -> None:
         if text == 'copy':
             num = self._profile.get_active_number()
             if num == -1:
@@ -129,8 +132,9 @@ help: show this help""")
         else:
             self.error()
 
-    def get_menu(self, menu, num):
+    def get_menu(self, menu, num) -> list:
         act = QtWidgets.QAction(QtWidgets.QApplication.translate("TOXID", "Copy TOX ID"), menu)
         friend = self._profile.get_friend(num)
-        act.connect(act, QtCore.SIGNAL("triggered()"), lambda: self.command('copy ' + str(friend.number)))
+        act.connect(act, QtCore.Signal("triggered()"),
+                    lambda: self.command('copy ' + str(friend.number)))
         return [act]

toxygen/smileys/smileys.py

@@ -1,12 +1,16 @@
-from utils import util
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import json
+import logging
 import os
 from collections import OrderedDict
-from PyQt5 import QtCore
+
+from  qtpy import QtCore
+
+from utils import util
 
 # LOG=util.log
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 log = lambda x: LOG.info(x)
 

toxygen/stickers/stickers.py

@@ -1,7 +1,8 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 import os
 import utils.util as util
 
-
 def load_stickers():
     """
     :return list of stickers

toxygen/tests/README.md

@@ -1,87 +0,0 @@
-# toxygen_wrapper
-
-[ctypes](https://docs.python.org/3/library/ctypes.html)
-wrapping of [Tox](https://tox.chat/)
-[```libtoxcore```](https://github.com/TokTok/c-toxcore) into Python.
-Taken from the ```wrapper``` directory of the now abandoned
-<https://github.com/toxygen-project/toxygen> ```next_gen``` branch
-by Ingvar.
-
-The basics of NGC groups are supported, as well as AV and toxencryptsave.
-There is no coverage of conferences as they are not used in ```toxygen```
-and the list of still unwrapped calls as of Sept. 2022 can be found in
-```tox.c-toxcore.missing```. The code still needs double-checking
-that every call in ```tox.py``` has the right signature, but it runs
-```toxygen``` with no apparent issues.
-
-It has been tested with UDP and TCP proxy (Tor). It has ***not*** been
-tested on Windows, and there may be some minor breakage, which should be
-easy to fix. There is a good coverage integration testsuite in ```wrapper_tests```.
-Change to that directory and run ```tests_wrapper.py --help```; the test
-suite gives a good set of examples of usage.
-
-## Install
-
-Put the parent of the wrapper directory on your PYTHONPATH and
-touch a file called `__init__.py` in its parent directory.
-
-Then you need a ```libs``` directory beside the `wrapper` directory
-and you need to link your ```libtoxcore.so``` and ```libtoxav.so```
-and ```libtoxencryptsave.so``` into it. Link all 3 filenames
-to ```libtoxcore.so``` if you have only ```libtoxcore.so```
-(which is usually the case if you built ```c-toxcore``` with ```cmake```
-rather than ```autogen/configure```). If you want to be different,
-the environment variable TOXCORE_LIBS overrides the location of ```libs```.
-
-As is, the code in ```tox.py``` is very verbose. Edit the file to change
-```
-def LOG_ERROR(a): print('EROR> '+a)
-def LOG_WARN(a): print('WARN> '+a)
-def LOG_INFO(a): print('INFO> '+a)
-def LOG_DEBUG(a): print('DBUG> '+a)
-def LOG_TRACE(a): pass # print('TRAC> '+a)
-```
-to all ```pass #``` or use ```logging.logger``` to suite your tastes.
-```logging.logger``` can be dangerous in callbacks in ```Qt``` applications,
-so we use simple print statements as default. The same applies to
-```wrapper/tests_wrapper.py```.
-
-## Prerequisites
-
-No prerequisites in Python3.
-
-## Other wrappers
-
-There are a number of other wrappings into Python of Tox core.
-This one uses [ctypes](https://docs.python.org/3/library/ctypes.html)
-which has its merits - there is no need to recompile anything as with
-Cython - change the Python file and it's done. And you can follow things
-in a Python debugger, or with the utterly stupendous Python feature of
-```gdb``` (```gdb -ex r --args /usr/bin/python3.9 <pyfile>```).
-
-CTYPES code can be brittle, segfaulting if you've got things wrong,
-but if your wrapping is right, it is very efficient and easy to work on.
-The [faulthandler](https://docs.python.org/3/library/faulthandler.html)
-module can be helpful in debugging crashes
-(e.g. from segmentation faults produced by erroneous C library wrapping).
-
-Others include:
-
-* <https://github.com/TokTok/py-toxcore-c> Cython bindings.
-  Incomplete and not really actively supported. Maybe it will get
-  worked on in the future,  but TokTok seems to be working on
-  java, rust, scalla, go, etc. bindings instead.
-  No support for NGC groups or toxencryptsave.
-
-* <https://github.com/oxij/PyTox>
-  forked from https://github.com/aitjcize/PyTox
-  by Wei-Ning Huang <aitjcize@gmail.com>.
-  Hardcore C wrapping which is not easy to keep up to date.
-  No support for NGC or toxencryptsave. Abandonned.
-  This was the basis for the TokTok/py-toxcore-c code until recently.
-
-To our point of view, the ability of CTYPEs to follow code in the
-debugger is a crucial advantage.
-
-Work on this project is suspended until the
-[MultiDevice](https://git.plastiras.org/emdee/tox_profile/wiki/MultiDevice-Announcements-POC) problem is solved. Fork me!

toxygen/tests/README.txt

@@ -0,0 +1 @@
+unused

toxygen/tests/logging_toxygen_echo.py

@@ -1,439 +0,0 @@
-#!/var/local/bin/python3.bash
-#
-""" echo.py features
- - accept friend request
- - echo back friend message
- - accept and answer friend call request
- - send back friend audio/video data
- - send back files friend sent
-"""
-
-from __future__ import print_function
-
-import sys
-import os
-import traceback
-import random
-from ctypes import *
-import argparse
-
-import time
-from os.path import exists
-
-# LOG=util.log
-global LOG
-import logging
-# log = lambda x: LOG.info(x)
-LOG = logging.getLogger('app')
-def LOG_error(a): print('EROR_ '+a)
-def LOG_warn(a):  print('WARN_ '+a)
-def LOG_info(a):  print('INFO_ '+a)
-def LOG_debug(a): print('DBUG_ '+a)
-def LOG_trace(a): pass # print('TRAC_ '+a)
-
-from middleware.tox_factory import tox_factory
-import wrapper
-import wrapper.toxcore_enums_and_consts as enums
-from wrapper.toxcore_enums_and_consts import TOX_CONNECTION, TOX_USER_STATUS, \
-    TOX_MESSAGE_TYPE, TOX_PUBLIC_KEY_SIZE, TOX_FILE_CONTROL
-import user_data
-from wrapper.libtox import LibToxCore
-import wrapper_tests.support_testing as ts
-from wrapper_tests.support_testing import oMainArgparser
-from wrapper_tests.support_testing import logging_toxygen_echo
-
-def sleep(fSec):
-    if 'QtCore' in globals():
-        if fSec > .000001: globals['QtCore'].QThread.msleep(fSec)
-        globals['QtCore'].QCoreApplication.processEvents()
-    else:
-        time.sleep(fSec)
-
-try:
-    import coloredlogs
-    if 'COLOREDLOGS_LEVEL_STYLES' not in os.environ:
-        os.environ['COLOREDLOGS_LEVEL_STYLES'] = 'spam=22;debug=28;verbose=34;notice=220;warning=202;success=118,bold;error=124;critical=background=red'
-except ImportError as e:
-    # logging.log(logging.DEBUG, f"coloredlogs not available:  {e}")
-    coloredlogs = None
-
-import wrapper_tests.support_testing as ts
-if 'USER' in os.environ:
-    sDATA_FILE = '/tmp/logging_toxygen_' +os.environ['USER'] +'.tox'
-elif 'USERNAME' in os.environ:
-    sDATA_FILE = '/tmp/logging_toxygen_' +os.environ['USERNAME'] +'.tox'
-else:
-    sDATA_FILE = '/tmp/logging_toxygen_' +'data' +'.tox'
-
-bHAVE_AV = True
-iDHT_TRIES = 100
-iDHT_TRY = 0
-
-#?SERVER = lLOCAL[-1]
-
-class AV(wrapper.tox.ToxAV):
-    def __init__(self, core):
-        super(AV, self).__init__(core)
-        self.core = self.get_tox()
-
-    def on_call(self, fid, audio_enabled, video_enabled):
-        LOG.info("Incoming %s call from %d:%s ..." % (
-            "video" if video_enabled else "audio", fid,
-            self.core.friend_get_name(fid)))
-        bret = self.answer(fid, 48, 64)
-        LOG.info(f"Answered, in call... {bret!s}")
-
-    def on_call_state(self, fid, state):
-        LOG.info('call state:fn=%d, state=%d' % (fid, state))
-
-    def on_audio_bit_rate(self, fid, audio_bit_rate):
-        LOG.info('audio bit rate status: fn=%d, abr=%d' %
-              (fid, audio_bit_rate))
-
-    def on_video_bit_rate(self, fid, video_bit_rate):
-        LOG.info('video bit rate status: fn=%d, vbr=%d' %
-              (fid, video_bit_rate))
-
-    def on_audio_receive_frame(self, fid, pcm, sample_count,
-                               channels, sampling_rate):
-        # LOG.info('audio frame: %d, %d, %d, %d' %
-        #      (fid, sample_count, channels, sampling_rate))
-        # LOG.info('pcm len:%d, %s' % (len(pcm), str(type(pcm))))
-        sys.stdout.write('.')
-        sys.stdout.flush()
-        bret = self.audio_send_frame(fid, pcm, sample_count,
-                                     channels, sampling_rate)
-        if bret is False:
-            LOG.error('on_audio_receive_frame error.')
-
-    def on_video_receive_frame(self, fid, width, height, frame, u, v):
-        LOG.info('video frame: %d, %d, %d, ' % (fid, width, height))
-        sys.stdout.write('*')
-        sys.stdout.flush()
-        bret = self.video_send_frame(fid, width, height, frame, u, v)
-        if bret is False:
-            LOG.error('on_video_receive_frame error.')
-
-    def witerate(self):
-        self.iterate()
-
-
-def save_to_file(tox, fname):
-    data = tox.get_savedata()
-    with open(fname, 'wb') as f:
-        f.write(data)
-
-def load_from_file(fname):
-    assert os.path.exists(fname)
-    return open(fname, 'rb').read()
-
-class EchoBot():
-    def __init__(self, oTox):
-        self._tox = oTox
-        self._tox.self_set_name("EchoBot")
-        LOG.info('ID: %s' % self._tox.self_get_address())
-
-        self.files = {}
-        self.av = None
-        self.on_connection_status = None
-
-    def start(self):
-        self.connect()
-        if bHAVE_AV:
-            # RuntimeError: Attempted to create a second session for the same Tox instance.
-
-            self.av = True # AV(self._tox_pointer)
-        def bobs_on_friend_request(iTox,
-                                     public_key,
-                                     message_data,
-                                     message_data_size,
-                                     *largs):
-            key = ''.join(chr(x) for x in public_key[:TOX_PUBLIC_KEY_SIZE])
-            sPk = wrapper.tox.bin_to_string(key, TOX_PUBLIC_KEY_SIZE)
-            sMd = str(message_data, 'UTF-8')
-            LOG.debug('on_friend_request ' +sPk +' ' +sMd)
-            self.on_friend_request(sPk, sMd)
-        LOG.info('setting bobs_on_friend_request')
-        self._tox.callback_friend_request(bobs_on_friend_request)
-
-        def bobs_on_friend_message(iTox,
-                                   iFriendNum,
-                                   iMessageType,
-                                   message_data,
-                                   message_data_size,
-                                   *largs):
-            sMd = str(message_data, 'UTF-8')
-            LOG_debug(f"on_friend_message  {iFriendNum}" +' ' +sMd)
-            self.on_friend_message(iFriendNum, iMessageType, sMd)
-        LOG.info('setting bobs_on_friend_message')
-        self._tox.callback_friend_message(bobs_on_friend_message)
-
-        def bobs_on_file_chunk_request(iTox, fid, filenumber, position, length, *largs):
-            if length == 0:
-                return
-
-            data = self.files[(fid, filenumber)]['f'][position:(position + length)]
-            self._tox.file_send_chunk(fid, filenumber, position, data)
-        self._tox.callback_file_chunk_request(bobs_on_file_chunk_request)
-
-        def bobs_on_file_recv(iTox, fid, filenumber, kind, size, filename, *largs):
-            LOG_info(f"on_file_recv {fid!s} {filenumber!s} {kind!s} {size!s} {filename}")
-            if size == 0:
-                return
-            self.files[(fid, filenumber)] = {
-                'f': bytes(),
-                'filename': filename,
-                'size': size
-            }
-            self._tox.file_control(fid, filenumber, TOX_FILE_CONTROL['RESUME'])
-
-
-    def connect(self):
-        if not self.on_connection_status:
-            def on_connection_status(iTox, iCon, *largs):
-                LOG_info('ON_CONNECTION_STATUS - CONNECTED ' + repr(iCon))
-            self._tox.callback_self_connection_status(on_connection_status)
-            LOG.info('setting on_connection_status callback ')
-            self.on_connection_status = on_connection_status
-        if self._oargs.network in ['newlocal', 'local']:
-            LOG.info('connecting on the new network ')
-            sNet = 'newlocal'
-        elif self._oargs.network == 'new':
-            LOG.info('connecting on the new network ')
-            sNet = 'new'
-        else: # main old
-            LOG.info('connecting on the old network ')
-            sNet = 'old'
-        sFile = self._oargs.nodes_json
-        lNodes = generate_nodes_from_file(sFile)
-        lElts = lNodes
-        random.shuffle(lElts)
-        for lElt in lElts[:10]:
-            status = self._tox.self_get_connection_status()
-            try:
-                if self._tox.bootstrap(*lElt):
-                    LOG.info('connected to ' + lElt[0]+' '+repr(status))
-                else:
-                    LOG.warn('failed connecting to ' + lElt[0])
-            except Exception as e:
-                LOG.warn('error connecting to ' + lElt[0])
-
-        if self._oargs.proxy_type > 0:
-            random.shuffle(ts.lRELAYS)
-            for lElt in ts.lRELAYS[:10]:
-                status = self._tox.self_get_connection_status()
-                try:
-                    if self._tox.add_tcp_relay(*lElt):
-                        LOG.info('relayed to ' + lElt[0] +' '+repr(status))
-                    else:
-                        LOG.warn('failed relay to ' + lElt[0])
-                except Exception as e:
-                    LOG.warn('error relay to ' + lElt[0])
-
-    def loop(self):
-        if not self.av:
-            self.start()
-        checked = False
-        save_to_file(self._tox, sDATA_FILE)
-
-        LOG.info('Starting loop.')
-        while True:
-
-            status = self._tox.self_get_connection_status()
-            if not checked and status:
-                LOG.info('Connected to DHT.')
-                checked = True
-            if not checked and not status:
-                global iDHT_TRY
-                iDHT_TRY += 10
-                self.connect()
-                self.iterate(100)
-                if iDHT_TRY >= iDHT_TRIES:
-                    raise RuntimeError("Failed to connect to the DHT.")
-                LOG.warn(f"NOT Connected to DHT. {iDHT_TRY}")
-                checked = True
-            if checked and not status:
-                LOG.info('Disconnected from DHT.')
-                self.connect()
-                checked = False
-
-            if bHAVE_AV:
-                True # self.av.witerate()
-            self.iterate(100)
-
-        LOG.info('Ending loop.')
-
-    def iterate(self, n=100):
-        interval = self._tox.iteration_interval()
-        for i in range(n):
-            self._tox.iterate()
-            sleep(interval / 1000.0)
-            self._tox.iterate()
-
-    def on_friend_request(self, pk, message):
-        LOG.debug('Friend request from %s: %s' % (pk, message))
-        self._tox.friend_add_norequest(pk)
-        LOG.info('on_friend_request Accepted.')
-        save_to_file(self._tox, sDATA_FILE)
-
-    def on_friend_message(self, friendId, type, message):
-        name = self._tox.friend_get_name(friendId)
-        LOG.debug('%s: %s' % (name, message))
-        yMessage = bytes(message, 'UTF-8')
-        self._tox.friend_send_message(friendId, TOX_MESSAGE_TYPE['NORMAL'], yMessage)
-        LOG.info('EchoBot sent: %s' % message)
-
-    def on_file_recv_chunk(self, fid, filenumber, position, data):
-        filename = self.files[(fid, filenumber)]['filename']
-        size = self.files[(fid, filenumber)]['size']
-        LOG.debug(f"on_file_recv_chunk {fid!s} {filenumber!s} {filename} {position/float(size)*100!s}")
-
-        if data is None:
-            msg = "I got '{}', sending it back right away!".format(filename)
-            self._tox.friend_send_message(fid, TOX_MESSAGE_TYPE['NORMAL'], msg)
-
-            self.files[(fid, 0)] = self.files[(fid, filenumber)]
-
-            length = self.files[(fid, filenumber)]['size']
-            self.file_send(fid, 0, length, filename, filename)
-
-            del self.files[(fid, filenumber)]
-            return
-
-        self.files[(fid, filenumber)]['f'] += data
-
-def iMain(oArgs):
-    global sDATA_FILE
-    # oTOX_OPTIONS = ToxOptions()
-    global oTOX_OPTIONS
-    oTOX_OPTIONS = oToxygenToxOptions(oArgs)
-    opts = oTOX_OPTIONS
-    if coloredlogs:
-        coloredlogs.install(
-                            level=oArgs.loglevel,
-                            logger=LOG,
-                            # %(asctime)s,%(msecs)03d %(hostname)s [%(process)d]
-                            fmt='%(name)s %(levelname)s %(message)s'
-                        )
-    else:
-        if 'logfile' in oArgs:
-            logging.basicConfig(filename=oArgs.logfile,
-                                level=oArgs.loglevel,
-                                format='%(levelname)-8s %(message)s')
-        else:
-            logging.basicConfig(level=oArgs.loglevel,
-                                format='%(levelname)-8s %(message)s')
-
-    iRet = 0
-    if hasattr(oArgs,'profile') and oArgs.profile and os.path.isfile(oArgs.profile):
-        sDATA_FILE = oArgs.profile
-        LOG.info(f"loading from  {sDATA_FILE}")
-        opts.savedata_data = load_from_file(sDATA_FILE)
-        opts.savedata_length = len(opts.savedata_data)
-        opts.savedata_type = enums.TOX_SAVEDATA_TYPE['TOX_SAVE']
-    else:
-        opts.savedata_data = None
-
-    try:
-        if False:
-            oTox = tox_factory(data=opts.savedata_data,
-                        settings=opts, args=oArgs, app=None)
-        else:
-            oTox = wrapper.tox.Tox(opts)
-        t = EchoBot(oTox)
-        t._oargs = oArgs
-        t.start()
-        t.loop()
-        save_to_file(t._tox, sDATA_FILE)
-    except KeyboardInterrupt:
-        save_to_file(t._tox, sDATA_FILE)
-    except RuntimeError as e:
-        LOG.error(f"exiting with  {e}")
-        iRet = 1
-    except Exception as e:
-        LOG.error(f"exiting with  {e}")
-        LOG.warn(' iMain(): ' \
-                     +'\n' + traceback.format_exc())
-        iRet = 1
-    return iRet
-
-def oToxygenToxOptions(oArgs, data=None):
-    tox_options = wrapper.tox.Tox.options_new()
-
-    tox_options.contents.local_discovery_enabled = False
-    tox_options.contents.dht_announcements_enabled = False
-    tox_options.contents.hole_punching_enabled = False
-    tox_options.contents.experimental_thread_safety = False
-    tox_options.contents.ipv6_enabled = False
-    tox_options.contents.tcp_port = 3390
-
-    if oArgs.proxy_type > 0:
-        tox_options.contents.proxy_type = int(oArgs.proxy_type)
-        tox_options.contents.proxy_host = bytes(oArgs.proxy_host, 'UTF-8')
-        tox_options.contents.proxy_port = int(oArgs.proxy_port)
-        tox_options.contents.udp_enabled = False
-        LOG.debug('setting oArgs.proxy_host = ' +oArgs.proxy_host)
-    else:
-        tox_options.contents.udp_enabled = True
-
-    if data:  # load existing profile
-        tox_options.contents.savedata_type = enums.TOX_SAVEDATA_TYPE['TOX_SAVE']
-        tox_options.contents.savedata_data = c_char_p(data)
-        tox_options.contents.savedata_length = len(data)
-    else:  # create new profile
-        tox_options.contents.savedata_type = enums.TOX_SAVEDATA_TYPE['NONE']
-        tox_options.contents.savedata_data = None
-        tox_options.contents.savedata_length = 0
-
-    if tox_options._options_pointer:
-        ts.vAddLoggerCallback(tox_options, ts.on_log)
-    else:
-        logging.warn("No tox_options._options_pointer " +repr(tox_options._options_pointer))
-
-    return tox_options
-
-def oArgparse(lArgv):
-    parser = ts.oMainArgparser()
-    parser.add_argument('profile', type=str, nargs='?',
-                        default=sDATA_FILE,
-                        help='Path to Tox profile to save')
-    oArgs = parser.parse_args(lArgv)
-    if hasattr(oArgs, 'sleep') and oArgs.sleep == 'qt':
-        pass # broken
-    else:
-        oArgs.sleep = 'time'
-    for key in ts.lBOOLEANS:
-        if key not in oArgs: continue
-        val = getattr(oArgs, key)
-        if val in ['False', 'false', 0]:
-            setattr(oArgs, key, False)
-        else:
-            setattr(oArgs, key, True)
-    if not os.path.exists('/proc/sys/net/ipv6') and oArgs.ipv6_enabled:
-        LOG.warn('setting oArgs.ipv6_enabled = False')
-        oArgs.ipv6_enabled = False
-    return oArgs
-
-def main(largs=None):
-    if largs is None: largs = []
-    oArgs = oArgparse(largs)
-    global     oTOX_OARGS
-    oTOX_OARGS = oArgs
-    print(oArgs)
-
-    if coloredlogs:
-        logger = logging.getLogger()
-        # https://pypi.org/project/coloredlogs/
-        coloredlogs.install(level=oArgs.loglevel,
-                        logger=logger,
-                        # %(asctime)s,%(msecs)03d %(hostname)s [%(process)d]
-                        fmt='%(name)s %(levelname)s %(message)s'
-                        )
-    else:
-        logging.basicConfig(level=oArgs.loglevel) #  logging.INFO
-
-    return iMain(oArgs)
-
-
-if __name__ == '__main__':
-    sys.exit(main(sys.argv[1:]))

toxygen/tests/socks.py

@@ -1,3 +1,5 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 """SocksiPy - Python SOCKS module.
 Version 1.00
 

toxygen/tests/support_testing.py

@@ -1,914 +0,0 @@
-# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-
-import argparse
-import contextlib
-import inspect
-import json
-import logging
-import os
-import re
-import select
-import shutil
-import socket
-import sys
-import time
-import traceback
-import unittest
-from ctypes import *
-from random import Random
-import functools
-
-random = Random()
-
-try:
-    import coloredlogs
-    if 'COLOREDLOGS_LEVEL_STYLES' not in os.environ:
-        os.environ['COLOREDLOGS_LEVEL_STYLES'] = 'spam=22;debug=28;verbose=34;notice=220;warning=202;success=118,bold;error=124;critical=background=red'
-    # https://pypi.org/project/coloredlogs/
-except ImportError as e:
-    coloredlogs = False
-try:
-    import stem
-except ImportError as e:
-    stem = False
-try:
-    import nmap
-except ImportError as e:
-    nmap = False
-
-import wrapper
-from wrapper.toxcore_enums_and_consts import TOX_CONNECTION, TOX_USER_STATUS
-
-from wrapper_tests.support_http import bAreWeConnected
-from wrapper_tests.support_onions import (is_valid_fingerprint,
-                                          lIntroductionPoints,
-                                          oGetStemController,
-                                          sMapaddressResolv, sTorResolve)
-
-try:
-    from user_data.settings import get_user_config_path
-except ImportError:
-    get_user_config_path = None
-
-# LOG=util.log
-global LOG
-LOG = logging.getLogger()
-
-def LOG_ERROR(l): print('ERRORc: '+l)
-def LOG_WARN(l):  print('WARNc: ' +l)
-def LOG_INFO(l):  print('INFOc: ' +l)
-def LOG_DEBUG(l): print('DEBUGc: '+l)
-def LOG_TRACE(l): pass # print('TRACE+ '+l)
-
-try:
-    from trepan.api import debug
-    from trepan.interfaces import server as Mserver
-except:
-#    print('trepan3 TCP server NOT available.')
-    pass
-else:
-#    print('trepan3 TCP server available.')
-    def trepan_handler(num=None, f=None):
-        connection_opts={'IO': 'TCP', 'PORT': 6666}
-        intf = Mserver.ServerInterface(connection_opts=connection_opts)
-        dbg_opts = { 'interface': intf }
-        print(f'Starting TCP server listening on port 6666.')
-        debug(dbg_opts=dbg_opts)
-        return
-
-# self._audio_thread.isAlive
-iTHREAD_TIMEOUT = 1
-iTHREAD_SLEEP = 1
-iTHREAD_JOINS = 8
-iNODES = 6
-
-lToxSamplerates = [8000, 12000, 16000, 24000, 48000]
-lToxSampleratesK = [8, 12, 16, 24, 48]
-lBOOLEANS = [
-        'local_discovery_enabled',
-        'udp_enabled',
-        'ipv6_enabled',
-        'trace_enabled',
-        'compact_mode',
-        'allow_inline',
-        'notifications',
-        'sound_notifications',
-        'calls_sound',
-        'hole_punching_enabled',
-        'dht_announcements_enabled',
-        'save_history',
-        'download_nodes_list'
-        'core_logging',
-        ]
-
-sDIR = os.environ.get('TMPDIR', '/tmp')
-sTOX_VERSION = "1000002018"
-bHAVE_NMAP = shutil.which('nmap')
-bHAVE_JQ = shutil.which('jq')
-bHAVE_BASH = shutil.which('bash')
-bHAVE_TORR = shutil.which('tor-resolve')
-
-lDEAD_BS = [
-    # Failed to resolve "tox3.plastiras.org"
-    "tox3.plastiras.org",
-    'tox.kolka.tech',
-    # IPs that do not reverse resolve
-    '49.12.229.145',
-    "46.101.197.175",
-    '114.35.245.150',
-    '172.93.52.70',
-    '195.123.208.139',
-    '205.185.115.131',
-    # IPs that do not rreverse resolve
-    'yggnode.cf', '188.225.9.167',
-    '85-143-221-42.simplecloud.ru', '85.143.221.42',
-    # IPs that do not ping
-    '104.244.74.69', 'tox.plastiras.org',
-    '195.123.208.139',
-    'gt.sot-te.ch', '32.226.5.82',
-    # suspicious IPs
-    'tox.abilinski.com', '172.103.164.250', '172.103.164.250.tpia.cipherkey.com',
-    ]
-
-
-def assert_main_thread():
-    from PyQt5 import QtCore, QtWidgets
-    from qtpy.QtWidgets import QApplication
-
-    # this "instance" method is very useful!
-    app_thread = QtWidgets.QApplication.instance().thread()
-    curr_thread = QtCore.QThread.currentThread()
-    if app_thread != curr_thread:
-        raise RuntimeError('attempt to call MainWindow.append_message from non-app thread')
-
-@contextlib.contextmanager
-def ignoreStdout():
-    devnull = os.open(os.devnull, os.O_WRONLY)
-    old_stdout = os.dup(1)
-    sys.stdout.flush()
-    os.dup2(devnull, 1)
-    os.close(devnull)
-    try:
-        yield
-    finally:
-        os.dup2(old_stdout, 1)
-        os.close(old_stdout)
-
-@contextlib.contextmanager
-def ignoreStderr():
-    devnull = os.open(os.devnull, os.O_WRONLY)
-    old_stderr = os.dup(2)
-    sys.stderr.flush()
-    os.dup2(devnull, 2)
-    os.close(devnull)
-    try:
-        yield
-    finally:
-        os.dup2(old_stderr, 2)
-        os.close(old_stderr)
-
-def clean_booleans(oArgs):
-    for key in lBOOLEANS:
-        if not hasattr(oArgs, key): continue
-        val = getattr(oArgs, key)
-        if type(val) == bool: continue
-        if val in ['False', 'false', '0']:
-            setattr(oArgs, key, False)
-        else:
-            setattr(oArgs, key, True)
-
-def on_log(iTox, level, filename, line, func, message, *data):
-    # LOG.debug(repr((level, filename, line, func, message,)))
-    tox_log_cb(level, filename, line, func, message)
-
-def tox_log_cb(level, filename, line, func, message, *args):
-    """
-    * @param level The severity of the log message.
-    * @param filename The source file from which the message originated.
-    * @param line The source line from which the message originated.
-    * @param func The function from which the message originated.
-    * @param message The log message.
-    * @param user_data The user data pointer passed to tox_new in options.
-    """
-    if type(func) == bytes:
-        func = str(func, 'utf-8')
-        message = str(message, 'UTF-8')
-        filename = str(filename, 'UTF-8')
-
-        if filename == 'network.c':
-            if line == 660: return
-                # root WARNING 3network.c#944:b'send_packet'attempted to send message with network family 10 (probably IPv6) on IPv4 socket
-            if line == 944: return
-            i = message.find('07 = GET_NODES')
-            if i > 0:
-                return
-        if filename == 'TCP_common.c': return
-
-        i = message.find(' | ')
-        if i > 0:
-            message = message[:i]
-        # message = filename +'#' +str(line) +':'+func +' '+message
-
-        name = 'core'
-        # old level is meaningless
-        level = 10 # LOG.level
-
-        # LOG._log(LOG.level, f"{level}: {message}", list())
-
-        i = message.find('(0: OK)')
-        if i > 0:
-            level = 10 # LOG.debug
-        else:
-            i = message.find('(1: ')
-            if i > 0:
-                level = 30 # LOG.warn
-            else:
-                level = 20 # LOG.info
-
-        o = LOG.makeRecord(filename, level, func, line, message, list(), None)
-        # LOG.handle(o)
-        LOG_TRACE(f"{level}: {func}{line} {message}")
-        return
-
-    elif level == 1:
-        LOG.critical(f"{level}: {message}")
-    elif level == 2:
-        LOG.error(f"{level}: {message}")
-    elif level == 3:
-        LOG.warn(f"{level}: {message}")
-    elif level == 4:
-        LOG.info(f"{level}: {message}")
-    elif level == 5:
-        LOG.debug(f"{level}: {message}")
-    else:
-        LOG_TRACE(f"{level}: {message}")
-
-def vAddLoggerCallback(tox_options, callback=None):
-    if callback is None:
-        wrapper.tox.Tox.libtoxcore.tox_options_set_log_callback(
-            tox_options._options_pointer,
-            POINTER(None)())
-        tox_options.self_logger_cb = None
-        return
-
-    c_callback = CFUNCTYPE(None, c_void_p, c_int, c_char_p, c_int, c_char_p, c_char_p, c_void_p)
-    tox_options.self_logger_cb = c_callback(callback)
-    wrapper.tox.Tox.libtoxcore.tox_options_set_log_callback(
-        tox_options._options_pointer,
-        tox_options.self_logger_cb)
-
-def get_video_indexes():
-    # Linux
-    return [str(l[5:]) for l in os.listdir('/dev/') if l.startswith('video')]
-
-def get_audio():
-    with ignoreStderr():
-        import pyaudio
-    oPyA = pyaudio.PyAudio()
-
-    input_devices = output_devices = 0
-    for i in range(oPyA.get_device_count()):
-        device = oPyA.get_device_info_by_index(i)
-        if device["maxInputChannels"]:
-            input_devices += 1
-        if device["maxOutputChannels"]:
-            output_devices += 1
-    # {'index': 21, 'structVersion': 2, 'name': 'default', 'hostApi': 0, 'maxInputChannels': 64, 'maxOutputChannels': 64, 'defaultLowInputLatency': 0.008707482993197279, 'defaultLowOutputLatency': 0.008707482993197279, 'defaultHighInputLatency': 0.034829931972789115, 'defaultHighOutputLatency': 0.034829931972789115, 'defaultSampleRate': 44100.0}
-    audio = {'input': oPyA.get_default_input_device_info()['index'] if input_devices else -1,
-             'output': oPyA.get_default_output_device_info()['index'] if output_devices else -1,
-             'enabled': input_devices and output_devices}
-    return audio
-
-def oMainArgparser(_=None, iMode=0):
-    # 'Mode: 0=chat 1=chat+audio 2=chat+audio+video default: 0'
-    if not os.path.exists('/proc/sys/net/ipv6'):
-        bIpV6 = 'False'
-    else:
-        bIpV6 = 'True'
-    lIpV6Choices=[bIpV6, 'False']
-
-    sNodesJson = os.path.join(os.environ['HOME'], '.config', 'tox', 'DHTnodes.json')
-    if not os.path.exists(sNodesJson): sNodesJson = ''
-
-    logfile = os.path.join(os.environ.get('TMPDIR', '/tmp'), 'toxygen.log')
-    if not os.path.exists(sNodesJson): logfile = ''
-
-    parser = argparse.ArgumentParser(add_help=True)
-    parser.add_argument('--proxy_host', '--proxy-host', type=str,
-                        # oddball - we want to use '' as a setting
-                        default='0.0.0.0',
-                        help='proxy host')
-    parser.add_argument('--proxy_port', '--proxy-port', default=0, type=int,
-                        help='proxy port')
-    parser.add_argument('--proxy_type', '--proxy-type', default=0, type=int,
-                        choices=[0,1,2],
-                        help='proxy type 1=http, 2=socks')
-    parser.add_argument('--tcp_port', '--tcp-port', default=0, type=int,
-                        help='tcp port')
-    parser.add_argument('--udp_enabled', type=str, default='True',
-                        choices=['True', 'False'],
-                        help='En/Disable udp')
-    parser.add_argument('--ipv6_enabled', type=str, default=bIpV6,
-                        choices=lIpV6Choices,
-                        help=f"En/Disable ipv6 - default  {bIpV6}")
-    parser.add_argument('--trace_enabled',type=str,
-                        default='True' if os.environ.get('DEBUG') else 'False',
-                        choices=['True','False'],
-                        help='Debugging from toxcore logger_trace or env DEBUG=1')
-    parser.add_argument('--download_nodes_list', type=str, default='False',
-                        choices=['True', 'False'],
-                        help='Download nodes list')
-    parser.add_argument('--nodes_json', type=str,
-                        default=sNodesJson)
-    parser.add_argument('--network', type=str,
-                        choices=['main', 'local'],
-                        default='main')
-    parser.add_argument('--download_nodes_url', type=str,
-                        default='https://nodes.tox.chat/json')
-    parser.add_argument('--logfile', default=logfile,
-                        help='Filename for logging - start with + for stdout too')
-    parser.add_argument('--loglevel', default=logging.INFO, type=int,
-                        # choices=[logging.info,logging.trace,logging.debug,logging.error]
-                        help='Threshold for logging (lower is more) default: 20')
-    parser.add_argument('--mode', type=int, default=iMode,
-                        choices=[0,1,2],
-                        help='Mode: 0=chat 1=chat+audio 2=chat+audio+video default: 0')
-    parser.add_argument('--hole_punching_enabled',type=str,
-                        default='False', choices=['True','False'],
-                        help='En/Enable hole punching')
-    parser.add_argument('--dht_announcements_enabled',type=str,
-                        default='True', choices=['True','False'],
-                        help='En/Disable DHT announcements')
-    return parser
-
-def vSetupLogging(oArgs):
-    global LOG
-    logging._defaultFormatter = logging.Formatter(datefmt='%m-%d %H:%M:%S')
-    logging._defaultFormatter.default_time_format = '%m-%d %H:%M:%S'
-    logging._defaultFormatter.default_msec_format = ''
-
-    add = None
-    kwargs = dict(level=oArgs.loglevel,
-                  format='%(levelname)-8s %(message)s')
-    if oArgs.logfile:
-        add = oArgs.logfile.startswith('+')
-        sub = oArgs.logfile.startswith('-')
-        if add or sub:
-            oArgs.logfile = oArgs.logfile[1:]
-        kwargs['filename'] = oArgs.logfile
-
-    if coloredlogs:
-        # https://pypi.org/project/coloredlogs/
-        aKw = dict(level=oArgs.loglevel,
-                   logger=LOG,
-                   stream=sys.stdout,
-                   fmt='%(name)s %(levelname)s %(message)s'
-                   )
-        coloredlogs.install(**aKw)
-        if oArgs.logfile:
-            oHandler = logging.FileHandler(oArgs.logfile)
-            LOG.addHandler(oHandler)
-    else:
-        logging.basicConfig(**kwargs)
-        if add:
-            oHandler = logging.StreamHandler(sys.stdout)
-            LOG.addHandler(oHandler)
-
-    LOG.info(f"Setting loglevel to {oArgs.loglevel!s}")
-
-
-def setup_logging(oArgs):
-    global LOG
-    if coloredlogs:
-        aKw = dict(level=oArgs.loglevel,
-                   logger=LOG,
-                   fmt='%(name)s %(levelname)s %(message)s')
-        if oArgs.logfile:
-            oFd = open(oArgs.logfile, 'wt')
-            setattr(oArgs, 'log_oFd', oFd)
-            aKw['stream'] = oFd
-        coloredlogs.install(**aKw)
-        if oArgs.logfile:
-            oHandler = logging.StreamHandler(stream=sys.stdout)
-            LOG.addHandler(oHandler)
-    else:
-        aKw = dict(level=oArgs.loglevel,
-                   format='%(name)s %(levelname)-4s %(message)s')
-        if oArgs.logfile:
-            aKw['filename'] = oArgs.logfile
-        logging.basicConfig(**aKw)
-
-    logging._defaultFormatter = logging.Formatter(datefmt='%m-%d %H:%M:%S')
-    logging._defaultFormatter.default_time_format = '%m-%d %H:%M:%S'
-    logging._defaultFormatter.default_msec_format = ''
-
-    LOG.setLevel(oArgs.loglevel)
-#    LOG.trace = lambda l: LOG.log(0, repr(l))
-    LOG.info(f"Setting loglevel to {oArgs.loglevel!s}")
-
-def signal_handler(num, f):
-    from trepan.api import debug
-    from trepan.interfaces import server as Mserver
-    connection_opts={'IO': 'TCP', 'PORT': 6666}
-    intf = Mserver.ServerInterface(connection_opts=connection_opts)
-    dbg_opts = {'interface': intf}
-    LOG.info('Starting TCP server listening on port 6666.')
-    debug(dbg_opts=dbg_opts)
-    return
-
-def merge_args_into_settings(args, settings):
-    if args:
-        if not hasattr(args, 'audio'):
-            LOG.warn('No audio ' +repr(args))
-        settings['audio'] = getattr(args, 'audio')
-        if not hasattr(args, 'video'):
-            LOG.warn('No video ' +repr(args))
-        settings['video'] = getattr(args, 'video')
-        for key in settings.keys():
-            # proxy_type proxy_port proxy_host
-            not_key = 'not_' +key
-            if hasattr(args, key):
-                val = getattr(args, key)
-                if type(val) == bytes:
-                    # proxy_host - ascii?
-                    # filenames - ascii?
-                    val = str(val, 'UTF-8')
-                settings[key] = val
-            elif hasattr(args, not_key):
-                val = not getattr(args, not_key)
-                settings[key] = val
-    clean_settings(settings)
-    return
-
-def clean_settings(self):
-    # failsafe to ensure C tox is bytes and Py settings is str
-
-    # overrides
-    self['mirror_mode'] = False
-    # REQUIRED!!
-    if not os.path.exists('/proc/sys/net/ipv6'):
-        LOG.warn('Disabling IPV6 because /proc/sys/net/ipv6 does not exist')
-        self['ipv6_enabled'] = False
-
-    if 'proxy_type' in self and self['proxy_type'] == 0:
-        self['proxy_host'] = ''
-        self['proxy_port'] = 0
-
-    if 'proxy_type' in self and self['proxy_type'] != 0 and \
-        'proxy_host' in self and self['proxy_host'] != '' and \
-        'proxy_port' in self and self['proxy_port'] != 0:
-        if 'udp_enabled' in self and self['udp_enabled']:
-            # We don't currently support UDP over proxy.
-            LOG.info("UDP enabled and proxy set: disabling UDP")
-        self['udp_enabled'] = False
-        if 'local_discovery_enabled' in self and self['local_discovery_enabled']:
-            LOG.info("local_discovery_enabled enabled and proxy set: disabling local_discovery_enabled")
-        self['local_discovery_enabled'] = False
-        if 'dht_announcements_enabled' in self and self['dht_announcements_enabled']:
-            LOG.info("dht_announcements_enabled enabled and proxy set: disabling dht_announcements_enabled")
-        self['dht_announcements_enabled'] = False
-
-    if 'auto_accept_path' in self and \
-       type(self['auto_accept_path']) == bytes:
-        self['auto_accept_path'] = str(self['auto_accept_path'], 'UTF-8')
-
-    LOG.debug("Cleaned settings")
-
-def lSdSamplerates(iDev):
-    try:
-        import sounddevice as sd
-    except ImportError:
-        return []
-    samplerates = (32000, 44100, 48000, 96000, )
-    device = iDev
-    supported_samplerates = []
-    for fs in samplerates:
-        try:
-            sd.check_output_settings(device=device, samplerate=fs)
-        except Exception as e:
-            # LOG.debug(f"Sample rate not supported {fs}" +' '+str(e))
-            pass
-        else:
-            supported_samplerates.append(fs)
-    return supported_samplerates
-
-def _get_nodes_path(oArgs=None):
-    if oArgs and oArgs.nodes_json and os.path.isfile(oArgs.nodes_json):
-        LOG.debug("_get_nodes_path: " +oArgs.nodes_json)
-        default = oArgs.nodes_json
-    elif get_user_config_path:
-        default = os.path.join(get_user_config_path(), 'toxygen_nodes.json')
-    else:
-        # Windwoes
-        default = os.path.join(os.getenv('HOME'), '.config', 'tox', 'toxygen_nodes.json')
-    LOG.debug("_get_nodes_path: " +default)
-    return default
-
-DEFAULT_NODES_COUNT = 8
-
-global aNODES
-aNODES = {}
-
-
-# @functools.lru_cache(maxsize=12) TypeError: unhashable type: 'Namespace'
-def generate_nodes(oArgs=None,
-                   nodes_count=DEFAULT_NODES_COUNT,
-                   ipv='ipv4',
-                   udp_not_tcp=True):
-    global aNODES
-    sKey = ipv
-    sKey += ',0' if udp_not_tcp else ',1'
-    if sKey in aNODES and aNODES[sKey]:
-        return aNODES[sKey]
-    sFile = _get_nodes_path(oArgs=oArgs)
-    assert os.path.exists(sFile), sFile
-    lNodes = generate_nodes_from_file(sFile,
-                                      nodes_count=nodes_count,
-                                      ipv=ipv, udp_not_tcp=udp_not_tcp)
-    assert lNodes
-    aNODES[sKey] = lNodes
-    return aNODES[sKey]
-
-aNODES_CACHE = {}
-def generate_nodes_from_file(sFile,
-                             nodes_count=DEFAULT_NODES_COUNT,
-                             ipv='ipv4',
-                             udp_not_tcp=True,
-                             ):
-    """https://github.com/TokTok/c-toxcore/issues/469
-I had a conversation with @irungentoo on IRC about whether we really need to call tox_bootstrap() when having UDP disabled and why. The answer is yes, because in addition to TCP relays (tox_add_tcp_relay()), toxcore also needs to know addresses of UDP onion nodes in order to work correctly. The DHT, however, is not used when UDP is disabled. tox_bootstrap() function resolves the address passed to it as argument and calls onion_add_bs_node_path() and DHT_bootstrap() functions. Although calling DHT_bootstrap() is not really necessary as DHT is not used, we still need to resolve the address of the DHT node in order to populate the onion routes with onion_add_bs_node_path() call.
-"""
-    global aNODES_CACHE
-
-    key = ipv
-    key += ',0' if udp_not_tcp else ',1'
-    if key in aNODES_CACHE:
-        sorted_nodes =  aNODES_CACHE[key]
-    else:
-        if not os.path.exists(sFile):
-            LOG.error("generate_nodes_from_file file not found " +sFile)
-            return []
-        try:
-            with open(sFile, 'rt') as fl:
-                json_nodes = json.loads(fl.read())['nodes']
-        except Exception as e:
-            LOG.error(f"generate_nodes_from_file error {sFile}\n{e}")
-            return []
-        else:
-            LOG.debug("generate_nodes_from_file " +sFile)
-
-        if udp_not_tcp:
-            nodes = [(node[ipv], node['port'], node['public_key'],) for
-                     node in json_nodes if node[ipv] != 'NONE' \
-                          and node["status_udp"] in [True, "true"]
-                     ]
-        else:
-            nodes = []
-            elts = [(node[ipv], node['tcp_ports'], node['public_key'],) \
-                    for node in json_nodes if node[ipv] != 'NONE' \
-                        and node["status_tcp"] in [True, "true"]
-                    ]
-            for (ipv, ports, public_key,) in elts:
-                for port in ports:
-                    nodes += [(ipv, port, public_key)]
-        if not nodes:
-            LOG.warn(f'empty generate_nodes from {sFile} {json_nodes!r}')
-            return []
-        sorted_nodes = nodes
-        aNODES_CACHE[key] = sorted_nodes
-
-    random.shuffle(sorted_nodes)
-    if nodes_count is not None and len(sorted_nodes) > nodes_count:
-        sorted_nodes = sorted_nodes[-nodes_count:]
-    LOG.debug(f"generate_nodes_from_file {sFile} len={len(sorted_nodes)}")
-    return sorted_nodes
-
-def tox_bootstrapd_port():
-    port = 33446
-    sFile = '/etc/tox-bootstrapd.conf'
-    if os.path.exists(sFile):
-        with open(sFile, 'rt') as oFd:
-            for line in  oFd.readlines():
-                if line.startswith('port = '):
-                    port = int(line[7:])
-    return port
-
-def bootstrap_local(elts, lToxes, oArgs=None):
-    if os.path.exists('/run/tox-bootstrapd/tox-bootstrapd.pid'):
-        LOG.debug('/run/tox-bootstrapd/tox-bootstrapd.pid')
-        iRet = True
-    else:
-        iRet = os.system("netstat -nle4|grep -q :33")
-        if iRet > 0:
-            LOG.warn(f'bootstraping local No local DHT running')
-    LOG.info(f'bootstraping local')
-    return bootstrap_udp(elts, lToxes, oArgs)
-
-def lDNSClean(l):
-    global lDEAD_BS
-    # list(set(l).difference(set(lDEAD_BS)))
-    return [elt for elt in l if elt not in lDEAD_BS]
-
-def lExitExcluder(oArgs, iPort=9051):
-    """
-    https://raw.githubusercontent.com/nusenu/noContactInfo_Exit_Excluder/main/exclude_noContactInfo_Exits.py
-    """
-    if not stem:
-        LOG.warn('please install the stem Python package')
-        return ''
-    LOG.debug('lExcludeExitNodes')
-
-    try:
-        controller = oGetStemController(log_level=10)
-        # generator
-        relays = controller.get_server_descriptors()
-    except Exception as e:
-        LOG.error(f'Failed to get relay descriptors {e}')
-        return None
-
-    if controller.is_set('ExcludeExitNodes'):
-        LOG.info('ExcludeExitNodes is in use already.')
-        return None
-
-    exit_excludelist=[]
-    LOG.debug("Excluded exit relays:")
-    for relay in relays:
-        if relay.exit_policy.is_exiting_allowed() and not relay.contact:
-            if is_valid_fingerprint(relay.fingerprint):
-                exit_excludelist.append(relay.fingerprint)
-                LOG.debug("https://metrics.torproject.org/rs.html#details/%s" % relay.fingerprint)
-            else:
-                LOG.warn('Invalid Fingerprint: %s' % relay.fingerprint)
-
-    try:
-        controller.set_conf('ExcludeExitNodes', exit_excludelist)
-        LOG.info('Excluded a total of %s exit relays without ContactInfo from the exit position.' % len(exit_excludelist))
-    except Exception as e:
-        LOG.exception('ExcludeExitNodes ' +str(e))
-    return exit_excludelist
-
-aHOSTS = {}
-@functools.lru_cache(maxsize=20)
-def sDNSLookup(host):
-    global aHOSTS
-    ipv = 0
-    if host in lDEAD_BS:
-#        LOG.warn(f"address skipped because in lDEAD_BS {host}")
-        return ''
-    if host in aHOSTS:
-        return aHOSTS[host]
-
-    try:
-        s = host.replace('.','')
-        int(s)
-        ipv = 4
-    except:
-        try:
-            s = host.replace(':','')
-            int(s)
-            ipv = 6
-        except: pass
-
-    if ipv > 0:
-#        LOG.debug(f"v={ipv} IP address {host}")
-        return host
-
-    LOG.debug(f"sDNSLookup {host}")
-    ip = ''
-    if host.endswith('.tox') or host.endswith('.onion'):
-        if False and stem:
-            ip = sMapaddressResolv(host)
-            if ip: return ip
-
-        ip = sTorResolve(host)
-        if ip: return ip
-
-        if not bHAVE_TORR:
-            LOG.warn(f"onion address skipped because no tor-resolve {host}")
-            return ''
-        try:
-            sout = f"/tmp/TR{os.getpid()}.log"
-            i = os.system(f"tor-resolve -4 {host} > {sout}")
-            if not i:
-                LOG.warn(f"onion address skipped because tor-resolve on {host}")
-                return ''
-            ip = open(sout, 'rt').read()
-            if ip.endswith('failed.'):
-                LOG.warn(f"onion address skipped because tor-resolve failed on {host}")
-                return ''
-            LOG.debug(f"onion address tor-resolve {ip} on {host}")
-            return ip
-        except:
-            pass
-    else:
-        try:
-            ip = socket.gethostbyname(host)
-            LOG.debug(f"host={host} gethostbyname IP address {ip}")
-            if ip:
-                aHOSTS[host] = ip
-                return ip
-            # drop through
-        except:
-            # drop through
-            pass
-
-    if ip == '':
-        try:
-            sout = f"/tmp/TR{os.getpid()}.log"
-            i = os.system(f"dig {host} +timeout=15|grep ^{host}|sed -e 's/.* //'> {sout}")
-            if not i:
-                LOG.warn(f"address skipped because dig failed on {host}")
-                return ''
-            ip = open(sout, 'rt').read().strip()
-            LOG.debug(f"address dig {ip} on {host}")
-            aHOSTS[host] = ip
-            return ip
-        except:
-            ip = host
-    LOG.debug(f'sDNSLookup {host} -> {ip}')
-    if ip and ip != host:
-        aHOSTS[host] = ip
-    return ip
-
-def bootstrap_udp(lelts, lToxes, oArgs=None):
-    lelts = lDNSClean(lelts)
-    socket.setdefaulttimeout(15.0)
-    for oTox in lToxes:
-        random.shuffle(lelts)
-        if hasattr(oTox, 'oArgs'):
-            oArgs = oTox.oArgs
-            if hasattr(oArgs, 'contents') and oArgs.contents.proxy_type != 0:
-                lelts = lelts[:1]
-
-#        LOG.debug(f'bootstrap_udp DHT bootstraping {oTox.name} {len(lelts)}')
-        for largs in lelts:
-            assert len(largs) == 3
-            host, port, key = largs
-            assert host; assert port; assert key
-            if host in lDEAD_BS: continue
-            ip = sDNSLookup(host)
-            if not ip:
-                LOG.warn(f'bootstrap_udp to host={host} port={port} did not resolve ip={ip}')
-                continue
-
-            if type(port) == str:
-                port = int(port)
-            try:
-                assert len(key) == 64, key
-                # NOT ip
-                oRet = oTox.bootstrap(host,
-                                     port,
-                                     key)
-            except Exception as e:
-                if oArgs is None or (
-                    hasattr(oArgs, 'contents') and oArgs.contents.proxy_type == 0):
-                    pass
-                    # LOG.error(f'bootstrap_udp failed to host={host} port={port} {e}')
-                continue
-            if not oRet:
-                LOG.warn(f'bootstrap_udp failed to {host} :  {oRet}')
-            elif oTox.self_get_connection_status() != TOX_CONNECTION['NONE']:
-                LOG.info(f'bootstrap_udp to {host} connected')
-                break
-            else:
-#                LOG.debug(f'bootstrap_udp to {host} not connected')
-                pass
-
-def bootstrap_tcp(lelts, lToxes, oArgs=None):
-    lelts = lDNSClean(lelts)
-    for oTox in lToxes:
-        if hasattr(oTox, 'oArgs'): oArgs = oTox.oArgs
-        random.shuffle(lelts)
-#        LOG.debug(f'bootstrap_tcp bootstapping {oTox.name} {len(lelts)}')
-        for (host, port, key,) in lelts:
-            assert host; assert port;assert key
-            if host in lDEAD_BS: continue
-            ip = sDNSLookup(host)
-            if not ip:
-                LOG.warn(f'bootstrap_tcp to {host} did not resolve ip={ip}')
-#                continue
-                ip = host
-            if host.endswith('.onion') and stem:
-                l = lIntroductionPoints(host)
-                if not l:
-                    LOG.warn(f'bootstrap_tcp to {host} has no introduction points')
-                    continue
-            if type(port) == str:
-                port = int(port)
-            try:
-                assert len(key) == 64, key
-                oRet = oTox.add_tcp_relay(ip,
-                                         port,
-                                         key)
-            except Exception as e:
-                LOG.error(f'bootstrap_tcp to {host} : ' +str(e))
-                continue
-            if not oRet:
-                LOG.warn(f'bootstrap_tcp failed to {host} : {oRet}')
-            elif oTox.mycon_time == 1:
-                LOG.info(f'bootstrap_tcp to {host} not yet connected last=1')
-            elif oTox.mycon_status is False:
-                LOG.info(f'bootstrap_tcp to {host} not True' \
-                         +f" last={int(oTox.mycon_time)}" )
-            elif oTox.self_get_connection_status() != TOX_CONNECTION['NONE']:
-                LOG.info(f'bootstrap_tcp to {host} connected' \
-                         +f" last={int(oTox.mycon_time)}" )
-                break
-            else:
-                LOG.debug(f'bootstrap_tcp to {host} but not connected' \
-                         +f" last={int(oTox.mycon_time)}" )
-                pass
-
-def iNmapInfoNmap(sProt, sHost, sPort, key=None, environ=None, cmd=''):
-    if sHost in ['-', 'NONE']: return 0
-    if not nmap: return 0
-    nmps = nmap.PortScanner
-    if sProt in ['socks', 'socks5', 'tcp4']:
-        prot = 'tcp'
-        cmd = f" -Pn -n -sT -p T:{sPort}"
-    else:
-        prot = 'udp'
-        cmd = f" -Pn -n -sU -p U:{sPort}"
-    LOG.debug(f"iNmapInfoNmap cmd={cmd}")
-    sys.stdout.flush()
-    o = nmps().scan(hosts=sHost, arguments=cmd)
-    aScan = o['scan']
-    ip = list(aScan.keys())[0]
-    state = aScan[ip][prot][sPort]['state']
-    LOG.info(f"iNmapInfoNmap: to {sHost} {state}")
-    return 0
-
-def iNmapInfo(sProt, sHost, sPort, key=None, environ=None, cmd='nmap'):
-    if sHost in ['-', 'NONE']: return 0
-    sFile = os.path.join("/tmp", f"{sHost}.{os.getpid()}.nmap")
-    if sProt in ['socks', 'socks5', 'tcp4']:
-        cmd += f" -Pn -n -sT -p T:{sPort} {sHost} | grep /tcp "
-    else:
-        cmd += f" -Pn -n -sU -p U:{sPort} {sHost} | grep /udp "
-    LOG.debug(f"iNmapInfo cmd={cmd}")
-    sys.stdout.flush()
-    iRet = os.system('sudo ' +cmd +f" >{sFile} 2>&1 ")
-    LOG.debug(f"iNmapInfo cmd={cmd} iRet={iRet}")
-    if iRet != 0:
-        return iRet
-    assert os.path.exists(sFile), sFile
-    with open(sFile, 'rt') as oFd:
-        l = oFd.readlines()
-    assert len(l)
-    l = [line for line in l if line and not line.startswith('WARNING:')]
-    s = '\n'.join([s.strip() for s in l])
-    LOG.info(f"iNmapInfo: to {sHost}\n{s}")
-    return 0
-
-def bootstrap_iNmapInfo(lElts, oArgs, protocol="tcp4", bIS_LOCAL=False, iNODES=iNODES, cmd='nmap'):
-    if not bIS_LOCAL and not bAreWeConnected():
-        LOG.warn(f"bootstrap_iNmapInfo not local and NOT CONNECTED")
-        return True
-    if os.environ['USER'] != 'root':
-        LOG.warn(f"bootstrap_iNmapInfo not ROOT")
-        return True
-
-    lRetval = []
-    for elts in lElts[:iNODES]:
-        host, port, key = elts
-        ip = sDNSLookup(host)
-        if not ip:
-            LOG.info('bootstrap_iNmapInfo to {host} did not resolve ip={ip}')
-            continue
-        if type(port) == str:
-            port = int(port)
-        iRet = -1
-        try:
-            if not nmap:
-                iRet = iNmapInfo(protocol, ip, port, key, cmd=cmd)
-            else:
-                iRet = iNmapInfoNmap(protocol, ip, port, key)
-            if iRet != 0:
-                LOG.warn('iNmapInfo to ' +repr(host) +' retval=' +str(iRet))
-                lRetval += [False]
-            else:
-                LOG.debug('iNmapInfo to ' +repr(host) +' retval=' +str(iRet))
-                lRetval += [True]
-        except Exception as e:
-            LOG.exception('iNmapInfo to {host} : ' +str(e)
-                          )
-            lRetval += [False]
-    return any(lRetval)
-
-def caseFactory(cases):
-    """We want the tests run in order."""
-    if len(cases) > 1:
-        ordered_cases = sorted(cases, key=lambda f: inspect.findsource(f)[1])
-    else:
-        ordered_cases = cases
-    return ordered_cases
-
-def suiteFactory(*testcases):
-    """We want the tests run in order."""
-    linen    = lambda f: getattr(tc, f).__code__.co_firstlineno
-    lncmp = lambda a, b: linen(a) - linen(b)
-
-    test_suite = unittest.TestSuite()
-    for tc in testcases:
-        test_suite.addTest(unittest.makeSuite(tc, sortUsing=lncmp))
-    return test_suite

toxygen/tests/test_gdb.py

@@ -1,3 +1,5 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
 # Verify that gdb can pretty-print the various PyObject* types
 #
 # The code for testing gdb was adapted from similar work in Unladen Swallow's
@@ -854,14 +856,14 @@ id(42)
         cmd = textwrap.dedent('''
             class MyList(list):
                 def __init__(self):
-                    super().__init__()   # wrapper_call()
+                    super().__init__()   # toxygen_wrapper_call()
 
             id("first break point")
             l = MyList()
         ''')
         # Verify with "py-bt":
         gdb_output = self.get_stack_trace(cmd,
-                                          cmds_after_breakpoint=['break wrapper_call', 'continue', 'py-bt'])
+                                          cmds_after_breakpoint=['break toxygen_wrapper_call', 'continue', 'py-bt'])
         self.assertRegex(gdb_output,
                          r"<method-wrapper u?'__init__' of MyList object at ")
 

toxygen/tests/tests_socks.py

@@ -67,10 +67,10 @@ except ImportError as e:
     logging.log(logging.DEBUG, f"color_runner not available:  {e}")
     color_runner = None
 
-import wrapper
+import toxygen_wrapper
-import wrapper.toxcore_enums_and_consts as enums
+import toxygen_wrapper.toxcore_enums_and_consts as enums
-from wrapper.tox import Tox
+from toxygen_wrapper.tox import Tox
-from wrapper.toxcore_enums_and_consts import (TOX_ADDRESS_SIZE, TOX_CONNECTION,
+from toxygen_wrapper.toxcore_enums_and_consts import (TOX_ADDRESS_SIZE, TOX_CONNECTION,
                                               TOX_FILE_CONTROL,
                                               TOX_MESSAGE_TYPE,
                                               TOX_SECRET_KEY_SIZE,
@@ -79,7 +79,7 @@ from wrapper.toxcore_enums_and_consts import (TOX_ADDRESS_SIZE, TOX_CONNECTION,
 try:
     import support_testing as ts
 except ImportError:
-    import wrapper_tests.support_testing as ts
+    import toxygen_wrapper.tests.support_testing as ts
 
 try:
     from tests.toxygen_tests import test_sound_notification
@@ -87,7 +87,7 @@ try:
 except ImportError:
     bIS_NOT_TOXYGEN = True
 
-# from PyQt5 import QtCore
+# from  qtpy import QtCore
 import time
 
 sleep = time.sleep
@@ -511,7 +511,7 @@ class ToxSuite(unittest.TestCase):
             try:
                 oRet = method(*args)
                 if oRet:
-                    LOG.info(f"wait_ensure_exec oRet {oRet!r}")
+                    LOG.info(f"wait_ensure_exec oRet {oRet}")
                     return True
             except ArgumentError as e:
                 #  ArgumentError('This client is currently NOT CONNECTED to the friend.')
@@ -1788,7 +1788,7 @@ def iMain(oArgs):
 
 def oToxygenToxOptions(oArgs):
     data = None
-    tox_options = wrapper.tox.Tox.options_new()
+    tox_options = toxygen_wrapper.tox.Tox.options_new()
     if oArgs.proxy_type:
         tox_options.contents.proxy_type = int(oArgs.proxy_type)
         tox_options.contents.proxy_host = bytes(oArgs.proxy_host, 'UTF-8')

toxygen/tests/toxygen_tests.py

@@ -1,17 +0,0 @@
-# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-
-from notifications import sound
-from notifications.sound import SOUND_NOTIFICATION
-from time import sleep
-
-if True:
-    def test_sound_notification(self):
-        """
-        Plays sound notification
-        :param  type of notification
-        """
-        sound.sound_notification( SOUND_NOTIFICATION['MESSAGE'] )
-        sleep(10)
-        sound.sound_notification( SOUND_NOTIFICATION['FILE_TRANSFER'] )
-        sleep(10)
-        sound.sound_notification( None )

toxygen/third_party/qweechat/__init__.py

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#

toxygen/third_party/qweechat/about.py

@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# about.py - about dialog box
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""About dialog box."""
-
-from PyQt5 import QtCore, QtWidgets as QtGui
-
-from third_party.qweechat.version import qweechat_version
-
-
-class AboutDialog(QtGui.QDialog):
-    """About dialog."""
-
-    def __init__(self, app_name, author, weechat_site, *args):
-        QtGui.QDialog.__init__(*(self,) + args)
-        self.setModal(True)
-        self.setWindowTitle('About')
-
-        close_button = QtGui.QPushButton('Close')
-        close_button.pressed.connect(self.close)
-
-        hbox = QtGui.QHBoxLayout()
-        hbox.addStretch(1)
-        hbox.addWidget(close_button)
-        hbox.addStretch(1)
-
-        vbox = QtGui.QVBoxLayout()
-        messages = [
-            f'<b>{app_name}</b> {qweechat_version()}',
-            f'© 2011-2022 {author}',
-            '',
-            f'<a href="{weechat_site}">{weechat_site}</a>',
-            '',
-        ]
-        for msg in messages:
-            label = QtGui.QLabel(msg)
-            label.setAlignment(QtCore.Qt.AlignHCenter)
-            vbox.addWidget(label)
-        vbox.addLayout(hbox)
-
-        self.setLayout(vbox)
-        self.show()

toxygen/third_party/qweechat/buffer.py

@@ -1,250 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# buffer.py - management of WeeChat buffers/nicklist
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Management of WeeChat buffers/nicklist."""
-
-from pkg_resources import resource_filename
-
-from PyQt5 import QtCore, QtGui, QtWidgets
-from PyQt5.QtCore import pyqtSignal
-Signal = pyqtSignal
-
-from third_party.qweechat.chat import ChatTextEdit
-from third_party.qweechat.input import InputLineEdit
-from third_party.qweechat.weechat import color
-
-
-class GenericListWidget(QtWidgets.QListWidget):
-    """Generic QListWidget with dynamic size."""
-
-    def __init__(self, *args):
-        super().__init__(*args)
-        self.setMaximumWidth(100)
-        self.setTextElideMode(QtCore.Qt.ElideNone)
-        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        self.setFocusPolicy(QtCore.Qt.NoFocus)
-        pal = self.palette()
-        pal.setColor(QtGui.QPalette.Highlight, QtGui.QColor('#ddddff'))
-        pal.setColor(QtGui.QPalette.HighlightedText, QtGui.QColor('black'))
-        self.setPalette(pal)
-
-    def auto_resize(self):
-        size = self.sizeHintForColumn(0)
-        if size > 0:
-            size += 4
-        self.setMaximumWidth(size)
-
-    def clear(self, *args):
-        """Re-implement clear to set dynamic size after clear."""
-        QtWidgets.QListWidget.clear(*(self,) + args)
-        self.auto_resize()
-
-    def addItem(self, *args):
-        """Re-implement addItem to set dynamic size after add."""
-        QtWidgets.QListWidget.addItem(*(self,) + args)
-        self.auto_resize()
-
-    def insertItem(self, *args):
-        """Re-implement insertItem to set dynamic size after insert."""
-        QtWidgets.QListWidget.insertItem(*(self,) + args)
-        self.auto_resize()
-
-
-class BufferListWidget(GenericListWidget):
-    """Widget with list of buffers."""
-
-    def switch_prev_buffer(self):
-        if self.currentRow() > 0:
-            self.setCurrentRow(self.currentRow() - 1)
-        else:
-            self.setCurrentRow(self.count() - 1)
-
-    def switch_next_buffer(self):
-        if self.currentRow() < self.count() - 1:
-            self.setCurrentRow(self.currentRow() + 1)
-        else:
-            self.setCurrentRow(0)
-
-
-class BufferWidget(QtWidgets.QWidget):
-    """
-    Widget with (from top to bottom):
-    title, chat + nicklist (optional) + prompt/input.
-    """
-
-    def __init__(self, display_nicklist=False):
-        super().__init__()
-
-        # title
-        self.title = QtWidgets.QLineEdit()
-        self.title.setFocusPolicy(QtCore.Qt.NoFocus)
-
-        # splitter with chat + nicklist
-        self.chat_nicklist = QtWidgets.QSplitter()
-        self.chat_nicklist.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
-                                         QtWidgets.QSizePolicy.Expanding)
-        self.chat = ChatTextEdit(debug=False)
-        self.chat_nicklist.addWidget(self.chat)
-        self.nicklist = GenericListWidget()
-        if not display_nicklist:
-            self.nicklist.setVisible(False)
-        self.chat_nicklist.addWidget(self.nicklist)
-
-        # prompt + input
-        self.hbox_edit = QtWidgets.QHBoxLayout()
-        self.hbox_edit.setContentsMargins(0, 0, 0, 0)
-        self.hbox_edit.setSpacing(0)
-        self.input = InputLineEdit(self.chat)
-        self.hbox_edit.addWidget(self.input)
-        prompt_input = QtWidgets.QWidget()
-        prompt_input.setLayout(self.hbox_edit)
-
-        # vbox with title + chat/nicklist + prompt/input
-        vbox = QtWidgets.QVBoxLayout()
-        vbox.setContentsMargins(0, 0, 0, 0)
-        vbox.setSpacing(0)
-        vbox.addWidget(self.title)
-        vbox.addWidget(self.chat_nicklist)
-        vbox.addWidget(prompt_input)
-
-        self.setLayout(vbox)
-
-    def set_title(self, title):
-        """Set buffer title."""
-        self.title.clear()
-        if title is not None:
-            self.title.setText(title)
-
-    def set_prompt(self, prompt):
-        """Set prompt."""
-        if self.hbox_edit.count() > 1:
-            self.hbox_edit.takeAt(0)
-        if prompt is not None:
-            label = QtWidgets.QLabel(prompt)
-            label.setContentsMargins(0, 0, 5, 0)
-            self.hbox_edit.insertWidget(0, label)
-
-
-class Buffer(QtCore.QObject):
-    """A WeeChat buffer."""
-
-    bufferInput = Signal(str, str)
-
-    def __init__(self, data=None):
-        QtCore.QObject.__init__(self)
-        self.data = data or {}
-        self.nicklist = {}
-        self.widget = BufferWidget(display_nicklist=self.data.get('nicklist',
-                                                                  0))
-        self.update_title()
-        self.update_prompt()
-        self.widget.input.textSent.connect(self.input_text_sent)
-
-    def pointer(self):
-        """Return pointer on buffer."""
-        return self.data.get('__path', [''])[0]
-
-    def update_title(self):
-        """Update title."""
-        try:
-            self.widget.set_title(
-                color.remove(self.data['title']))
-        except Exception:  # noqa: E722
-            # TODO: Debug print the exception to be fixed.
-            # traceback.print_exc()
-            self.widget.set_title(None)
-
-    def update_prompt(self):
-        """Update prompt."""
-        try:
-            self.widget.set_prompt(self.data['local_variables']['nick'])
-        except Exception:  # noqa: E722
-            self.widget.set_prompt(None)
-
-    def input_text_sent(self, text):
-        """Called when text has to be sent to buffer."""
-        if self.data:
-            self.bufferInput.emit(self.data['full_name'], text)
-
-    def nicklist_add_item(self, parent, group, prefix, name, visible):
-        """Add a group/nick in nicklist."""
-        if group:
-            self.nicklist[name] = {
-                'visible': visible,
-                'nicks': []
-            }
-        else:
-            self.nicklist[parent]['nicks'].append({
-                'prefix': prefix,
-                'name': name,
-                'visible': visible,
-            })
-
-    def nicklist_remove_item(self, parent, group, name):
-        """Remove a group/nick from nicklist."""
-        if group:
-            if name in self.nicklist:
-                del self.nicklist[name]
-        else:
-            if parent in self.nicklist:
-                self.nicklist[parent]['nicks'] = [
-                    nick for nick in self.nicklist[parent]['nicks']
-                    if nick['name'] != name
-                ]
-
-    def nicklist_update_item(self, parent, group, prefix, name, visible):
-        """Update a group/nick in nicklist."""
-        if group:
-            if name in self.nicklist:
-                self.nicklist[name]['visible'] = visible
-        else:
-            if parent in self.nicklist:
-                for nick in self.nicklist[parent]['nicks']:
-                    if nick['name'] == name:
-                        nick['prefix'] = prefix
-                        nick['visible'] = visible
-                        break
-
-    def nicklist_refresh(self):
-        """Refresh nicklist."""
-        self.widget.nicklist.clear()
-        for group in sorted(self.nicklist):
-            for nick in sorted(self.nicklist[group]['nicks'],
-                               key=lambda n: n['name']):
-                prefix_color = {
-                    '': '',
-                    ' ': '',
-                    '+': 'yellow',
-                }
-                col = prefix_color.get(nick['prefix'], 'green')
-                if col:
-                    icon = QtGui.QIcon(
-                        resource_filename(__name__,
-                                          'data/icons/bullet_%s_8x8.png' %
-                                          col))
-                else:
-                    pixmap = QtGui.QPixmap(8, 8)
-                    pixmap.fill()
-                    icon = QtGui.QIcon(pixmap)
-                item = QtWidgets.QListWidgetItem(icon, nick['name'])
-                self.widget.nicklist.addItem(item)
-                self.widget.nicklist.setVisible(True)

toxygen/third_party/qweechat/chat.py

@@ -1,142 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# chat.py - chat area
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Chat area."""
-
-import datetime
-
-from PyQt5 import QtCore, QtWidgets, QtGui
-
-from third_party.qweechat import config
-from third_party.qweechat.weechat import color
-
-
-class ChatTextEdit(QtWidgets.QTextEdit):
-    """Chat area."""
-
-    def __init__(self, debug, *args):
-        QtWidgets.QTextEdit.__init__(*(self,) + args)
-        self.debug = debug
-        self.readOnly = True
-        self.setFocusPolicy(QtCore.Qt.NoFocus)
-        self.setFontFamily('monospace')
-        self._textcolor = self.textColor()
-        self._bgcolor = QtGui.QColor('#FFFFFF')
-        self._setcolorcode = {
-            'F': (self.setTextColor, self._textcolor),
-            'B': (self.setTextBackgroundColor, self._bgcolor)
-        }
-        self._setfont = {
-            '*': self.setFontWeight,
-            '_': self.setFontUnderline,
-            '/': self.setFontItalic
-        }
-        self._fontvalues = {
-            False: {
-                '*': QtGui.QFont.Normal,
-                '_': False,
-                '/': False
-            },
-            True: {
-                '*': QtGui.QFont.Bold,
-                '_': True,
-                '/': True
-            }
-        }
-        self._color = color.Color(config.color_options(), self.debug)
-
-    def display(self, time, prefix, text, forcecolor=None):
-        if time == 0:
-            now = datetime.datetime.now()
-        else:
-            now = datetime.datetime.fromtimestamp(float(time))
-        self.setTextColor(QtGui.QColor('#999999'))
-        self.insertPlainText(now.strftime('%H:%M '))
-        prefix = self._color.convert(prefix)
-        text = self._color.convert(text)
-        if forcecolor:
-            if prefix:
-                prefix = '\x01(F%s)%s' % (forcecolor, prefix)
-            text = '\x01(F%s)%s' % (forcecolor, text)
-        if prefix:
-            self._display_with_colors(prefix + ' ')
-        if text:
-            self._display_with_colors(text)
-            if text[-1:] != '\n':
-                self.insertPlainText('\n')
-        else:
-            self.insertPlainText('\n')
-        self.scroll_bottom()
-
-    def _display_with_colors(self, string):
-        self.setTextColor(self._textcolor)
-        self.setTextBackgroundColor(self._bgcolor)
-        self._reset_attributes()
-        items = string.split('\x01')
-        for i, item in enumerate(items):
-            if i > 0 and item.startswith('('):
-                pos = item.find(')')
-                if pos >= 2:
-                    action = item[1]
-                    code = item[2:pos]
-                    if action == '+':
-                        # set attribute
-                        self._set_attribute(code[0], True)
-                    elif action == '-':
-                        # remove attribute
-                        self._set_attribute(code[0], False)
-                    else:
-                        # reset attributes and color
-                        if code == 'r':
-                            self._reset_attributes()
-                            self._setcolorcode[action][0](
-                                self._setcolorcode[action][1])
-                        else:
-                            # set attributes + color
-                            while code.startswith(('*', '!', '/', '_', '|',
-                                                   'r')):
-                                if code[0] == 'r':
-                                    self._reset_attributes()
-                                elif code[0] in self._setfont:
-                                    self._set_attribute(
-                                        code[0],
-                                        not self._font[code[0]])
-                                code = code[1:]
-                            if code:
-                                self._setcolorcode[action][0](
-                                    QtGui.QColor(code))
-                    item = item[pos+1:]
-            if len(item) > 0:
-                self.insertPlainText(item)
-
-    def _reset_attributes(self):
-        self._font = {}
-        for attr in self._setfont:
-            self._set_attribute(attr, False)
-
-    def _set_attribute(self, attr, value):
-        self._font[attr] = value
-        self._setfont[attr](self._fontvalues[self._font[attr]][attr])
-
-    def scroll_bottom(self):
-        scroll = self.verticalScrollBar()
-        scroll.setValue(scroll.maximum())

toxygen/third_party/qweechat/config.py

@@ -1,136 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# config.py - configuration for QWeeChat
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Configuration for QWeeChat."""
-
-import configparser
-import os
-
-from pathlib import Path
-
-CONFIG_DIR = '%s/.config/qweechat' % os.getenv('HOME')
-CONFIG_FILENAME = '%s/qweechat.conf' % CONFIG_DIR
-
-CONFIG_DEFAULT_RELAY_LINES = 50
-
-CONFIG_DEFAULT_SECTIONS = ('relay', 'look', 'color')
-CONFIG_DEFAULT_OPTIONS = (('relay.hostname', '127.0.0.1'),
-                          ('relay.port', '9000'),
-                          ('relay.ssl', 'off'),
-                          ('relay.password', ''),
-                          ('relay.autoconnect', 'off'),
-                          ('relay.lines', str(CONFIG_DEFAULT_RELAY_LINES)),
-                          ('look.debug', 'off'),
-                          ('look.statusbar', 'on'))
-
-# Default colors for WeeChat color options (option name, #rgb value)
-CONFIG_DEFAULT_COLOR_OPTIONS = (
-    ('separator', '#000066'),  # 0
-    ('chat', '#000000'),  # 1
-    ('chat_time', '#999999'),  # 2
-    ('chat_time_delimiters', '#000000'),  # 3
-    ('chat_prefix_error', '#FF6633'),  # 4
-    ('chat_prefix_network', '#990099'),  # 5
-    ('chat_prefix_action', '#000000'),  # 6
-    ('chat_prefix_join', '#00CC00'),  # 7
-    ('chat_prefix_quit', '#CC0000'),  # 8
-    ('chat_prefix_more', '#CC00FF'),  # 9
-    ('chat_prefix_suffix', '#330099'),  # 10
-    ('chat_buffer', '#000000'),  # 11
-    ('chat_server', '#000000'),  # 12
-    ('chat_channel', '#000000'),  # 13
-    ('chat_nick', '#000000'),  # 14
-    ('chat_nick_self', '*#000000'),  # 15
-    ('chat_nick_other', '#000000'),  # 16
-    ('', '#000000'),  # 17 (nick1 -- obsolete)
-    ('', '#000000'),  # 18 (nick2 -- obsolete)
-    ('', '#000000'),  # 19 (nick3 -- obsolete)
-    ('', '#000000'),  # 20 (nick4 -- obsolete)
-    ('', '#000000'),  # 21 (nick5 -- obsolete)
-    ('', '#000000'),  # 22 (nick6 -- obsolete)
-    ('', '#000000'),  # 23 (nick7 -- obsolete)
-    ('', '#000000'),  # 24 (nick8 -- obsolete)
-    ('', '#000000'),  # 25 (nick9 -- obsolete)
-    ('', '#000000'),  # 26 (nick10 -- obsolete)
-    ('chat_host', '#666666'),  # 27
-    ('chat_delimiters', '#9999FF'),  # 28
-    ('chat_highlight', '#3399CC'),  # 29
-    ('chat_read_marker', '#000000'),  # 30
-    ('chat_text_found', '#000000'),  # 31
-    ('chat_value', '#000000'),  # 32
-    ('chat_prefix_buffer', '#000000'),  # 33
-    ('chat_tags', '#000000'),  # 34
-    ('chat_inactive_window', '#000000'),  # 35
-    ('chat_inactive_buffer', '#000000'),  # 36
-    ('chat_prefix_buffer_inactive_buffer', '#000000'),  # 37
-    ('chat_nick_offline', '#000000'),  # 38
-    ('chat_nick_offline_highlight', '#000000'),  # 39
-    ('chat_nick_prefix', '#000000'),  # 40
-    ('chat_nick_suffix', '#000000'),  # 41
-    ('emphasis', '#000000'),  # 42
-    ('chat_day_change', '#000000'),  # 43
-)
-config_color_options = []
-
-
-def read():
-    """Read config file."""
-    global config_color_options
-    config = configparser.RawConfigParser()
-    if os.path.isfile(CONFIG_FILENAME):
-        config.read(CONFIG_FILENAME)
-
-    # add missing sections/options
-    for section in CONFIG_DEFAULT_SECTIONS:
-        if not config.has_section(section):
-            config.add_section(section)
-    for option in reversed(CONFIG_DEFAULT_OPTIONS):
-        section, name = option[0].split('.', 1)
-        if not config.has_option(section, name):
-            config.set(section, name, option[1])
-    section = 'color'
-    for option in reversed(CONFIG_DEFAULT_COLOR_OPTIONS):
-        if option[0] and not config.has_option(section, option[0]):
-            config.set(section, option[0], option[1])
-
-    # build list of color options
-    config_color_options = []
-    for option in CONFIG_DEFAULT_COLOR_OPTIONS:
-        if option[0]:
-            config_color_options.append(config.get('color', option[0]))
-        else:
-            config_color_options.append('#000000')
-
-    return config
-
-
-def write(config):
-    """Write config file."""
-    Path(CONFIG_DIR).mkdir(mode=0o0700, parents=True, exist_ok=True)
-    with open(CONFIG_FILENAME, 'w') as cfg:
-        config.write(cfg)
-
-
-def color_options():
-    """Return color options."""
-    global config_color_options
-    return config_color_options

toxygen/third_party/qweechat/connection.py

@@ -1,128 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# connection.py - connection window
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Connection window."""
-
-from PyQt5 import QtGui, QtWidgets
-
-
-class ConnectionDialog(QtWidgets.QDialog):
-    """Connection window."""
-
-    def __init__(self, values, *args):
-        super().__init__(*args)
-        self.values = values
-        self.setModal(True)
-        self.setWindowTitle('Connect to WeeChat')
-
-        grid = QtWidgets.QGridLayout()
-        grid.setSpacing(10)
-
-        self.fields = {}
-        focus = None
-
-        # hostname
-        grid.addWidget(QtWidgets.QLabel('<b>Hostname</b>'), 0, 0)
-        line_edit = QtWidgets.QLineEdit()
-        line_edit.setFixedWidth(200)
-        value = self.values.get('hostname', '')
-        if value in ['None', None]: value = ''
-        line_edit.insert(value)
-        grid.addWidget(line_edit, 0, 1)
-        self.fields['hostname'] = line_edit
-        if not focus and not value:
-            focus = 'hostname'
-
-        # port / SSL
-        grid.addWidget(QtWidgets.QLabel('<b>Port</b>'), 1, 0)
-        line_edit = QtWidgets.QLineEdit()
-        line_edit.setFixedWidth(200)
-        value = self.values.get('port', '')
-        if value in ['None', None]:
-            value = '0'
-        elif type(value) == int:
-            value = str(value)
-        line_edit.insert(value)
-        grid.addWidget(line_edit, 1, 1)
-        self.fields['port'] = line_edit
-        if not focus and not value:
-            focus = 'port'
-
-        ssl = QtWidgets.QCheckBox('SSL')
-        ssl.setChecked(self.values['ssl'] == 'on')
-        grid.addWidget(ssl, 1, 2)
-        self.fields['ssl'] = ssl
-
-        # password
-        grid.addWidget(QtWidgets.QLabel('<b>Password</b>'), 2, 0)
-        line_edit = QtWidgets.QLineEdit()
-        line_edit.setFixedWidth(200)
-        line_edit.setEchoMode(QtWidgets.QLineEdit.Password)
-        value = self.values.get('password', '')
-        if value in ['None', None]: value = ''
-        line_edit.insert(value)
-        grid.addWidget(line_edit, 2, 1)
-        self.fields['password'] = line_edit
-        if not focus and not value:
-            focus = 'password'
-
-        # TOTP (Time-Based One-Time Password)
-        label = QtWidgets.QLabel('TOTP')
-        label.setToolTip('Time-Based One-Time Password (6 digits)')
-        grid.addWidget(label, 3, 0)
-        line_edit = QtWidgets.QLineEdit()
-        line_edit.setPlaceholderText('6 digits')
-        validator = QtGui.QIntValidator(0, 999999, self)
-        line_edit.setValidator(validator)
-        line_edit.setFixedWidth(80)
-        value = self.values.get('totp', '')
-        line_edit.insert(value)
-        grid.addWidget(line_edit, 3, 1)
-        self.fields['totp'] = line_edit
-        if not focus and not value:
-            focus = 'totp'
-
-        # lines
-        grid.addWidget(QtWidgets.QLabel('Lines'), 4, 0)
-        line_edit = QtWidgets.QLineEdit()
-        line_edit.setFixedWidth(200)
-        validator = QtGui.QIntValidator(0, 2147483647, self)
-        line_edit.setValidator(validator)
-        line_edit.setFixedWidth(80)
-        value = self.values.get('lines', '')
-        line_edit.insert(value)
-        grid.addWidget(line_edit, 4, 1)
-        self.fields['lines'] = line_edit
-        if not focus and not value:
-            focus = 'lines'
-
-        self.dialog_buttons = QtWidgets.QDialogButtonBox()
-        self.dialog_buttons.setStandardButtons(
-            QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
-        self.dialog_buttons.rejected.connect(self.close)
-
-        grid.addWidget(self.dialog_buttons, 5, 0, 1, 2)
-        self.setLayout(grid)
-        self.show()
-
-        if focus:
-            self.fields[focus].setFocus()

toxygen/third_party/qweechat/debug.py

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# debug.py - debug window
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Debug window."""
-
-from PyQt5 import QtWidgets
-
-from third_party.qweechat.chat import ChatTextEdit
-from third_party.qweechat.input import InputLineEdit
-
-
-class DebugDialog(QtWidgets.QDialog):
-    """Debug dialog."""
-
-    def __init__(self, *args):
-        QtWidgets.QDialog.__init__(*(self,) + args)
-        self.resize(1024, 768)
-        self.setWindowTitle('Debug console')
-
-        self.chat = ChatTextEdit(debug=True)
-        self.input = InputLineEdit(self.chat)
-
-        vbox = QtWidgets.QVBoxLayout()
-        vbox.addWidget(self.chat)
-        vbox.addWidget(self.input)
-
-        self.setLayout(vbox)
-        self.show()
-
-    def display_lines(self, lines):
-        for line in lines:
-            self.chat.display(*line[0], **line[1])

toxygen/third_party/qweechat/input.py

@@ -1,96 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# input.py - input line for chat and debug window
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Input line for chat and debug window."""
-
-from PyQt5 import QtCore, QtWidgets
-from PyQt5.QtCore import pyqtSignal
-Signal = pyqtSignal
-
-class InputLineEdit(QtWidgets.QLineEdit):
-    """Input line."""
-
-    bufferSwitchPrev = Signal()
-    bufferSwitchNext = Signal()
-    textSent = Signal(str)
-
-    def __init__(self, scroll_widget):
-        super().__init__()
-        self.scroll_widget = scroll_widget
-        self._history = []
-        self._history_index = -1
-        self.returnPressed.connect(self._input_return_pressed)
-
-    def keyPressEvent(self, event):
-        key = event.key()
-        modifiers = event.modifiers()
-        scroll = self.scroll_widget.verticalScrollBar()
-        if modifiers == QtCore.Qt.ControlModifier:
-            if key == QtCore.Qt.Key_PageUp:
-                self.bufferSwitchPrev.emit()
-            elif key == QtCore.Qt.Key_PageDown:
-                self.bufferSwitchNext.emit()
-            else:
-                QtWidgets.QLineEdit.keyPressEvent(self, event)
-        elif modifiers == QtCore.Qt.AltModifier:
-            if key in (QtCore.Qt.Key_Left, QtCore.Qt.Key_Up):
-                self.bufferSwitchPrev.emit()
-            elif key in (QtCore.Qt.Key_Right, QtCore.Qt.Key_Down):
-                self.bufferSwitchNext.emit()
-            elif key == QtCore.Qt.Key_PageUp:
-                scroll.setValue(scroll.value() - (scroll.pageStep() / 10))
-            elif key == QtCore.Qt.Key_PageDown:
-                scroll.setValue(scroll.value() + (scroll.pageStep() / 10))
-            elif key == QtCore.Qt.Key_Home:
-                scroll.setValue(scroll.minimum())
-            elif key == QtCore.Qt.Key_End:
-                scroll.setValue(scroll.maximum())
-            else:
-                QtWidgets.QLineEdit.keyPressEvent(self, event)
-        elif key == QtCore.Qt.Key_PageUp:
-            scroll.setValue(scroll.value() - scroll.pageStep())
-        elif key == QtCore.Qt.Key_PageDown:
-            scroll.setValue(scroll.value() + scroll.pageStep())
-        elif key == QtCore.Qt.Key_Up:
-            self._history_navigate(-1)
-        elif key == QtCore.Qt.Key_Down:
-            self._history_navigate(1)
-        else:
-            QtWidgets.QLineEdit.keyPressEvent(self, event)
-
-    def _input_return_pressed(self):
-        self._history.append(self.text())
-        self._history_index = len(self._history)
-        self.textSent.emit(self.text())
-        self.clear()
-
-    def _history_navigate(self, direction):
-        if self._history:
-            self._history_index += direction
-            if self._history_index < 0:
-                self._history_index = 0
-                return
-            if self._history_index > len(self._history) - 1:
-                self._history_index = len(self._history)
-                self.clear()
-                return
-            self.setText(self._history[self._history_index])

toxygen/third_party/qweechat/network.py

@@ -1,358 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# network.py - I/O with WeeChat/relay
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""I/O with WeeChat/relay."""
-
-import hashlib
-import secrets
-import struct
-
-from PyQt5 import QtCore, QtNetwork
-from PyQt5.QtCore import pyqtSignal
-Signal = pyqtSignal
-
-from third_party.qweechat import config
-from third_party.qweechat.debug import DebugDialog
-
-
-# list of supported hash algorithms on our side
-# (the hash algorithm will be negotiated with the remote WeeChat)
-_HASH_ALGOS_LIST = [
-    'plain',
-    'sha256',
-    'sha512',
-    'pbkdf2+sha256',
-    'pbkdf2+sha512',
-]
-_HASH_ALGOS = ':'.join(_HASH_ALGOS_LIST)
-
-# handshake with remote WeeChat (before init)
-_PROTO_HANDSHAKE = f'(handshake) handshake password_hash_algo={_HASH_ALGOS}\n'
-
-# initialize with the password (plain text)
-_PROTO_INIT_PWD = 'init password=%(password)s%(totp)s\n'  # nosec
-
-# initialize with the hashed password
-_PROTO_INIT_HASH = ('init password_hash='
-                    '%(algo)s:%(salt)s%(iter)s:%(hash)s%(totp)s\n')
-
-_PROTO_SYNC_CMDS = [
-    # get buffers
-    '(listbuffers) hdata buffer:gui_buffers(*) number,full_name,short_name,'
-    'type,nicklist,title,local_variables',
-    # get lines
-    '(listlines) hdata buffer:gui_buffers(*)/own_lines/last_line(-%(lines)d)/'
-    'data date,displayed,prefix,message',
-    # get nicklist for all buffers
-    '(nicklist) nicklist',
-    # enable synchronization
-    'sync',
-]
-
-STATUS_DISCONNECTED = 'disconnected'
-STATUS_CONNECTING = 'connecting'
-STATUS_AUTHENTICATING = 'authenticating'
-STATUS_CONNECTED = 'connected'
-
-NETWORK_STATUS = {
-    STATUS_DISCONNECTED: {
-        'label': 'Disconnected',
-        'color': '#aa0000',
-        'icon': 'dialog-close.png',
-    },
-    STATUS_CONNECTING: {
-        'label': 'Connecting…',
-        'color': '#dd5f00',
-        'icon': 'dialog-warning.png',
-    },
-    STATUS_AUTHENTICATING: {
-        'label': 'Authenticating…',
-        'color': '#007fff',
-        'icon': 'dialog-password.png',
-    },
-    STATUS_CONNECTED: {
-        'label': 'Connected',
-        'color': 'green',
-        'icon': 'dialog-ok-apply.png',
-    },
-}
-
-
-class Network(QtCore.QObject):
-    """I/O with WeeChat/relay."""
-
-    statusChanged = Signal(str, str)
-    messageFromWeechat = Signal(QtCore.QByteArray)
-
-    def __init__(self, *args):
-        super().__init__(*args)
-        self._init_connection()
-        self.debug_lines = []
-        self.debug_dialog = None
-        self._lines = config.CONFIG_DEFAULT_RELAY_LINES
-        self._buffer = QtCore.QByteArray()
-        self._socket = QtNetwork.QSslSocket()
-        self._socket.connected.connect(self._socket_connected)
-        self._socket.readyRead.connect(self._socket_read)
-        self._socket.disconnected.connect(self._socket_disconnected)
-
-    def _init_connection(self):
-        self.status = STATUS_DISCONNECTED
-        self._hostname = None
-        self._port = None
-        self._ssl = None
-        self._password = None
-        self._totp = None
-        self._handshake_received = False
-        self._handshake_timer = None
-        self._handshake_timer = False
-        self._pwd_hash_algo = None
-        self._pwd_hash_iter = 0
-        self._server_nonce = None
-
-    def set_status(self, status):
-        """Set current status."""
-        self.status = status
-        self.statusChanged.emit(status, None)
-
-    def pbkdf2(self, hash_name, salt):
-        """Return hashed password with PBKDF2-HMAC."""
-        return hashlib.pbkdf2_hmac(
-            hash_name,
-            password=self._password.encode('utf-8'),
-            salt=salt,
-            iterations=self._pwd_hash_iter,
-        ).hex()
-
-    def _build_init_command(self):
-        """Build the init command to send to WeeChat."""
-        totp = f',totp={self._totp}' if self._totp else ''
-        if self._pwd_hash_algo == 'plain':
-            cmd = _PROTO_INIT_PWD % {
-                'password': self._password,
-                'totp': totp,
-            }
-        else:
-            client_nonce = secrets.token_bytes(16)
-            salt = self._server_nonce + client_nonce
-            pwd_hash = None
-            iterations = ''
-            if self._pwd_hash_algo == 'pbkdf2+sha512':
-                pwd_hash = self.pbkdf2('sha512', salt)
-                iterations = f':{self._pwd_hash_iter}'
-            elif self._pwd_hash_algo == 'pbkdf2+sha256':
-                pwd_hash = self.pbkdf2('sha256', salt)
-                iterations = f':{self._pwd_hash_iter}'
-            elif self._pwd_hash_algo == 'sha512':
-                pwd = salt + self._password.encode('utf-8')
-                pwd_hash = hashlib.sha512(pwd).hexdigest()
-            elif self._pwd_hash_algo == 'sha256':
-                pwd = salt + self._password.encode('utf-8')
-                pwd_hash = hashlib.sha256(pwd).hexdigest()
-            if not pwd_hash:
-                return None
-            cmd = _PROTO_INIT_HASH % {
-                'algo': self._pwd_hash_algo,
-                'salt': bytearray(salt).hex(),
-                'iter': iterations,
-                'hash': pwd_hash,
-                'totp': totp,
-            }
-        return cmd
-
-    def _build_sync_command(self):
-        """Build the sync commands to send to WeeChat."""
-        cmd = '\n'.join(_PROTO_SYNC_CMDS) + '\n'
-        return cmd % {'lines': self._lines}
-
-    def handshake_timer_expired(self):
-        if self.status == STATUS_AUTHENTICATING:
-            self._pwd_hash_algo = 'plain'
-            self.send_to_weechat(self._build_init_command())
-            self.sync_weechat()
-            self.set_status(STATUS_CONNECTED)
-
-    def _socket_connected(self):
-        """Slot: socket connected."""
-        self.set_status(STATUS_AUTHENTICATING)
-        self.send_to_weechat(_PROTO_HANDSHAKE)
-        self._handshake_timer = QtCore.QTimer()
-        self._handshake_timer.setSingleShot(True)
-        self._handshake_timer.setInterval(2000)
-        self._handshake_timer.timeout.connect(self.handshake_timer_expired)
-        self._handshake_timer.start()
-
-    def _socket_read(self):
-        """Slot: data available on socket."""
-        data = self._socket.readAll()
-        self._buffer.append(data)
-        while len(self._buffer) >= 4:
-            remainder = None
-            length = struct.unpack('>i', self._buffer[0:4].data())[0]
-            if len(self._buffer) < length:
-                # partial message, just wait for end of message
-                break
-            # more than one message?
-            if length < len(self._buffer):
-                # save beginning of another message
-                remainder = self._buffer[length:]
-                self._buffer = self._buffer[0:length]
-            self.messageFromWeechat.emit(self._buffer)
-            if not self.is_connected():
-                return
-            self._buffer.clear()
-            if remainder:
-                self._buffer.append(remainder)
-
-    def _socket_disconnected(self):
-        """Slot: socket disconnected."""
-        if self._handshake_timer:
-            self._handshake_timer.stop()
-        self._init_connection()
-        self.set_status(STATUS_DISCONNECTED)
-
-    def is_connected(self):
-        """Return True if the socket is connected, False otherwise."""
-        return self._socket.state() == QtNetwork.QAbstractSocket.ConnectedState
-
-    def is_ssl(self):
-        """Return True if SSL is used, False otherwise."""
-        return self._ssl
-
-    def connect_weechat(self, hostname, port, ssl, password, totp, lines):
-        """Connect to WeeChat."""
-        self._hostname = hostname
-        try:
-            self._port = int(port)
-        except ValueError:
-            self._port = 0
-        self._ssl = ssl
-        self._password = password
-        self._totp = totp
-        try:
-            self._lines = int(lines)
-        except ValueError:
-            self._lines = config.CONFIG_DEFAULT_RELAY_LINES
-        if self._socket.state() == QtNetwork.QAbstractSocket.ConnectedState:
-            return
-        if self._socket.state() != QtNetwork.QAbstractSocket.UnconnectedState:
-            self._socket.abort()
-        if self._ssl:
-            self._socket.ignoreSslErrors()
-            self._socket.connectToHostEncrypted(self._hostname, self._port)
-        else:
-            self._socket.connectToHost(self._hostname, self._port)
-        self.set_status(STATUS_CONNECTING)
-
-    def disconnect_weechat(self):
-        """Disconnect from WeeChat."""
-        if self._socket.state() == QtNetwork.QAbstractSocket.UnconnectedState:
-            self.set_status(STATUS_DISCONNECTED)
-            return
-        if self._socket.state() == QtNetwork.QAbstractSocket.ConnectedState:
-            self.send_to_weechat('quit\n')
-            self._socket.waitForBytesWritten(1000)
-        else:
-            self.set_status(STATUS_DISCONNECTED)
-        self._socket.abort()
-
-    def send_to_weechat(self, message):
-        """Send a message to WeeChat."""
-        self.debug_print(0, '<==', message, forcecolor='#AA0000')
-        self._socket.write(message.encode('utf-8'))
-
-    def init_with_handshake(self, response):
-        """Initialize with WeeChat using the handshake response."""
-        self._pwd_hash_algo = response['password_hash_algo']
-        self._pwd_hash_iter = int(response['password_hash_iterations'])
-        self._server_nonce = bytearray.fromhex(response['nonce'])
-        if self._pwd_hash_algo:
-            cmd = self._build_init_command()
-            if cmd:
-                self.send_to_weechat(cmd)
-                self.sync_weechat()
-                self.set_status(STATUS_CONNECTED)
-                return
-        # failed to initialize: disconnect
-        self.disconnect_weechat()
-
-    def desync_weechat(self):
-        """Desynchronize from WeeChat."""
-        self.send_to_weechat('desync\n')
-
-    def sync_weechat(self):
-        """Synchronize with WeeChat."""
-        self.send_to_weechat(self._build_sync_command())
-
-    def status_label(self, status):
-        """Return the label for a given status."""
-        return NETWORK_STATUS.get(status, {}).get('label', '')
-
-    def status_color(self, status):
-        """Return the color for a given status."""
-        return NETWORK_STATUS.get(status, {}).get('color', 'black')
-
-    def status_icon(self, status):
-        """Return the name of icon for a given status."""
-        return NETWORK_STATUS.get(status, {}).get('icon', '')
-
-    def get_options(self):
-        """Get connection options."""
-        return {
-            'hostname': self._hostname,
-            'port': self._port,
-            'ssl': 'on' if self._ssl else 'off',
-            'password': self._password,
-            'lines': str(self._lines),
-        }
-
-    def debug_print(self, *args, **kwargs):
-        """Display a debug message."""
-        self.debug_lines.append((args, kwargs))
-        if self.debug_dialog:
-            self.debug_dialog.chat.display(*args, **kwargs)
-
-    def _debug_dialog_closed(self, result):
-        """Called when debug dialog is closed."""
-        self.debug_dialog = None
-
-    def debug_input_text_sent(self, text):
-        """Send debug buffer input to WeeChat."""
-        if self.network.is_connected():
-            text = str(text)
-            pos = text.find(')')
-            if text.startswith('(') and pos >= 0:
-                text = '(debug_%s)%s' % (text[1:pos], text[pos+1:])
-            else:
-                text = '(debug) %s' % text
-            self.network.debug_print(0, '<==', text, forcecolor='#AA0000')
-            self.network.send_to_weechat(text + '\n')
-
-    def open_debug_dialog(self):
-        """Open a dialog with debug messages."""
-        if not self.debug_dialog:
-            self.debug_dialog = DebugDialog()
-            self.debug_dialog.input.textSent.connect(
-                self.debug_input_text_sent)
-            self.debug_dialog.finished.connect(self._debug_dialog_closed)
-            self.debug_dialog.display_lines(self.debug_lines)
-            self.debug_dialog.chat.scroll_bottom()

toxygen/third_party/qweechat/preferences.py

@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# preferences.py - preferences dialog box
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Preferences dialog box."""
-
-from PyQt5 import QtCore, QtWidgets as QtGui
-
-
-class PreferencesDialog(QtGui.QDialog):
-    """Preferences dialog."""
-
-    def __init__(self, *args):
-        QtGui.QDialog.__init__(*(self,) + args)
-        self.setModal(True)
-        self.setWindowTitle('Preferences')
-
-        close_button = QtGui.QPushButton('Close')
-        close_button.pressed.connect(self.close)
-
-        hbox = QtGui.QHBoxLayout()
-        hbox.addStretch(1)
-        hbox.addWidget(close_button)
-        hbox.addStretch(1)
-
-        vbox = QtGui.QVBoxLayout()
-
-        label = QtGui.QLabel('Not yet implemented!')
-        label.setAlignment(QtCore.Qt.AlignHCenter)
-        vbox.addWidget(label)
-
-        label = QtGui.QLabel('')
-        label.setAlignment(QtCore.Qt.AlignHCenter)
-        vbox.addWidget(label)
-
-        vbox.addLayout(hbox)
-
-        self.setLayout(vbox)
-        self.show()

toxygen/third_party/qweechat/qweechat.py

@@ -1,569 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# qweechat.py - WeeChat remote GUI using Qt toolkit
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""
-QWeeChat is a WeeChat remote GUI using Qt toolkit.
-
-It requires requires WeeChat 0.3.7 or newer, running on local or remote host.
-"""
-
-#
-# History:
-#
-# 2011-05-27, Sébastien Helleu <flashcode@flashtux.org>:
-#     start dev
-#
-
-import sys
-import traceback
-from pkg_resources import resource_filename
-
-from PyQt5 import QtCore, QtGui, QtWidgets
-
-from third_party.qweechat import config
-from third_party.qweechat.about import AboutDialog
-from third_party.qweechat.buffer import BufferListWidget, Buffer
-from third_party.qweechat.connection import ConnectionDialog
-from third_party.qweechat.network import Network, STATUS_DISCONNECTED
-from third_party.qweechat.preferences import PreferencesDialog
-from third_party.qweechat.weechat import protocol
-
-
-APP_NAME = 'QWeeChat'
-AUTHOR = 'Sébastien Helleu'
-WEECHAT_SITE = 'https://weechat.org/'
-
-# not QFrame
-class MainWindow(QtWidgets.QMainWindow):
-    """Main window."""
-
-    def __init__(self, *args):
-        super().__init__(*args)
-
-        self.config = config.read()
-
-        self.resize(1000, 600)
-        self.setWindowTitle(APP_NAME)
-
-        self.about_dialog = None
-        self.connection_dialog = None
-        self.preferences_dialog = None
-
-        # network
-        self.network = Network()
-        self.network.statusChanged.connect(self._network_status_changed)
-        self.network.messageFromWeechat.connect(self._network_weechat_msg)
-
-        # list of buffers
-        self.list_buffers = BufferListWidget()
-        self.list_buffers.currentRowChanged.connect(self._buffer_switch)
-
-        # default buffer
-        self.buffers = [Buffer()]
-        self.stacked_buffers = QtWidgets.QStackedWidget()
-        self.stacked_buffers.addWidget(self.buffers[0].widget)
-
-        # splitter with buffers + chat/input
-        splitter = QtWidgets.QSplitter()
-        splitter.addWidget(self.list_buffers)
-        splitter.addWidget(self.stacked_buffers)
-
-        self.list_buffers.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
-                                        QtWidgets.QSizePolicy.Preferred)
-        self.stacked_buffers.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
-                           QtWidgets.QSizePolicy.Expanding)
-        # MainWindow
-        self.setCentralWidget(splitter)
-
-        if self.config.getboolean('look', 'statusbar'):
-            self.statusBar().visible = True
-        self.statusBar().visible = True
-
-        # actions for menu and toolbar
-        actions_def = {
-            'connect': [
-                'network-connect.png',
-                'Connect to WeeChat',
-                'Ctrl+O',
-                self.open_connection_dialog,
-            ],
-            'disconnect': [
-                'network-disconnect.png',
-                'Disconnect from WeeChat',
-                'Ctrl+D',
-                self.network.disconnect_weechat,
-            ],
-            'debug': [
-                'edit-find.png',
-                'Open debug console window',
-                'Ctrl+B',
-                self.network.open_debug_dialog,
-            ],
-            'preferences': [
-                'preferences-other.png',
-                'Change preferences',
-                'Ctrl+P',
-                self.open_preferences_dialog,
-            ],
-            'about': [
-                'help-about.png',
-                'About QWeeChat',
-                'Ctrl+H',
-                self.open_about_dialog,
-            ],
-            'save connection': [
-                'document-save.png',
-                'Save connection configuration',
-                'Ctrl+S',
-                self.save_connection,
-            ],
-            'quit': [
-                'application-exit.png',
-                'Quit application',
-                'Ctrl+Q',
-                self.close,
-            ],
-        }
-        self.actions = {}
-        for name, action in list(actions_def.items()):
-            self.actions[name] = QtWidgets.QAction(
-                QtGui.QIcon(
-                    resource_filename(__name__, 'data/icons/%s' % action[0])),
-                name.capitalize(), self)
-            self.actions[name].setToolTip(f'{action[1]} ({action[2]})')
-            self.actions[name].setShortcut(action[2])
-            self.actions[name].triggered.connect(action[3])
-
-        # menu
-        self.menu = self.menuBar()
-        menu_file = self.menu.addMenu('&File')
-        menu_file.addActions([self.actions['connect'],
-                              self.actions['disconnect'],
-                              self.actions['preferences'],
-                              self.actions['save connection'],
-                              self.actions['quit']])
-        menu_window = self.menu.addMenu('&Window')
-        menu_window.addAction(self.actions['debug'])
-        name = 'toggle'
-        menu_window.addAction(
-            QtWidgets.QAction(QtGui.QIcon(
-                resource_filename(__name__, 'data/icons/%s' % 'weechat.png')),
-            name.capitalize(), self))
-        #? .triggered.connect(self.onMyToolBarButtonClick)
-
-        menu_help = self.menu.addMenu('&Help')
-        menu_help.addAction(self.actions['about'])
-        self.network_status = QtWidgets.QLabel()
-        self.network_status.setFixedHeight(20)
-        self.network_status.setFixedWidth(200)
-        self.network_status.setContentsMargins(0, 0, 10, 0)
-        self.network_status.setAlignment(QtCore.Qt.AlignRight)
-        if hasattr(self.menu, 'setCornerWidget'):
-            self.menu.setCornerWidget(self.network_status,
-                                    QtCore.Qt.TopRightCorner)
-        self.network_status_set(STATUS_DISCONNECTED)
-
-        # toolbar
-        toolbar = self.addToolBar('toolBar')
-        toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
-        toolbar.addActions([self.actions['connect'],
-                            self.actions['disconnect'],
-                            self.actions['debug'],
-                            self.actions['preferences'],
-                            self.actions['about'],
-                            self.actions['quit']])
-        self.toolbar = toolbar
-        self.buffers[0].widget.input.setFocus()
-
-        # open debug dialog
-        if self.config.getboolean('look', 'debug'):
-            self.network.open_debug_dialog()
-
-        # auto-connect to relay
-        if self.config.getboolean('relay', 'autoconnect'):
-            self.network.connect_weechat(
-                hostname=self.config.get('relay', 'hostname', fallback='127.0.0.1'),
-                port=self.config.get('relay', 'port', fallback='9000'),
-                ssl=self.config.getboolean('relay', 'ssl', fallback=False),
-                password=self.config.get('relay', 'password', fallback=''),
-                totp=self.config.get('relay', 'password', fallback=''),
-                lines=self.config.get('relay', 'lines', fallback=''),
-            )
-
-        self.show()
-
-    def _buffer_switch(self, index):
-        """Switch to a buffer."""
-        if index >= 0:
-            self.stacked_buffers.setCurrentIndex(index)
-            self.stacked_buffers.widget(index).input.setFocus()
-
-    def buffer_input(self, full_name, text):
-        """Send buffer input to WeeChat."""
-        if self.network.is_connected():
-            message = 'input %s %s\n' % (full_name, text)
-            self.network.send_to_weechat(message)
-            self.network.debug_print(0, '<==', message, forcecolor='#AA0000')
-
-    def open_preferences_dialog(self):
-        """Open a dialog with preferences."""
-        # TODO: implement the preferences dialog box
-        self.preferences_dialog = PreferencesDialog(self)
-
-    def save_connection(self):
-        """Save connection configuration."""
-        if self.network:
-            options = self.network.get_options()
-            for option in options:
-                self.config.set('relay', option, options[option])
-
-    def open_about_dialog(self):
-        """Open a dialog with info about QWeeChat."""
-        self.about_dialog = AboutDialog(APP_NAME, AUTHOR, WEECHAT_SITE, self)
-
-    def open_connection_dialog(self):
-        """Open a dialog with connection settings."""
-        values = {}
-        for option in ('hostname', 'port', 'ssl', 'password', 'lines'):
-            val = self.config.get('relay', option, fallback='')
-            if val in [None, 'None']: val = ''
-            if option == 'port' and val in [None, 'None']: val = 0
-            values[option] = val
-        self.connection_dialog = ConnectionDialog(values, self)
-        self.connection_dialog.dialog_buttons.accepted.connect(
-            self.connect_weechat)
-
-    def connect_weechat(self):
-        """Connect to WeeChat."""
-        self.network.connect_weechat(
-            hostname=self.connection_dialog.fields['hostname'].text(),
-            port=self.connection_dialog.fields['port'].text(),
-            ssl=self.connection_dialog.fields['ssl'].isChecked(),
-            password=self.connection_dialog.fields['password'].text(),
-            totp=self.connection_dialog.fields['totp'].text(),
-            lines=int(self.connection_dialog.fields['lines'].text()),
-        )
-        hostname=self.connection_dialog.fields['hostname'].text()
-        port = self.connection_dialog.fields['port'].text()
-        ssl=self.connection_dialog.fields['ssl'].isChecked()
-        password = '' # self.connection_dialog.fields['password'].text()
-        self.config.set('relay', 'port', port)
-        self.config.set('relay', 'hostname', hostname)
-        self.config.set('relay', 'password', password)
-        self.connection_dialog.close()
-
-    def _network_status_changed(self, status, extra):
-        """Called when the network status has changed."""
-        if self.config.getboolean('look', 'statusbar'):
-            self.statusBar().showMessage(status)
-        self.network.debug_print(0, '', status, forcecolor='#0000AA')
-        self.network_status_set(status)
-
-    def network_status_set(self, status):
-        """Set the network status."""
-        pal = self.network_status.palette()
-        try:
-            pal.setColor(self.network_status.foregroundRole(),
-                     self.network.status_color(status))
-        except:
-            # dunno
-            pass
-        ssl = ' (SSL)' if status != STATUS_DISCONNECTED \
-              and self.network.is_ssl() else ''
-        self.network_status.setPalette(pal)
-        icon = self.network.status_icon(status)
-        if icon:
-            self.network_status.setText(
-                '<img src="%s"> %s' %
-                (resource_filename(__name__, 'data/icons/%s' % icon),
-                 self.network.status_label(status) + ssl))
-        else:
-            self.network_status.setText(status.capitalize())
-        if status == STATUS_DISCONNECTED:
-            self.actions['connect'].setEnabled(True)
-            self.actions['disconnect'].setEnabled(False)
-        else:
-            self.actions['connect'].setEnabled(False)
-            self.actions['disconnect'].setEnabled(True)
-
-    def _network_weechat_msg(self, message):
-        """Called when a message is received from WeeChat."""
-        self.network.debug_print(
-            0, '==>',
-            'message (%d bytes):\n%s'
-            % (len(message),
-               protocol.hex_and_ascii(message.data(), 20)),
-            forcecolor='#008800',
-        )
-        try:
-            proto = protocol.Protocol()
-            message = proto.decode(message.data())
-            if message.uncompressed:
-                self.network.debug_print(
-                    0, '==>',
-                    'message uncompressed (%d bytes):\n%s'
-                    % (message.size_uncompressed,
-                       protocol.hex_and_ascii(message.uncompressed, 20)),
-                    forcecolor='#008800')
-            self.network.debug_print(0, '', 'Message: %s' % message)
-            self.parse_message(message)
-        except Exception:  # noqa: E722
-            print('Error while decoding message from WeeChat:\n%s'
-                  % traceback.format_exc())
-            self.network.disconnect_weechat()
-
-    def _parse_handshake(self, message):
-        """Parse a WeeChat message with handshake response."""
-        for obj in message.objects:
-            if obj.objtype != 'htb':
-                continue
-            self.network.init_with_handshake(obj.value)
-            break
-
-    def _parse_listbuffers(self, message):
-        """Parse a WeeChat message with list of buffers."""
-        for obj in message.objects:
-            if obj.objtype != 'hda' or obj.value['path'][-1] != 'buffer':
-                continue
-            self.list_buffers.clear()
-            while self.stacked_buffers.count() > 0:
-                buf = self.stacked_buffers.widget(0)
-                self.stacked_buffers.removeWidget(buf)
-            self.buffers = []
-            for item in obj.value['items']:
-                buf = self.create_buffer(item)
-                self.insert_buffer(len(self.buffers), buf)
-            self.list_buffers.setCurrentRow(0)
-            self.buffers[0].widget.input.setFocus()
-
-    def _parse_line(self, message):
-        """Parse a WeeChat message with a buffer line."""
-        for obj in message.objects:
-            lines = []
-            if obj.objtype != 'hda' or obj.value['path'][-1] != 'line_data':
-                continue
-            for item in obj.value['items']:
-                if message.msgid == 'listlines':
-                    ptrbuf = item['__path'][0]
-                else:
-                    ptrbuf = item['buffer']
-                index = [i for i, b in enumerate(self.buffers)
-                         if b.pointer() == ptrbuf]
-                if index:
-                    lines.append(
-                        (index[0],
-                         (item['date'], item['prefix'],
-                          item['message']))
-                    )
-            if message.msgid == 'listlines':
-                lines.reverse()
-            for line in lines:
-                self.buffers[line[0]].widget.chat.display(*line[1])
-
-    def _parse_nicklist(self, message):
-        """Parse a WeeChat message with a buffer nicklist."""
-        buffer_refresh = {}
-        for obj in message.objects:
-            if obj.objtype != 'hda' or \
-               obj.value['path'][-1] != 'nicklist_item':
-                continue
-            group = '__root'
-            for item in obj.value['items']:
-                index = [i for i, b in enumerate(self.buffers)
-                         if b.pointer() == item['__path'][0]]
-                if index:
-                    if not index[0] in buffer_refresh:
-                        self.buffers[index[0]].nicklist = {}
-                    buffer_refresh[index[0]] = True
-                    if item['group']:
-                        group = item['name']
-                    self.buffers[index[0]].nicklist_add_item(
-                        group, item['group'], item['prefix'], item['name'],
-                        item['visible'])
-        for index in buffer_refresh:
-            self.buffers[index].nicklist_refresh()
-
-    def _parse_nicklist_diff(self, message):
-        """Parse a WeeChat message with a buffer nicklist diff."""
-        buffer_refresh = {}
-        for obj in message.objects:
-            if obj.objtype != 'hda' or \
-               obj.value['path'][-1] != 'nicklist_item':
-                continue
-            group = '__root'
-            for item in obj.value['items']:
-                index = [i for i, b in enumerate(self.buffers)
-                         if b.pointer() == item['__path'][0]]
-                if not index:
-                    continue
-                buffer_refresh[index[0]] = True
-                if item['_diff'] == ord('^'):
-                    group = item['name']
-                elif item['_diff'] == ord('+'):
-                    self.buffers[index[0]].nicklist_add_item(
-                        group, item['group'], item['prefix'], item['name'],
-                        item['visible'])
-                elif item['_diff'] == ord('-'):
-                    self.buffers[index[0]].nicklist_remove_item(
-                        group, item['group'], item['name'])
-                elif item['_diff'] == ord('*'):
-                    self.buffers[index[0]].nicklist_update_item(
-                        group, item['group'], item['prefix'], item['name'],
-                        item['visible'])
-        for index in buffer_refresh:
-            self.buffers[index].nicklist_refresh()
-
-    def _parse_buffer_opened(self, message):
-        """Parse a WeeChat message with a new buffer (opened)."""
-        for obj in message.objects:
-            if obj.objtype != 'hda' or obj.value['path'][-1] != 'buffer':
-                continue
-            for item in obj.value['items']:
-                buf = self.create_buffer(item)
-                index = self.find_buffer_index_for_insert(item['next_buffer'])
-                self.insert_buffer(index, buf)
-
-    def _parse_buffer(self, message):
-        """Parse a WeeChat message with a buffer event
-        (anything except a new buffer).
-        """
-        for obj in message.objects:
-            if obj.objtype != 'hda' or obj.value['path'][-1] != 'buffer':
-                continue
-            for item in obj.value['items']:
-                index = [i for i, b in enumerate(self.buffers)
-                         if b.pointer() == item['__path'][0]]
-                if not index:
-                    continue
-                index = index[0]
-                if message.msgid == '_buffer_type_changed':
-                    self.buffers[index].data['type'] = item['type']
-                elif message.msgid in ('_buffer_moved', '_buffer_merged',
-                                       '_buffer_unmerged'):
-                    buf = self.buffers[index]
-                    buf.data['number'] = item['number']
-                    self.remove_buffer(index)
-                    index2 = self.find_buffer_index_for_insert(
-                        item['next_buffer'])
-                    self.insert_buffer(index2, buf)
-                elif message.msgid == '_buffer_renamed':
-                    self.buffers[index].data['full_name'] = item['full_name']
-                    self.buffers[index].data['short_name'] = item['short_name']
-                elif message.msgid == '_buffer_title_changed':
-                    self.buffers[index].data['title'] = item['title']
-                    self.buffers[index].update_title()
-                elif message.msgid == '_buffer_cleared':
-                    self.buffers[index].widget.chat.clear()
-                elif message.msgid.startswith('_buffer_localvar_'):
-                    self.buffers[index].data['local_variables'] = \
-                        item['local_variables']
-                    self.buffers[index].update_prompt()
-                elif message.msgid == '_buffer_closing':
-                    self.remove_buffer(index)
-
-    def parse_message(self, message):
-        """Parse a WeeChat message."""
-        if message.msgid.startswith('debug'):
-            self.network.debug_print(0, '', '(debug message, ignored)')
-        elif message.msgid == 'handshake':
-            self._parse_handshake(message)
-        elif message.msgid == 'listbuffers':
-            self._parse_listbuffers(message)
-        elif message.msgid in ('listlines', '_buffer_line_added'):
-            self._parse_line(message)
-        elif message.msgid in ('_nicklist', 'nicklist'):
-            self._parse_nicklist(message)
-        elif message.msgid == '_nicklist_diff':
-            self._parse_nicklist_diff(message)
-        elif message.msgid == '_buffer_opened':
-            self._parse_buffer_opened(message)
-        elif message.msgid.startswith('_buffer_'):
-            self._parse_buffer(message)
-        elif message.msgid == '_upgrade':
-            self.network.desync_weechat()
-        elif message.msgid == '_upgrade_ended':
-            self.network.sync_weechat()
-        else:
-            print(f"Unknown message with id {message.msgid}")
-
-    def create_buffer(self, item):
-        """Create a new buffer."""
-        buf = Buffer(item)
-        buf.bufferInput.connect(self.buffer_input)
-        buf.widget.input.bufferSwitchPrev.connect(
-            self.list_buffers.switch_prev_buffer)
-        buf.widget.input.bufferSwitchNext.connect(
-            self.list_buffers.switch_next_buffer)
-        return buf
-
-    def insert_buffer(self, index, buf):
-        """Insert a buffer in list."""
-        self.buffers.insert(index, buf)
-        self.list_buffers.insertItem(index, '%s'
-                                     % (buf.data['local_variables']['name']))
-        self.stacked_buffers.insertWidget(index, buf.widget)
-
-    def remove_buffer(self, index):
-        """Remove a buffer."""
-        if self.list_buffers.currentRow == index and index > 0:
-            self.list_buffers.setCurrentRow(index - 1)
-        self.list_buffers.takeItem(index)
-        self.stacked_buffers.removeWidget(self.stacked_buffers.widget(index))
-        self.buffers.pop(index)
-
-    def find_buffer_index_for_insert(self, next_buffer):
-        """Find position to insert a buffer in list."""
-        index = -1
-        if next_buffer == '0x0':
-            index = len(self.buffers)
-        else:
-            elts = [i for i, b in enumerate(self.buffers)
-                     if b.pointer() == next_buffer]
-            if len(elts):
-                index = elts[0]
-        if index < 0:
-            print('Warning: unable to find position for buffer, using end of '
-                  'list by default')
-            index = len(self.buffers)
-        return index
-
-    def closeEvent(self, event):
-        """Called when QWeeChat window is closed."""
-        self.network.disconnect_weechat()
-        if self.network.debug_dialog:
-            self.network.debug_dialog.close()
-        config.write(self.config)
-        QtWidgets.QFrame.closeEvent(self, event)
-
-
-def main():
-    app = QtWidgets.QApplication(sys.argv)
-    app.setStyle(QtWidgets.QStyleFactory.create('Cleanlooks'))
-    app.setWindowIcon(QtGui.QIcon(
-        resource_filename(__name__, 'data/icons/weechat.png')))
-    main_win = MainWindow()
-    main_win.show()
-    sys.exit(app.exec_())
-
-
-if __name__ == '__main__':
-    main()

toxygen/third_party/qweechat/version.py

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# version.py - version of QWeeChat
-#
-# Copyright (C) 2011-2022 Sébastien Helleu <flashcode@flashtux.org>
-#
-# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
-#
-# QWeeChat is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# QWeeChat is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Version of QWeeChat."""
-
-VERSION = '0.0.1-dev'
-
-
-def qweechat_version():
-    """Return QWeeChat version."""
-    return VERSION

toxygen/ui/av_widgets.py

@@ -1,15 +1,17 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+import logging
 import threading
-
-from PyQt5 import QtCore, QtGui, QtWidgets
-import pyaudio
 import wave
 
+from  qtpy import QtCore, QtGui, QtWidgets
+
 from ui import widgets
 import utils.util as util
-import wrapper_tests.support_testing as ts
+import toxygen_wrapper.tests.support_testing as ts
+with ts.ignoreStderr():
+    import pyaudio
 
 global LOG
-import logging
 LOG = logging.getLogger('app.'+__name__)
 
 class IncomingCallWidget(widgets.CenteredWidget):
@@ -65,7 +67,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
 
         output_device_index = self._settings._oArgs.audio['output']
 
-        if False and self._settings['calls_sound']:
+        if self._settings['calls_sound']:
             class SoundPlay(QtCore.QThread):
 
                 def __init__(self):
@@ -117,6 +119,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
             self.thread = None
 
     def stop(self):
+        LOG.debug(f"stop from friend_number={self._friend_number}")
         if self._processing:
             self.close()
         if self.thread is not None:
@@ -127,8 +130,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
                 if not self.thread.isRunning(): break
                 i = i + 1
             else:
-                LOG.warn(f"SoundPlay {self.thread.a} BLOCKED")
+                LOG.warn(f"stop {self.thread.a} BLOCKED")
-                # Fatal Python error: Segmentation fault
                 self.thread.a.stream.close()
                 self.thread.a.p.terminate()
                 self.thread.a.close()
@@ -146,13 +148,15 @@ class IncomingCallWidget(widgets.CenteredWidget):
         try:
             self._calls_manager.accept_call(self._friend_number, True, False)
         finally:
-            self.stop()
+            #? self.stop()
+            LOG.debug(f" accept_call_with_audio NOT stop from={self._friend_number}")
+            pass
 
     def accept_call_with_video(self):
         # ts.trepan_handler()
 
         if self._processing:
-            LOG.warn(__name__+f" accept_call_with_video from {self._friend_number}")
+            LOG.warn(f" accept_call_with_video from {self._friend_number}")
             return
         self.setWindowTitle('Answering video call')
         self._processing = True
@@ -163,11 +167,14 @@ class IncomingCallWidget(widgets.CenteredWidget):
             self.stop()
 
     def decline_call(self):
+        LOG.debug(f"decline_call from {self._friend_number}")
         if self._processing:
             return
         self._processing = True
         try:
             self._calls_manager.stop_call(self._friend_number, False)
+        except Exception as e:
+            LOG.warn(f"decline_call from {self._friend_number} {e}")
         finally:
             self.stop()
 

toxygen/ui/contact_items.py

@@ -1,5 +1,7 @@
-from wrapper.toxcore_enums_and_consts import *
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
-from PyQt5 import QtCore, QtGui, QtWidgets
+from  qtpy import QtCore, QtGui, QtWidgets
+from toxygen_wrapper.toxcore_enums_and_consts import *
+
 from utils.util import *
 from ui.widgets import DataLabel
 
@@ -32,7 +34,8 @@ class ContactItem(QtWidgets.QWidget):
         self.status_message.setFont(font)
         self.kind = DataLabel(self)
         self.kind.setGeometry(QtCore.QRect(50 if mode else 75, 38 if mode else 48, 190, 15 if mode else 20))
-        font.setBold(True)
+        font.setBold(False)
+        font.setItalic(True)
         self.kind.setFont(font)
         self.connection_status = StatusCircle(self)
         self.connection_status.setGeometry(QtCore.QRect(230, -2 if mode else 5, 32, 32))

toxygen/ui/create_profile_screen.py

@@ -1,9 +1,11 @@
+# -*- mode: python; indent-tabs-mode: nil; py-indent-offset: 4; coding: utf-8 -*-
+
+from  qtpy import uic
+
 from ui.widgets import *
-from PyQt5 import uic
 import utils.util as util
 import utils.ui as util_ui
 
-
 class CreateProfileScreenResult:
 
     def __init__(self, save_into_default_folder, password):