From ecdcfe9c22a44d283b364716ddf947f386b32f1d Mon Sep 17 00:00:00 2001 From: Schimon Jehudah Date: Mon, 4 Dec 2023 14:41:02 +0000 Subject: [PATCH] Fox issue with callback (adding URL) and an attempt to import specific parts of modules --- slixfeed/__main__.py | 26 ++-- slixfeed/confighandler.py | 5 +- slixfeed/datahandler.py | 124 ++++++++-------- slixfeed/filehandler.py | 6 +- slixfeed/listhandler.py | 6 +- slixfeed/sqlitehandler.py | 35 +++-- slixfeed/taskhandler.py | 73 +++++----- slixfeed/xmpphandler.py | 299 ++++++++++++++++++++------------------ 8 files changed, 306 insertions(+), 268 deletions(-) diff --git a/slixfeed/__main__.py b/slixfeed/__main__.py index c50b185..b68cfd6 100644 --- a/slixfeed/__main__.py +++ b/slixfeed/__main__.py @@ -13,11 +13,17 @@ FIXME TODO +0) from slixfeed.FILENAME import XYZ + See project feed2toot + 1) SQL prepared statements. 2) Machine Learning for scrapping Title, Link, Summary and Timstamp. -3) Support MUC. +3) Set MUC subject + Feeds which entries are to be set as groupchat subject. + Perhaps not, as it would require to check every feed for this setting. + Maybe a separate bot. 4) Support categories. @@ -36,7 +42,9 @@ TODO 11) Download and upload/send article (xHTML, xHTMLZ, Markdown, MHTML, TXT). Use Readability. -12) Fetch summary from URL, instead of storing summary. +12) Fetch summary from URL, instead of storing summary, or + Store 5 upcoming summaries. + This would help making the database files smaller. 13) Support protocol Gopher https://github.com/michael-lazar/pygopherd @@ -60,22 +68,22 @@ from argparse import ArgumentParser from getpass import getpass import logging -from datetime import date -import time +# from datetime import date +# import time # from eliot import start_action, to_file # # to_file(open("slixfeed.log", "w")) # # with start_action(action_type="set_date()", jid=jid): # # with start_action(action_type="message()", msg=msg): -#import irchandler -import xmpphandler -#import matrixhandler +#import slixfeed.irchandler +from xmpphandler import Slixfeed +#import slixfeed.matrixhandler if __name__ == '__main__': # Setup the command line arguments. - parser = ArgumentParser(description=xmpphandler.Slixfeed.__doc__) + parser = ArgumentParser(description=Slixfeed.__doc__) # Output verbosity options. parser.add_argument( @@ -109,7 +117,7 @@ if __name__ == '__main__': # Setup the Slixfeed and register plugins. Note that while plugins may # have interdependencies, the order in which you register them does # not matter. - xmpp = xmpphandler.Slixfeed(args.jid, args.password) + xmpp = Slixfeed(args.jid, args.password) xmpp.register_plugin('xep_0004') # Data Forms xmpp.register_plugin('xep_0030') # Service Discovery xmpp.register_plugin('xep_0045') # Multi-User Chat diff --git a/slixfeed/confighandler.py b/slixfeed/confighandler.py index 01a4f3a..2dc9a73 100644 --- a/slixfeed/confighandler.py +++ b/slixfeed/confighandler.py @@ -10,8 +10,9 @@ TODO """ + import os -import filehandler +from filehandler import get_default_confdir from random import randrange @@ -64,7 +65,7 @@ def get_list(): Dictionary of pathnames. """ paths = [] - cfg_dir = filehandler.get_default_confdir() + cfg_dir = get_default_confdir() if not os.path.isdir(cfg_dir): os.mkdir(cfg_dir) cfg_file = os.path.join(cfg_dir, r"url_paths.txt") diff --git a/slixfeed/datahandler.py b/slixfeed/datahandler.py index c3470f2..944e268 100644 --- a/slixfeed/datahandler.py +++ b/slixfeed/datahandler.py @@ -14,25 +14,32 @@ TODO """ -import aiohttp -import asyncio -import feedparser - -import sqlitehandler -import confighandler -import datetimehandler -import listhandler - +from aiohttp import ClientError +from aiohttp import ClientSession +from aiohttp import ClientTimeout +from asyncio import TimeoutError from asyncio.exceptions import IncompleteReadError -from http.client import IncompleteRead -from urllib import error from bs4 import BeautifulSoup +from feedparser import parse +from http.client import IncompleteRead +from lxml import html +from datetimehandler import now +from datetimehandler import rfc2822_to_iso8601 +from confighandler import get_list +from listhandler import is_listed +from sqlitehandler import add_entry_and_set_date +from sqlitehandler import insert_feed +from sqlitehandler import check_entry_exist +from sqlitehandler import check_feed_exist +from sqlitehandler import get_feeds_url +from sqlitehandler import remove_nonexistent_entries +from sqlitehandler import update_source_status +from sqlitehandler import update_source_validity +from urllib import error # from xml.etree.ElementTree import ElementTree, ParseError from urllib.parse import urljoin from urllib.parse import urlsplit from urllib.parse import urlunsplit -from lxml import html - # NOTE Why (if res[0]) and (if res[1] == 200)? async def download_updates(db_file, url=None): @@ -49,7 +56,7 @@ async def download_updates(db_file, url=None): if url: urls = [url] # Valid [url] and [url,] and (url,) else: - urls = await sqlitehandler.get_feeds_url(db_file) + urls = await get_feeds_url(db_file) for url in urls: # print(os.path.basename(db_file), url[0]) source = url[0] @@ -60,14 +67,14 @@ async def download_updates(db_file, url=None): # urls.next() # next(urls) continue - await sqlitehandler.update_source_status( + await update_source_status( db_file, res[1], source ) if res[0]: try: - feed = feedparser.parse(res[0]) + feed = parse(res[0]) if feed.bozo: # bozo = ( # "WARNING: Bozo detected for feed: {}\n" @@ -78,7 +85,7 @@ async def download_updates(db_file, url=None): valid = 0 else: valid = 1 - await sqlitehandler.update_source_validity( + await update_source_validity( db_file, source, valid) @@ -102,8 +109,8 @@ async def download_updates(db_file, url=None): # NOTE Need to correct the SQL statement to do so entries = feed.entries # length = len(entries) - # await sqlitehandler.remove_entry(db_file, source, length) - await sqlitehandler.remove_nonexistent_entries( + # await remove_entry(db_file, source, length) + await remove_nonexistent_entries( db_file, feed, source @@ -113,14 +120,14 @@ async def download_updates(db_file, url=None): # TODO Pass date too for comparion check if entry.has_key("published"): date = entry.published - date = await datetimehandler.rfc2822_to_iso8601(date) + date = await rfc2822_to_iso8601(date) elif entry.has_key("updated"): date = entry.updated - date = await datetimehandler.rfc2822_to_iso8601(date) + date = await rfc2822_to_iso8601(date) else: # TODO Just set date = "*** No date ***" # date = await datetime.now().isoformat() - date = await datetimehandler.now() + date = await now() # NOTE Would seconds result in better database performance # date = datetime.datetime(date) # date = (date-datetime.datetime(1970,1,1)).total_seconds() @@ -140,7 +147,7 @@ async def download_updates(db_file, url=None): eid = entry.id else: eid = link - exist = await sqlitehandler.check_entry_exist( + exist = await check_entry_exist( db_file, source, eid=eid, @@ -172,13 +179,13 @@ async def download_updates(db_file, url=None): summary, pathname ) - allow_list = await listhandler.is_listed( + allow_list = await is_listed( db_file, "filter-allow", string ) if not allow_list: - reject_list = await listhandler.is_listed( + reject_list = await is_listed( db_file, "filter-deny", string @@ -202,19 +209,19 @@ async def download_updates(db_file, url=None): read_status ) if isinstance(date, int): - print("date is int") + print("PROBLEM: date is int") print(date) - breakpoint() + # breakpoint() print(source) print(date) - await sqlitehandler.add_entry_and_set_date( + await add_entry_and_set_date( db_file, source, entry ) - # print(await datetimehandler.current_time(), entry, title) + # print(await current_time(), entry, title) # else: - # print(await datetimehandler.current_time(), exist, title) + # print(await current_time(), exist, title) # NOTE Why (if result[0]) and (if result[1] == 200)? @@ -237,7 +244,7 @@ async def view_feed(url): result = await download_feed(url) if result[0]: try: - feed = feedparser.parse(result[0]) + feed = parse(result[0]) if feed.bozo: # msg = ( # ">{}\n" @@ -258,7 +265,7 @@ async def view_feed(url): "> {}\n" "Error: {}" ).format(url, e) - breakpoint() + # breakpoint() if result[1] == 200: title = await get_title(url, result[0]) entries = feed.entries @@ -278,10 +285,10 @@ async def view_feed(url): link = "*** No link ***" if entry.has_key("published"): date = entry.published - date = await datetimehandler.rfc2822_to_iso8601(date) + date = await rfc2822_to_iso8601(date) elif entry.has_key("updated"): date = entry.updated - date = await datetimehandler.rfc2822_to_iso8601(date) + date = await rfc2822_to_iso8601(date) else: date = "*** No date ***" msg += ( @@ -313,7 +320,7 @@ async def view_entry(url, num): result = await download_feed(url) if result[0]: try: - feed = feedparser.parse(result[0]) + feed = parse(result[0]) if feed.bozo: # msg = ( # ">{}\n" @@ -334,9 +341,9 @@ async def view_entry(url, num): "> {}\n" "Error: {}" ).format(url, e) - breakpoint() + # breakpoint() if result[1] == 200: - feed = feedparser.parse(result[0]) + feed = parse(result[0]) title = await get_title(url, result[0]) entries = feed.entries num = int(num) - 1 @@ -347,10 +354,10 @@ async def view_entry(url, num): title = "*** No title ***" if entry.has_key("published"): date = entry.published - date = await datetimehandler.rfc2822_to_iso8601(date) + date = await rfc2822_to_iso8601(date) elif entry.has_key("updated"): date = entry.updated - date = await datetimehandler.rfc2822_to_iso8601(date) + date = await rfc2822_to_iso8601(date) else: date = "*** No date ***" if entry.has_key("summary"): @@ -407,9 +414,9 @@ async def add_feed_no_check(db_file, data): url = data[0] title = data[1] url = await trim_url(url) - exist = await sqlitehandler.check_feed_exist(db_file, url) + exist = await check_feed_exist(db_file, url) if not exist: - msg = await sqlitehandler.add_feed(db_file, url, title) + msg = await insert_feed(db_file, url, title) await download_updates(db_file, [url]) else: ix = exist[0] @@ -440,21 +447,21 @@ async def add_feed(db_file, url): """ msg = None url = await trim_url(url) - exist = await sqlitehandler.check_feed_exist(db_file, url) + exist = await check_feed_exist(db_file, url) if not exist: res = await download_feed(url) if res[0]: - feed = feedparser.parse(res[0]) + feed = parse(res[0]) title = await get_title(url, feed) if feed.bozo: bozo = ( "Bozo detected. Failed to load: {}." ).format(url) print(bozo) - msg = await probe_page(add_feed, url, res[0], db_file) + msg = await probe_page(add_feed, url, res[0], db_file=db_file) else: status = res[1] - msg = await sqlitehandler.add_feed( + msg = await insert_feed( db_file, url, title, @@ -507,6 +514,7 @@ async def probe_page(callback, url, doc, num=None, db_file=None): elif isinstance(msg, list): url = msg[0] if db_file: + print("if db_file", db_file) return await callback(db_file, url) elif num: return await callback(url, num) @@ -528,9 +536,9 @@ async def download_feed(url): msg: list or str Document or error message. """ - timeout = aiohttp.ClientTimeout(total=10) - async with aiohttp.ClientSession() as session: - # async with aiohttp.ClientSession(trust_env=True) as session: + timeout = ClientTimeout(total=10) + async with ClientSession() as session: + # async with ClientSession(trust_env=True) as session: try: async with session.get(url, timeout=timeout) as response: status = response.status @@ -558,13 +566,13 @@ async def download_feed(url): False, "HTTP Error: " + str(status) ] - except aiohttp.ClientError as e: + except ClientError as e: # print('Error', str(e)) msg = [ False, "Error: " + str(e) ] - except asyncio.TimeoutError as e: + except TimeoutError as e: # print('Timeout:', str(e)) msg = [ False, @@ -771,7 +779,7 @@ async def feed_mode_request(url, tree): """ feeds = {} parted_url = urlsplit(url) - paths = confighandler.get_list() + paths = get_list() for path in paths: address = urlunsplit([ parted_url.scheme, @@ -782,10 +790,10 @@ async def feed_mode_request(url, tree): ]) res = await download_feed(address) if res[1] == 200: - # print(feedparser.parse(res[0])["feed"]["title"]) - # feeds[address] = feedparser.parse(res[0])["feed"]["title"] + # print(parse(res[0])["feed"]["title"]) + # feeds[address] = parse(res[0])["feed"]["title"] try: - title = feedparser.parse(res[0])["feed"]["title"] + title = parse(res[0])["feed"]["title"] except: title = '*** No Title ***' feeds[address] = title @@ -806,7 +814,7 @@ async def feed_mode_request(url, tree): res = await download_feed(address) if res[1] == 200: try: - feeds[address] = feedparser.parse(res[0]) + feeds[address] = parse(res[0]) # print(feeds) except: continue @@ -871,7 +879,7 @@ async def feed_mode_scan(url, tree): feeds = {} # paths = [] # TODO Test - paths = confighandler.get_list() + paths = get_list() for path in paths: # xpath_query = "//*[@*[contains(.,'{}')]]".format(path) xpath_query = "//a[contains(@href,'{}')]".format(path) @@ -908,7 +916,7 @@ async def feed_mode_scan(url, tree): res = await download_feed(address) if res[1] == 200: try: - feeds[address] = feedparser.parse(res[0]) + feeds[address] = parse(res[0]) # print(feeds) except: continue @@ -992,7 +1000,7 @@ async def feed_mode_auto_discovery(url, tree): # # The following code requires more bandwidth. # res = await download_feed(feed) # if res[0]: - # disco = feedparser.parse(res[0]) + # disco = parse(res[0]) # title = disco["feed"]["title"] # msg += "{} \n {} \n\n".format(title, feed) feed_name = feed.xpath('@title')[0] diff --git a/slixfeed/filehandler.py b/slixfeed/filehandler.py index d6cf666..4d12c10 100644 --- a/slixfeed/filehandler.py +++ b/slixfeed/filehandler.py @@ -4,7 +4,7 @@ import os import sys -import sqlitehandler +from sqlitehandler import create_tables def get_default_dbdir(): """ @@ -97,8 +97,8 @@ async def initdb(jid, callback, message=None): if not os.path.isdir(db_dir): os.mkdir(db_dir) db_file = os.path.join(db_dir, r"{}.db".format(jid)) - sqlitehandler.create_tables(db_file) - # await sqlitehandler.set_default_values(db_file) + create_tables(db_file) + # await set_default_values(db_file) if message: return await callback(db_file, message) else: diff --git a/slixfeed/listhandler.py b/slixfeed/listhandler.py index 462f3fa..11dcab7 100644 --- a/slixfeed/listhandler.py +++ b/slixfeed/listhandler.py @@ -15,7 +15,7 @@ TODO """ -import sqlitehandler +from sqlitehandler import get_settings_value async def add_to_list(newwords, keywords): @@ -98,7 +98,7 @@ async def is_listed(db_file, key, string): """ # async def reject(db_file, string): # async def is_blacklisted(db_file, string): - list = await sqlitehandler.get_settings_value( + list = await get_settings_value( db_file, key ) @@ -119,7 +119,7 @@ async def is_listed(db_file, key, string): This code was tested at module datahandler reject = 0 - blacklist = await sqlitehandler.get_settings_value( + blacklist = await get_settings_value( db_file, "filter-deny" ) diff --git a/slixfeed/sqlitehandler.py b/slixfeed/sqlitehandler.py index 1148e6d..5fed7c8 100644 --- a/slixfeed/sqlitehandler.py +++ b/slixfeed/sqlitehandler.py @@ -15,17 +15,18 @@ TODO """ -import sqlite3 -import asyncio - +from asyncio import Lock from bs4 import BeautifulSoup from datetime import date +# from slixfeed.confighandler import get_value_default +import confighandler as confighandler +# from slixfeed.datahandler import join_url +import datahandler as datahandler +from datetimehandler import current_time +from datetimehandler import rfc2822_to_iso8601 +from sqlite3 import connect from sqlite3 import Error -import confighandler -import datahandler -import datetimehandler - # from eliot import start_action, to_file # # with start_action(action_type="list_feeds()", db=db_file): # # with start_action(action_type="last_entries()", num=num): @@ -35,7 +36,7 @@ import datetimehandler # # with start_action(action_type="check_entry()", link=link): # aiosqlite -DBLOCK = asyncio.Lock() +DBLOCK = Lock() CURSORS = {} @@ -56,7 +57,7 @@ def create_connection(db_file): """ conn = None try: - conn = sqlite3.connect(db_file) + conn = connect(db_file) return conn except Error as e: print(e) @@ -155,9 +156,9 @@ def get_cursor(db_file): return CURSORS[db_file] -async def add_feed(db_file, url, title=None, status=None): +async def insert_feed(db_file, url, title=None, status=None): """ - Add a new feed into the feeds table. + Insert a new feed into the feeds table. Parameters ---------- @@ -879,11 +880,13 @@ async def add_entry(cur, entry): try: cur.execute(sql, entry) except: + print(await current_time(), "COROUTINE OBJECT NOW") print(entry[6]) print(type(entry[6])) print(entry) print(type(entry)) - breakpoint() + print(await current_time(), "COROUTINE OBJECT NOW") + # breakpoint() # NOTE See remove_nonexistent_entries @@ -992,7 +995,7 @@ async def remove_nonexistent_entries(db_file, feed, source): # print("compare11:", title, link, time) # print("compare22:", item[1], item[2], item[4]) # print("============") - time = await datetimehandler.rfc2822_to_iso8601(entry.published) + time = await rfc2822_to_iso8601(entry.published) if (item[1] == title and item[2] == link and item[4] == time): @@ -1401,8 +1404,8 @@ async def check_entry_exist(db_file, source, eid=None, "timestamp": date }).fetchone() except: - print(await datetimehandler.current_time(), "ERROR DATE: source =", source) - print(await datetimehandler.current_time(), "ERROR DATE: date =", date) + print(await current_time(), "ERROR DATE: source =", source) + print(await current_time(), "ERROR DATE: date =", date) else: sql = ( "SELECT id " @@ -1419,7 +1422,7 @@ async def check_entry_exist(db_file, source, eid=None, else: None except: - print(await datetimehandler.current_time(), "ERROR DATE: result =", source) + print(await current_time(), "ERROR DATE: result =", source) async def set_settings_value(db_file, key_value): diff --git a/slixfeed/taskhandler.py b/slixfeed/taskhandler.py index 35786b8..0cfe828 100644 --- a/slixfeed/taskhandler.py +++ b/slixfeed/taskhandler.py @@ -44,11 +44,16 @@ import logging import os import slixmpp -import datahandler -import datetimehandler -import filehandler -import sqlitehandler -import xmpphandler +from datahandler import download_updates +from datetimehandler import current_time +from filehandler import initdb +from filehandler import get_default_dbdir +from sqlitehandler import get_entry_unread +from sqlitehandler import get_settings_value +from sqlitehandler import get_number_of_items +from sqlitehandler import get_number_of_entries_unread +# from xmpphandler import Slixfeed +import xmpphandler as xmpphandler main_task = [] jid_tasker = {} @@ -118,7 +123,7 @@ Pass a list (or dict) of tasks to start NOTE -Consider callback e.g. xmpphandler.Slixfeed.send_status. +Consider callback e.g. Slixfeed.send_status. Or taskhandler for each protocol or specific taskhandler function. """ @@ -131,12 +136,12 @@ async def task_jid(self, jid): jid : str Jabber ID. """ - enabled = await filehandler.initdb( + enabled = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "enabled" ) - # print(await datetimehandler.current_time(), "enabled", enabled, jid) + # print(await current_time(), "enabled", enabled, jid) if enabled: # NOTE Perhaps we want to utilize super with keyword # arguments in order to know what tasks to initiate. @@ -177,7 +182,7 @@ async def task_jid(self, jid): async def send_update(self, jid, num=None): - # print(await datetimehandler.current_time(), jid, "def send_update") + # print(await current_time(), jid, "def send_update") """ Send news items as messages. @@ -190,14 +195,14 @@ async def send_update(self, jid, num=None): """ # print("Starting send_update()") # print(jid) - new = await filehandler.initdb( + new = await initdb( jid, - sqlitehandler.get_entry_unread, + get_entry_unread, num ) if new: # TODO Add while loop to assure delivery. - # print(await datetimehandler.current_time(), ">>> ACT send_message",jid) + # print(await current_time(), ">>> ACT send_message",jid) if await xmpphandler.Slixfeed.is_muc(self, jid): chat_type = "groupchat" else: @@ -216,9 +221,9 @@ async def send_update(self, jid, num=None): send_update, "interval" ) - # interval = await filehandler.initdb( + # interval = await initdb( # jid, - # sqlitehandler.get_settings_value, + # get_settings_value, # "interval" # ) # task_manager[jid]["interval"] = loop.call_at( @@ -227,8 +232,8 @@ async def send_update(self, jid, num=None): # send_update(jid) # ) - # print(await datetimehandler.current_time(), "asyncio.get_event_loop().time()") - # print(await datetimehandler.current_time(), asyncio.get_event_loop().time()) + # print(await current_time(), "asyncio.get_event_loop().time()") + # print(await current_time(), asyncio.get_event_loop().time()) # await asyncio.sleep(60 * interval) # loop.call_later( @@ -242,7 +247,7 @@ async def send_update(self, jid, num=None): async def send_status(self, jid): - # print(await datetimehandler.current_time(), jid, "def send_status") + # print(await current_time(), jid, "def send_status") """ Send status message. @@ -251,23 +256,23 @@ async def send_status(self, jid): jid : str Jabber ID. """ - # print(await datetimehandler.current_time(), "> SEND STATUS",jid) + # print(await current_time(), "> SEND STATUS",jid) status_text="🤖️ Slixfeed RSS News Bot" - enabled = await filehandler.initdb( + enabled = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "enabled" ) if not enabled: status_mode = "xa" status_text = "📫️ Send \"Start\" to receive updates" else: - feeds = await filehandler.initdb( + feeds = await initdb( jid, - sqlitehandler.get_number_of_items, + get_number_of_items, "feeds" ) - # print(await datetimehandler.current_time(), jid, "has", feeds, "feeds") + # print(await current_time(), jid, "has", feeds, "feeds") if not feeds: print(">>> not feeds:", feeds, "jid:", jid) status_mode = "available" @@ -275,9 +280,9 @@ async def send_status(self, jid): "📪️ Send a URL from a blog or a news website" ) else: - unread = await filehandler.initdb( + unread = await initdb( jid, - sqlitehandler.get_number_of_entries_unread + get_number_of_entries_unread ) if unread: status_mode = "chat" @@ -295,7 +300,7 @@ async def send_status(self, jid): status_text = "📭️ No news" # breakpoint() - # print(await datetimehandler.current_time(), status_text, "for", jid) + # print(await current_time(), status_text, "for", jid) xmpphandler.Slixfeed.send_presence( self, pshow=status_mode, @@ -332,9 +337,9 @@ async def refresh_task(self, jid, callback, key, val=None): Value. The default is None. """ if not val: - val = await filehandler.initdb( + val = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, key ) # if task_manager[jid][key]: @@ -364,7 +369,7 @@ async def refresh_task(self, jid, callback, key, val=None): # TODO Take this function out of # async def check_updates(jid): - # print(await datetimehandler.current_time(), jid, "def check_updates") + # print(await current_time(), jid, "def check_updates") """ Start calling for update check up. @@ -374,8 +379,8 @@ async def check_updates(jid): Jabber ID. """ while True: - # print(await datetimehandler.current_time(), "> CHCK UPDATE",jid) - await filehandler.initdb(jid, datahandler.download_updates) + # print(await current_time(), "> CHCK UPDATE",jid) + await initdb(jid, download_updates) await asyncio.sleep(60 * 90) # Schedule to call this function again in 90 minutes # loop.call_at( @@ -397,7 +402,7 @@ async def select_file(self): Initiate actions by JID (Jabber ID). """ while True: - db_dir = filehandler.get_default_dbdir() + db_dir = get_default_dbdir() if not os.path.isdir(db_dir): msg = ( "Slixfeed can not work without a database.\n" @@ -406,7 +411,7 @@ async def select_file(self): "Send a feed to the bot by URL:\n" "https://reclaimthenet.org/feed/" ) - # print(await datetimehandler.current_time(), msg) + # print(await current_time(), msg) print(msg) else: os.chdir(db_dir) diff --git a/slixfeed/xmpphandler.py b/slixfeed/xmpphandler.py index fbfd7be..d4383c2 100644 --- a/slixfeed/xmpphandler.py +++ b/slixfeed/xmpphandler.py @@ -51,23 +51,36 @@ NOTE import asyncio import logging -import os +# import os import slixmpp from random import randrange - +from datahandler import add_feed +from datahandler import add_feed_no_check +from datahandler import feed_to_http +from datahandler import view_entry +from datahandler import view_feed +from datetimehandler import current_time +from filehandler import initdb +from listhandler import add_to_list +from listhandler import remove_from_list +from sqlitehandler import get_settings_value +from sqlitehandler import set_settings_value +from sqlitehandler import mark_source_as_read +from sqlitehandler import last_entries +from sqlitehandler import list_feeds +from sqlitehandler import remove_feed +from sqlitehandler import search_feeds +from sqlitehandler import statistics +from sqlitehandler import toggle_status +from taskhandler import clean_tasks_xmpp +from taskhandler import start_tasks_xmpp +from taskhandler import refresh_task +from taskhandler import send_status +from taskhandler import send_update from slixmpp.plugins.xep_0363.http_upload import FileTooBig, HTTPError, UploadServiceNotFound # from slixmpp.plugins.xep_0402 import BookmarkStorage, Conference from slixmpp.plugins.xep_0048.stanza import Bookmarks -# TODO datahandler -> slixfeed.datahandler -# See project feed2toot -import datahandler -import datetimehandler -import filehandler -import listhandler -import sqlitehandler -import taskhandler - import xmltodict import xml.etree.ElementTree as ET from lxml import etree @@ -170,24 +183,24 @@ class Slixfeed(slixmpp.ClientXMPP): # print("def presence_available", presence["from"].bare) if presence["from"].bare not in self.boundjid.bare: jid = presence["from"].bare - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["interval", "status", "check"] ) - await taskhandler.start_tasks_xmpp( + await start_tasks_xmpp( self, jid, ["interval", "status", "check"] ) - # await taskhandler.task_jid(self, jid) - # main_task.extend([asyncio.create_task(taskhandler.task_jid(jid))]) + # await task_jid(self, jid) + # main_task.extend([asyncio.create_task(task_jid(jid))]) # print(main_task) async def stop_tasks(self, presence): if not self.boundjid.bare: jid = presence["from"].bare print(">>> unavailable:", jid) - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["interval", "status", "check"] ) @@ -224,16 +237,16 @@ class Slixfeed(slixmpp.ClientXMPP): async def join_muc(self, inviter, muc_jid): - token = await filehandler.initdb( + token = await initdb( muc_jid, - sqlitehandler.get_settings_value, + get_settings_value, "token" ) if token != "accepted": token = randrange(10000, 99999) - await filehandler.initdb( + await initdb( muc_jid, - sqlitehandler.set_settings_value, + set_settings_value, ["token", token] ) self.send_message( @@ -325,14 +338,14 @@ class Slixfeed(slixmpp.ClientXMPP): async def on_session_end(self, event): - print(await datetimehandler.current_time(), "Session ended. Attempting to reconnect.") + print(await current_time(), "Session ended. Attempting to reconnect.") print(event) logging.warning("Session ended. Attempting to reconnect.") await self.recover_connection(event) async def on_connection_failed(self, event): - print(await datetimehandler.current_time(), "Connection failed. Attempting to reconnect.") + print(await current_time(), "Connection failed. Attempting to reconnect.") print(event) logging.warning("Connection failed. Attempting to reconnect.") await self.recover_connection(event) @@ -343,7 +356,7 @@ class Slixfeed(slixmpp.ClientXMPP): # if self.connection_attempts <= self.max_connection_attempts: # self.reconnect(wait=5.0) # wait a bit before attempting to reconnect # else: - # print(await datetimehandler.current_time(),"Maximum connection attempts exceeded.") + # print(await current_time(),"Maximum connection attempts exceeded.") # logging.error("Maximum connection attempts exceeded.") print("Attempt:", self.connection_attempts) self.reconnect(wait=5.0) @@ -377,10 +390,10 @@ class Slixfeed(slixmpp.ClientXMPP): print(message) if message["type"] in ("chat", "normal"): jid = message["from"].bare - await taskhandler.refresh_task( + await refresh_task( self, jid, - taskhandler.send_status, + send_status, "status", 20 ) @@ -409,11 +422,11 @@ class Slixfeed(slixmpp.ClientXMPP): jid = presence["from"].bare if presence["show"] in ("away", "dnd", "xa"): print(">>> away, dnd, xa:", jid) - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["interval"] ) - await taskhandler.start_tasks_xmpp( + await start_tasks_xmpp( self, jid, ["status", "check"] @@ -450,7 +463,7 @@ class Slixfeed(slixmpp.ClientXMPP): # Deprecated in favour of event "presence_available" # if not main_task: - # await taskhandler.select_file() + # await select_file() async def is_muc(self, jid): @@ -583,15 +596,15 @@ class Slixfeed(slixmpp.ClientXMPP): if (msg['muc']['nick'] == "Slixfeed (RSS News Bot)" or not msg["body"].startswith("!")): return - token = await filehandler.initdb( + token = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "token" ) if token == "accepted": - operator = await filehandler.initdb( + operator = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "masters" ) if operator: @@ -600,17 +613,17 @@ class Slixfeed(slixmpp.ClientXMPP): # # Begin processing new JID # # Deprecated in favour of event "presence_available" - # db_dir = filehandler.get_default_dbdir() + # db_dir = get_default_dbdir() # os.chdir(db_dir) # if jid + ".db" not in os.listdir(): - # await taskhandler.task_jid(jid) + # await task_jid(jid) message = " ".join(msg["body"].split()) if msg["type"] == "groupchat": message = message[1:] message_lowercase = message.lower() - print(await datetimehandler.current_time(), "ACCOUNT: " + str(msg["from"])) - print(await datetimehandler.current_time(), "COMMAND:", message) + print(await current_time(), "ACCOUNT: " + str(msg["from"])) + print(await current_time(), "COMMAND:", message) match message_lowercase: case "help": @@ -639,20 +652,20 @@ class Slixfeed(slixmpp.ClientXMPP): case _ if message_lowercase.startswith("activate"): if msg["type"] == "groupchat": acode = message[9:] - token = await filehandler.initdb( + token = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "token" ) if int(acode) == token: - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, ["masters", nick] ) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, ["token", "accepted"] ) action = "{}, your are in command.".format(nick) @@ -665,31 +678,31 @@ class Slixfeed(slixmpp.ClientXMPP): url = message.split(" ")[0] title = " ".join(message.split(" ")[1:]) if url.startswith("http"): - action = await filehandler.initdb( + action = await initdb( jid, - datahandler.add_feed_no_check, + add_feed_no_check, [url, title] ) - old = await filehandler.initdb( + old = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "old" ) if old: - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["status"] ) - # await taskhandler.send_status(jid) - await taskhandler.start_tasks_xmpp( + # await send_status(jid) + await start_tasks_xmpp( self, jid, ["status"] ) else: - await filehandler.initdb( + await initdb( jid, - sqlitehandler.mark_source_as_read, + mark_source_as_read, url ) else: @@ -698,18 +711,18 @@ class Slixfeed(slixmpp.ClientXMPP): key = "filter-" + message[:5] val = message[7:] if val: - keywords = await filehandler.initdb( + keywords = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, key ) - val = await listhandler.add_to_list( + val = await add_to_list( val, keywords ) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) action = ( @@ -722,18 +735,18 @@ class Slixfeed(slixmpp.ClientXMPP): key = "filter-" + message[:5] val = message[7:] if val: - keywords = await filehandler.initdb( + keywords = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, key ) - val = await listhandler.remove_from_list( + val = await remove_from_list( val, keywords ) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) action = ( @@ -746,18 +759,18 @@ class Slixfeed(slixmpp.ClientXMPP): key = "filter-" + message[:4] val = message[6:] if val: - keywords = await filehandler.initdb( + keywords = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, key ) - val = await listhandler.add_to_list( + val = await add_to_list( val, keywords ) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) action = ( @@ -770,18 +783,18 @@ class Slixfeed(slixmpp.ClientXMPP): key = "filter-" + message[:4] val = message[6:] if val: - keywords = await filehandler.initdb( + keywords = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, key ) - val = await listhandler.remove_from_list( + val = await remove_from_list( val, keywords ) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) action = ( @@ -797,8 +810,8 @@ class Slixfeed(slixmpp.ClientXMPP): message_lowercase.startswith("feed:")): url = message if url.startswith("feed:"): - url = await datahandler.feed_to_http(url) - await taskhandler.clean_tasks_xmpp( + url = await feed_to_http(url) + await clean_tasks_xmpp( jid, ["status"] ) @@ -806,55 +819,55 @@ class Slixfeed(slixmpp.ClientXMPP): "📫️ Processing request to fetch data from {}" ).format(url) process_task_message(self, jid, task) - action = await filehandler.initdb( + action = await initdb( jid, - datahandler.add_feed, + add_feed, url ) - await taskhandler.start_tasks_xmpp( + await start_tasks_xmpp( self, jid, ["status"] ) # action = "> " + message + "\n" + action # FIXME Make the taskhandler to update status message - # await taskhandler.refresh_task( + # await refresh_task( # self, # jid, - # taskhandler.send_status, + # send_status, # "status", # 20 # ) # NOTE This would show the number of new unread entries - old = await filehandler.initdb( + old = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, "old" ) if old: - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["status"] ) - # await taskhandler.send_status(jid) - await taskhandler.start_tasks_xmpp( + # await send_status(jid) + await start_tasks_xmpp( self, jid, ["status"] ) else: - await filehandler.initdb( + await initdb( jid, - sqlitehandler.mark_source_as_read, + mark_source_as_read, url ) case _ if message_lowercase.startswith("feeds"): query = message[6:] if query: if len(query) > 3: - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.search_feeds, + search_feeds, query ) else: @@ -862,9 +875,9 @@ class Slixfeed(slixmpp.ClientXMPP): "Enter at least 4 characters to search" ) else: - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.list_feeds + list_feeds ) case "goodbye": if msg["type"] == "groupchat": @@ -883,17 +896,17 @@ class Slixfeed(slixmpp.ClientXMPP): # action = ( # "Updates will be sent every {} minutes." # ).format(action) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) # NOTE Perhaps this should be replaced # by functions clean and start - await taskhandler.refresh_task( + await refresh_task( self, jid, - taskhandler.send_update, + send_update, key, val ) @@ -909,9 +922,9 @@ class Slixfeed(slixmpp.ClientXMPP): key = message[:6] val = message[7:] if val: - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) if val == 0: @@ -928,18 +941,18 @@ class Slixfeed(slixmpp.ClientXMPP): key = message[:7] val = message[11:] if val: - names = await filehandler.initdb( + names = await initdb( jid, - sqlitehandler.get_settings_value, + get_settings_value, key ) - val = await listhandler.add_to_list( + val = await add_to_list( val, names ) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) action = ( @@ -949,9 +962,9 @@ class Slixfeed(slixmpp.ClientXMPP): else: action = "Missing value." case "new": - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, ["old", 0] ) action = ( @@ -959,34 +972,34 @@ class Slixfeed(slixmpp.ClientXMPP): ) case _ if message_lowercase.startswith("next"): num = message[5:] - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["interval", "status"] ) - await taskhandler.start_tasks_xmpp( + await start_tasks_xmpp( self, jid, ["interval", "status"] ) - # await taskhandler.refresh_task( + # await refresh_task( # self, # jid, - # taskhandler.send_update, + # send_update, # "interval", # num # ) - # await taskhandler.refresh_task( + # await refresh_task( # self, # jid, - # taskhandler.send_status, + # send_status, # "status", # 20 # ) - # await taskhandler.refresh_task(jid, key, val) + # await refresh_task(jid, key, val) case "old": - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, ["old", 1] ) action = ( @@ -999,9 +1012,9 @@ class Slixfeed(slixmpp.ClientXMPP): # action = ( # "Every update will contain {} news items." # ).format(action) - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) action = ( @@ -1019,22 +1032,22 @@ class Slixfeed(slixmpp.ClientXMPP): "📫️ Processing request to fetch data from {}" ).format(url) process_task_message(self, jid, task) - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["status"] ) if url.startswith("feed:"): - url = await datahandler.feed_to_http(url) + url = await feed_to_http(url) match len(data): case 1: if url.startswith("http"): - action = await datahandler.view_feed(url) + action = await view_feed(url) else: action = "Missing URL." case 2: num = data[1] if url.startswith("http"): - action = await datahandler.view_entry(url, num) + action = await view_entry(url, num) else: action = "Missing URL." case _: @@ -1043,7 +1056,7 @@ class Slixfeed(slixmpp.ClientXMPP): "`read URL` or `read URL NUMBER`\n" "URL must not contain white space." ) - await taskhandler.start_tasks_xmpp( + await start_tasks_xmpp( self, jid, ["status"] @@ -1051,9 +1064,9 @@ class Slixfeed(slixmpp.ClientXMPP): case _ if message_lowercase.startswith("recent"): num = message[7:] if num: - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.last_entries, + last_entries, num ) else: @@ -1061,23 +1074,23 @@ class Slixfeed(slixmpp.ClientXMPP): case _ if message_lowercase.startswith("remove"): ix = message[7:] if ix: - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.remove_feed, + remove_feed, ix ) - # await taskhandler.refresh_task( + # await refresh_task( # self, # jid, - # taskhandler.send_status, + # send_status, # "status", # 20 # ) - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["status"] ) - await taskhandler.start_tasks_xmpp( + await start_tasks_xmpp( self, jid, ["status"] @@ -1088,9 +1101,9 @@ class Slixfeed(slixmpp.ClientXMPP): query = message[7:] if query: if len(query) > 1: - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.search_entries, + search_entries, query ) else: @@ -1103,30 +1116,30 @@ class Slixfeed(slixmpp.ClientXMPP): # action = "Updates are enabled." key = "enabled" val = 1 - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) - # asyncio.create_task(taskhandler.task_jid(self, jid)) - await taskhandler.start_tasks_xmpp( + # asyncio.create_task(task_jid(self, jid)) + await start_tasks_xmpp( self, jid, ["interval", "status", "check"] ) action = "Updates are enabled." - # print(await datetimehandler.current_time(), "task_manager[jid]") + # print(await current_time(), "task_manager[jid]") # print(task_manager[jid]) case "stats": - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.statistics + statistics ) case _ if message_lowercase.startswith("status "): ix = message[7:] - action = await filehandler.initdb( + action = await initdb( jid, - sqlitehandler.toggle_status, + toggle_status, ix ) case "stop": @@ -1142,23 +1155,23 @@ class Slixfeed(slixmpp.ClientXMPP): # task_manager[jid]["interval"].cancel() # key = "enabled" # val = 0 - # action = await filehandler.initdb( + # action = await initdb( # jid, - # sqlitehandler.set_settings_value, + # set_settings_value, # [key, val] # ) # except: # action = "Updates are already disabled." # # print("Updates are already disabled. Nothing to do.") - # # await taskhandler.send_status(jid) + # # await send_status(jid) key = "enabled" val = 0 - await filehandler.initdb( + await initdb( jid, - sqlitehandler.set_settings_value, + set_settings_value, [key, val] ) - await taskhandler.clean_tasks_xmpp( + await clean_tasks_xmpp( jid, ["interval", "status"] )