forked from sch/Slixfeed
1009 lines
36 KiB
Python
1009 lines
36 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
|
|
FIXME
|
|
|
|
1) Function check_readiness or event "changed_status" is causing for
|
|
triple status messages and also false ones that indicate of lack
|
|
of feeds.
|
|
|
|
TODO
|
|
|
|
1) Deprecate "add" (see above) and make it interactive.
|
|
Slixfeed: Do you still want to add this URL to subscription list?
|
|
See: case _ if message_lowercase.startswith("add"):
|
|
|
|
2) Use loop (with gather) instead of TaskGroup.
|
|
|
|
3) Assure message delivery before calling a new task.
|
|
See https://slixmpp.readthedocs.io/en/latest/event_index.html#term-marker_acknowledged
|
|
|
|
4) Do not send updates when busy or away.
|
|
See https://slixmpp.readthedocs.io/en/latest/event_index.html#term-changed_status
|
|
|
|
NOTE
|
|
|
|
1) Self presence
|
|
Apparently, it is possible to view self presence.
|
|
This means that there is no need to store presences in order to switch or restore presence.
|
|
check_readiness
|
|
<presence from="slixfeed@canchat.org/xAPgJLHtMMHF" xml:lang="en" id="ab35c07b63a444d0a7c0a9a0b272f301" to="slixfeed@canchat.org/xAPgJLHtMMHF"><status>📂 Send a URL from a blog or a news website.</status><x xmlns="vcard-temp:x:update"><photo /></x></presence>
|
|
JID: self.boundjid.bare
|
|
MUC: self.nick
|
|
|
|
2) Extracting attribute using xmltodict.
|
|
import xmltodict
|
|
message = xmltodict.parse(str(message))
|
|
jid = message["message"]["x"]["@jid"]
|
|
|
|
"""
|
|
|
|
import asyncio
|
|
import logging
|
|
import os
|
|
import slixmpp
|
|
from random import randrange
|
|
|
|
from slixmpp.plugins.xep_0363.http_upload import FileTooBig, HTTPError, UploadServiceNotFound
|
|
|
|
import datahandler
|
|
import datetimehandler
|
|
import filehandler
|
|
import filterhandler
|
|
import sqlitehandler
|
|
import taskhandler
|
|
|
|
main_task = []
|
|
jid_tasker = {}
|
|
task_manager = {}
|
|
loop = asyncio.get_event_loop()
|
|
# asyncio.set_event_loop(loop)
|
|
|
|
# time_now = datetime.now()
|
|
# time_now = time_now.strftime("%H:%M:%S")
|
|
|
|
# def print_time():
|
|
# # return datetime.now().strftime("%H:%M:%S")
|
|
# now = datetime.now()
|
|
# current_time = now.strftime("%H:%M:%S")
|
|
# return current_time
|
|
|
|
|
|
class Slixfeed(slixmpp.ClientXMPP):
|
|
"""
|
|
Slixmpp
|
|
-------
|
|
News bot that sends updates from RSS feeds.
|
|
"""
|
|
def __init__(self, jid, password, room=None, nick=None):
|
|
slixmpp.ClientXMPP.__init__(self, jid, password)
|
|
|
|
# The session_start event will be triggered when
|
|
# the bot establishes its connection with the server
|
|
# and the XML streams are ready for use. We want to
|
|
# listen for this event so that we we can initialize
|
|
# our roster.
|
|
self.add_event_handler("session_start", self.start_session)
|
|
self.add_event_handler("session_resumed", self.start_session)
|
|
self.add_event_handler("got_offline", print("got_offline"))
|
|
# self.add_event_handler("got_online", self.check_readiness)
|
|
self.add_event_handler("changed_status", self.check_readiness)
|
|
self.add_event_handler("presence_unavailable", self.stop_tasks)
|
|
|
|
# self.add_event_handler("changed_subscription", self.check_subscription)
|
|
|
|
# self.add_event_handler("chatstate_active", self.check_chatstate_active)
|
|
# self.add_event_handler("chatstate_gone", self.check_chatstate_gone)
|
|
self.add_event_handler("chatstate_composing", self.check_chatstate_composing)
|
|
self.add_event_handler("chatstate_paused", self.check_chatstate_paused)
|
|
|
|
# The message event is triggered whenever a message
|
|
# stanza is received. Be aware that that includes
|
|
# MUC messages and error messages.
|
|
self.add_event_handler("message", self.message)
|
|
self.add_event_handler("message", self.settle)
|
|
|
|
self.add_event_handler("groupchat_invite", self.accept_muc_invite)
|
|
self.add_event_handler("groupchat_direct_invite", self.accept_muc_invite)
|
|
# self.add_event_handler("groupchat_message", self.message)
|
|
|
|
# self.add_event_handler("disconnected", self.reconnect)
|
|
# self.add_event_handler("disconnected", self.inspect_connection)
|
|
|
|
self.add_event_handler("reactions", self.reactions)
|
|
self.add_event_handler("presence_available", self.presence_available)
|
|
self.add_event_handler("presence_error", self.presence_error)
|
|
self.add_event_handler("presence_subscribe", self.presence_subscribe)
|
|
self.add_event_handler("presence_subscribed", self.presence_subscribed)
|
|
self.add_event_handler("presence_unsubscribe", self.presence_unsubscribe)
|
|
self.add_event_handler("presence_unsubscribed", self.unsubscribe)
|
|
|
|
# Initialize event loop
|
|
# self.loop = asyncio.get_event_loop()
|
|
|
|
# handlers for connection events
|
|
self.connection_attempts = 0
|
|
self.max_connection_attempts = 10
|
|
self.add_event_handler("connection_failed", self.on_connection_failed)
|
|
self.add_event_handler("session_end", self.on_session_end)
|
|
|
|
"""
|
|
|
|
FIXME
|
|
|
|
This function is triggered even when status is dnd/away/xa.
|
|
This results in sending messages even when status is dnd/away/xa.
|
|
See function check_readiness.
|
|
|
|
NOTE
|
|
|
|
The issue occurs only at bot startup.
|
|
Once status is changed to dnd/away/xa, the interval stops - as expected.
|
|
|
|
TODO
|
|
|
|
Use "sleep()"
|
|
|
|
"""
|
|
async def presence_available(self, presence):
|
|
# 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(
|
|
jid,
|
|
["interval", "status", "check"]
|
|
)
|
|
await taskhandler.start_tasks_xmpp(
|
|
self,
|
|
jid,
|
|
["interval", "status", "check"]
|
|
)
|
|
# await taskhandler.task_jid(self, jid)
|
|
# main_task.extend([asyncio.create_task(taskhandler.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(
|
|
jid,
|
|
["interval", "status", "check"]
|
|
)
|
|
|
|
|
|
async def presence_error(self, presence):
|
|
print("presence_error")
|
|
print(presence)
|
|
|
|
async def presence_subscribe(self, presence):
|
|
print("presence_subscribe")
|
|
print(presence)
|
|
|
|
async def presence_subscribed(self, presence):
|
|
print("presence_subscribed")
|
|
print(presence)
|
|
|
|
async def reactions(self, message):
|
|
print("reactions")
|
|
print(message)
|
|
|
|
async def accept_muc_invite(self, message):
|
|
ctr = message["from"].bare
|
|
jid = message['groupchat_invite']['jid']
|
|
tkn = randrange(10000, 99999)
|
|
self.plugin['xep_0045'].join_muc(
|
|
jid,
|
|
"Slixfeed (RSS News Bot)",
|
|
# If a room password is needed, use:
|
|
# password=the_room_password,
|
|
)
|
|
self.send_message(
|
|
mto=ctr,
|
|
mbody=(
|
|
"Send activation token {} to groupchat xmpp:{}?join."
|
|
).format(tkn, jid)
|
|
)
|
|
# self.add_event_handler(
|
|
# "muc::[room]::message",
|
|
# self.message
|
|
# )
|
|
|
|
|
|
async def on_session_end(self, event):
|
|
print(await datetimehandler.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(event)
|
|
logging.warning("Connection failed. Attempting to reconnect.")
|
|
await self.recover_connection(event)
|
|
|
|
|
|
async def recover_connection(self, event):
|
|
self.connection_attempts += 1
|
|
# 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.")
|
|
# logging.error("Maximum connection attempts exceeded.")
|
|
print("Attempt:", self.connection_attempts)
|
|
self.reconnect(wait=5.0)
|
|
|
|
|
|
async def inspect_connection(self, event):
|
|
print("Disconnected\nReconnecting...")
|
|
print(event)
|
|
try:
|
|
self.reconnect
|
|
except:
|
|
self.disconnect()
|
|
print("Problem reconnecting")
|
|
|
|
|
|
async def check_chatstate_composing(self, message):
|
|
print("def check_chatstate_composing")
|
|
print(message)
|
|
if message["type"] in ("chat", "normal"):
|
|
jid = message["from"].bare
|
|
status_text="Press \"help\" for manual."
|
|
self.send_presence(
|
|
# pshow=status_mode,
|
|
pstatus=status_text,
|
|
pto=jid,
|
|
)
|
|
|
|
|
|
async def check_chatstate_paused(self, message):
|
|
print("def check_chatstate_paused")
|
|
print(message)
|
|
if message["type"] in ("chat", "normal"):
|
|
jid = message["from"].bare
|
|
await taskhandler.refresh_task(
|
|
self,
|
|
jid,
|
|
taskhandler.send_status,
|
|
"status",
|
|
20
|
|
)
|
|
|
|
|
|
async def check_readiness(self, presence):
|
|
"""
|
|
If available, begin tasks.
|
|
If unavailable, eliminate tasks.
|
|
|
|
Parameters
|
|
----------
|
|
presence : str
|
|
XML stanza </presence>.
|
|
|
|
Returns
|
|
-------
|
|
None.
|
|
"""
|
|
# print("def check_readiness", presence["from"].bare, presence["type"])
|
|
# # available unavailable away (chat) dnd xa
|
|
# print(">>> type", presence["type"], presence["from"].bare)
|
|
# # away chat dnd xa
|
|
# print(">>> show", presence["show"], presence["from"].bare)
|
|
|
|
jid = presence["from"].bare
|
|
if presence["show"] in ("away", "dnd", "xa"):
|
|
print(">>> away, dnd, xa:", jid)
|
|
await taskhandler.clean_tasks_xmpp(
|
|
jid,
|
|
["interval"]
|
|
)
|
|
await taskhandler.start_tasks_xmpp(
|
|
self,
|
|
jid,
|
|
["status", "check"]
|
|
)
|
|
|
|
|
|
async def resume(self, event):
|
|
print("def resume")
|
|
print(event)
|
|
self.send_presence()
|
|
await self.get_roster()
|
|
|
|
|
|
async def start_session(self, event):
|
|
"""
|
|
Process the session_start event.
|
|
|
|
Typical actions for the session_start event are
|
|
requesting the roster and broadcasting an initial
|
|
presence stanza.
|
|
|
|
Arguments:
|
|
event -- An empty dictionary. The session_start
|
|
event does not provide any additional
|
|
data.
|
|
"""
|
|
print("def start_session")
|
|
print(event)
|
|
self.send_presence()
|
|
await self.get_roster()
|
|
|
|
# for task in main_task:
|
|
# task.cancel()
|
|
|
|
# Deprecated in favour of event "presence_available"
|
|
# if not main_task:
|
|
# await taskhandler.select_file()
|
|
|
|
|
|
async def settle(self, msg):
|
|
"""
|
|
Add JID to roster and settle subscription.
|
|
|
|
Parameters
|
|
----------
|
|
jid : str
|
|
Jabber ID.
|
|
|
|
Returns
|
|
-------
|
|
None.
|
|
"""
|
|
jid = msg["from"].bare
|
|
await self.get_roster()
|
|
# Check whether JID is in roster; otherwise, add it.
|
|
if jid not in self.client_roster.keys():
|
|
self.send_presence_subscription(
|
|
pto=jid,
|
|
ptype="subscribe",
|
|
pnick="Slixfeed RSS News Bot"
|
|
)
|
|
self.update_roster(
|
|
jid,
|
|
subscription="both"
|
|
)
|
|
# Check whether JID is subscribed; otherwise, ask for presence.
|
|
if not self.client_roster[jid]["to"]:
|
|
self.send_presence_subscription(
|
|
pto=jid,
|
|
pfrom=self.boundjid.bare,
|
|
ptype="subscribe",
|
|
pnick="Slixfeed RSS News Bot"
|
|
)
|
|
self.send_message(
|
|
mto=jid,
|
|
mtype="headline",
|
|
msubject="RSS News Bot",
|
|
mbody=("Accept subscription request to receive updates."),
|
|
mfrom=self.boundjid.bare,
|
|
mnick="Slixfeed RSS News Bot"
|
|
)
|
|
self.send_presence(
|
|
pto=jid,
|
|
pfrom=self.boundjid.bare,
|
|
# Accept symbol 🉑️ 👍️ ✍
|
|
pstatus="✒️ Accept subscription request to receive updates",
|
|
# ptype="subscribe",
|
|
pnick="Slixfeed RSS News Bot"
|
|
)
|
|
|
|
|
|
async def presence_unsubscribe(self, presence):
|
|
print("presence_unsubscribe")
|
|
print(presence)
|
|
|
|
|
|
async def unsubscribe(self, presence):
|
|
jid = presence["from"].bare
|
|
self.send_presence(
|
|
pto=jid,
|
|
pfrom=self.boundjid.bare,
|
|
pstatus="🖋️ Subscribe to receive updates",
|
|
pnick="Slixfeed RSS News Bot"
|
|
)
|
|
self.send_message(
|
|
mto=jid,
|
|
mbody="You have been unsubscribed."
|
|
)
|
|
self.update_roster(
|
|
jid,
|
|
subscription="remove"
|
|
)
|
|
|
|
|
|
async def message(self, msg):
|
|
"""
|
|
Process incoming message stanzas. Be aware that this also
|
|
includes MUC messages and error messages. It is usually
|
|
a good practice to check the messages's type before
|
|
processing or sending replies.
|
|
|
|
Parameters
|
|
----------
|
|
msg : str
|
|
The received message stanza. See the documentation
|
|
for stanza objects and the Message stanza to see
|
|
how it may be used.
|
|
"""
|
|
# print("message")
|
|
# print(msg)
|
|
if msg["type"] in ("chat", "groupchat", "normal"):
|
|
action = 0
|
|
jid = msg["from"].bare
|
|
if msg["type"] == "groupchat":
|
|
ctr = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.get_settings_value,
|
|
"masters"
|
|
)
|
|
if (msg["from"][msg["from"].index("/")+1:] not in ctr
|
|
or not msg["body"].startswith("!")):
|
|
return
|
|
|
|
# # Begin processing new JID
|
|
# # Deprecated in favour of event "presence_available"
|
|
# db_dir = filehandler.get_default_dbdir()
|
|
# os.chdir(db_dir)
|
|
# if jid + ".db" not in os.listdir():
|
|
# await taskhandler.task_jid(jid)
|
|
print(msg["body"])
|
|
print(msg["body"].split())
|
|
message = " ".join(msg["body"].split())
|
|
if msg["type"] == "groupchat":
|
|
message = message[1:]
|
|
print(message)
|
|
message_lowercase = message.lower()
|
|
|
|
print(await datetimehandler.current_time(), "ACCOUNT: " + str(msg["from"]))
|
|
print(await datetimehandler.current_time(), "COMMAND:", message)
|
|
|
|
match message_lowercase:
|
|
case "help":
|
|
action = print_help()
|
|
case "info":
|
|
action = print_info()
|
|
case _ if message_lowercase in [
|
|
"greetings", "hallo", "hello", "hey",
|
|
"hi", "hola", "holla", "hollo"]:
|
|
action = (
|
|
"Greeting!\n"
|
|
"I'm Slixfeed, an RSS News Bot!\n"
|
|
"Send \"help\" for instructions."
|
|
)
|
|
# print("task_manager[jid]")
|
|
# print(task_manager[jid])
|
|
await self.get_roster()
|
|
print("roster 1")
|
|
print(self.client_roster)
|
|
print("roster 2")
|
|
print(self.client_roster.keys())
|
|
case _ if message_lowercase.startswith("add"):
|
|
message = message[4:]
|
|
url = message.split(" ")[0]
|
|
title = " ".join(message.split(" ")[1:])
|
|
if url.startswith("http"):
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
datahandler.add_feed_no_check,
|
|
[url, title]
|
|
)
|
|
await taskhandler.refresh_task(
|
|
self,
|
|
jid,
|
|
taskhandler.send_status,
|
|
"status",
|
|
20
|
|
)
|
|
else:
|
|
action = "Missing URL."
|
|
case _ if message_lowercase.startswith("allow"):
|
|
key = "filter-" + message[:5]
|
|
val = message[6:]
|
|
if val:
|
|
keywords = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.get_settings_value,
|
|
key
|
|
)
|
|
val = await filterhandler.set_filter(
|
|
val,
|
|
keywords
|
|
)
|
|
await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.set_settings_value,
|
|
[key, val]
|
|
)
|
|
action = (
|
|
"Approved keywords\n"
|
|
"```\n{}\n```"
|
|
).format(val)
|
|
else:
|
|
action = "Missing keywords."
|
|
case _ if message_lowercase.startswith("deny"):
|
|
key = "filter-" + message[:4]
|
|
val = message[5:]
|
|
if val:
|
|
keywords = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.get_settings_value,
|
|
key
|
|
)
|
|
val = await filterhandler.set_filter(
|
|
val,
|
|
keywords
|
|
)
|
|
await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.set_settings_value,
|
|
[key, val]
|
|
)
|
|
action = (
|
|
"Rejected keywords\n"
|
|
"```\n{}\n```"
|
|
).format(val)
|
|
else:
|
|
action = "Missing keywords."
|
|
case _ if (message_lowercase.startswith("gemini") or
|
|
message_lowercase.startswith("gopher:")):
|
|
action = "Gemini and Gopher are not supported yet."
|
|
case _ if (message_lowercase.startswith("http") or
|
|
message_lowercase.startswith("feed:")):
|
|
url = message
|
|
if url.startswith("feed:"):
|
|
url = await datahandler.feed_to_http(url)
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
datahandler.add_feed,
|
|
url
|
|
)
|
|
# action = "> " + message + "\n" + action
|
|
# FIXME Make the taskhandler to update status message
|
|
# await taskhandler.refresh_task(
|
|
# self,
|
|
# jid,
|
|
# taskhandler.send_status,
|
|
# "status",
|
|
# 20
|
|
# )
|
|
# NOTE This would show the number of new unread entries
|
|
await taskhandler.clean_tasks_xmpp(
|
|
jid,
|
|
["status"]
|
|
)
|
|
# await taskhandler.send_status(jid)
|
|
await taskhandler.start_tasks_xmpp(
|
|
self,
|
|
jid,
|
|
["status"]
|
|
)
|
|
case _ if message_lowercase.startswith("feeds"):
|
|
query = message[6:]
|
|
if query:
|
|
if len(query) > 3:
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.search_feeds,
|
|
query
|
|
)
|
|
else:
|
|
action = (
|
|
"Enter at least 4 characters to search"
|
|
)
|
|
else:
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.list_feeds
|
|
)
|
|
case _ if message_lowercase.startswith("interval"):
|
|
# FIXME
|
|
# The following error occurs only upon first attempt to set interval.
|
|
# /usr/lib/python3.11/asyncio/events.py:73: RuntimeWarning: coroutine 'Slixfeed.send_update' was never awaited
|
|
# self._args = None
|
|
# RuntimeWarning: Enable tracemalloc to get the object allocation traceback
|
|
key = message[:8]
|
|
val = message[9:]
|
|
if val:
|
|
# action = (
|
|
# "Updates will be sent every {} minutes."
|
|
# ).format(action)
|
|
await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.set_settings_value,
|
|
[key, val]
|
|
)
|
|
await taskhandler.refresh_task(
|
|
self,
|
|
jid,
|
|
taskhandler.send_update,
|
|
key,
|
|
val
|
|
)
|
|
action = (
|
|
"Updates will be sent every {} minutes."
|
|
).format(val)
|
|
else:
|
|
action = "Missing value."
|
|
case _ if message_lowercase.startswith("next"):
|
|
num = message[5:]
|
|
await taskhandler.clean_tasks_xmpp(
|
|
jid,
|
|
["interval", "status"]
|
|
)
|
|
await taskhandler.start_tasks_xmpp(
|
|
self,
|
|
jid,
|
|
["interval", "status"]
|
|
)
|
|
# await taskhandler.refresh_task(
|
|
# self,
|
|
# jid,
|
|
# taskhandler.send_update,
|
|
# "interval",
|
|
# num
|
|
# )
|
|
# await taskhandler.refresh_task(
|
|
# self,
|
|
# jid,
|
|
# taskhandler.send_status,
|
|
# "status",
|
|
# 20
|
|
# )
|
|
# await taskhandler.refresh_task(jid, key, val)
|
|
case _ if message_lowercase.startswith("quantum"):
|
|
key = message[:7]
|
|
val = message[8:]
|
|
if val:
|
|
# action = (
|
|
# "Every update will contain {} news items."
|
|
# ).format(action)
|
|
await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.set_settings_value,
|
|
[key, val]
|
|
)
|
|
action = (
|
|
"Next update will contain {} news items."
|
|
).format(val)
|
|
else:
|
|
action = "Missing value."
|
|
case "random":
|
|
action = "Updates will be sent randomly."
|
|
case _ if message_lowercase.startswith("read"):
|
|
url = message[5:]
|
|
if url.startswith("http"):
|
|
# action = await datahandler.view_feed(url)
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
datahandler.view_feed,
|
|
url
|
|
)
|
|
else:
|
|
action = "Missing URL."
|
|
case _ if message_lowercase.startswith("recent"):
|
|
num = message[7:]
|
|
if num:
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.last_entries,
|
|
num
|
|
)
|
|
else:
|
|
action = "Missing value."
|
|
case _ if message_lowercase.startswith("remove"):
|
|
ix = message[7:]
|
|
if ix:
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.remove_feed,
|
|
ix
|
|
)
|
|
# await taskhandler.refresh_task(
|
|
# self,
|
|
# jid,
|
|
# taskhandler.send_status,
|
|
# "status",
|
|
# 20
|
|
# )
|
|
await taskhandler.clean_tasks_xmpp(
|
|
jid,
|
|
["status"]
|
|
)
|
|
await taskhandler.start_tasks_xmpp(
|
|
self,
|
|
jid,
|
|
["status"]
|
|
)
|
|
else:
|
|
action = "Missing feed ID."
|
|
case _ if message_lowercase.startswith("search"):
|
|
query = message[7:]
|
|
if query:
|
|
if len(query) > 1:
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.search_entries,
|
|
query
|
|
)
|
|
else:
|
|
action = (
|
|
"Enter at least 2 characters to search"
|
|
)
|
|
else:
|
|
action = "Missing search query."
|
|
case "start":
|
|
# action = "Updates are enabled."
|
|
key = "enabled"
|
|
val = 1
|
|
await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.set_settings_value,
|
|
[key, val]
|
|
)
|
|
# asyncio.create_task(taskhandler.task_jid(self, jid))
|
|
await taskhandler.start_tasks_xmpp(
|
|
self,
|
|
jid,
|
|
["interval", "status", "check"]
|
|
)
|
|
action = "Updates are enabled."
|
|
# print(await datetimehandler.current_time(), "task_manager[jid]")
|
|
# print(task_manager[jid])
|
|
case "stats":
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.statistics
|
|
)
|
|
case _ if message_lowercase.startswith("select"):
|
|
num = message[7:]
|
|
if num:
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
datahandler.view_entry,
|
|
num
|
|
)
|
|
else:
|
|
action = "Missing number."
|
|
case _ if message_lowercase.startswith("status "):
|
|
ix = message[7:]
|
|
action = await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.toggle_status,
|
|
ix
|
|
)
|
|
case "stop":
|
|
# FIXME
|
|
# The following error occurs only upon first attempt to stop.
|
|
# /usr/lib/python3.11/asyncio/events.py:73: RuntimeWarning: coroutine 'Slixfeed.send_update' was never awaited
|
|
# self._args = None
|
|
# RuntimeWarning: Enable tracemalloc to get the object allocation traceback
|
|
# action = "Updates are disabled."
|
|
# try:
|
|
# # task_manager[jid]["check"].cancel()
|
|
# # task_manager[jid]["status"].cancel()
|
|
# task_manager[jid]["interval"].cancel()
|
|
# key = "enabled"
|
|
# val = 0
|
|
# action = await filehandler.initdb(
|
|
# jid,
|
|
# sqlitehandler.set_settings_value,
|
|
# [key, val]
|
|
# )
|
|
# except:
|
|
# action = "Updates are already disabled."
|
|
# # print("Updates are already disabled. Nothing to do.")
|
|
# # await taskhandler.send_status(jid)
|
|
key = "enabled"
|
|
val = 0
|
|
await filehandler.initdb(
|
|
jid,
|
|
sqlitehandler.set_settings_value,
|
|
[key, val]
|
|
)
|
|
await taskhandler.clean_tasks_xmpp(jid, ["interval"])
|
|
self.send_presence(
|
|
pshow="xa",
|
|
pstatus="Send \"Start\" to receive news.",
|
|
pto=jid,
|
|
)
|
|
action = "Updates are disabled."
|
|
case "support":
|
|
# TODO Send an invitation.
|
|
action = "Join xmpp:slixmpp@muc.poez.io?join"
|
|
case _:
|
|
action = (
|
|
"Unknown command. "
|
|
"Press \"help\" for list of commands"
|
|
)
|
|
if action: msg.reply(action).send()
|
|
|
|
|
|
def print_info():
|
|
"""
|
|
Print information.
|
|
|
|
Returns
|
|
-------
|
|
msg : str
|
|
Message.
|
|
"""
|
|
msg = (
|
|
"```\n"
|
|
"NAME\n"
|
|
"Slixfeed - News syndication bot for Jabber/XMPP\n"
|
|
"\n"
|
|
"DESCRIPTION\n"
|
|
" Slixfeed is a news aggregator bot for online news feeds.\n"
|
|
" This program is primarily designed for XMPP.\n"
|
|
" For more information, visit https://xmpp.org/software/\n"
|
|
"\n"
|
|
# "PROTOCOLS\n"
|
|
# " Supported prootcols are IRC, Matrix and XMPP.\n"
|
|
# " For the best experience, we recommend you to use XMPP.\n"
|
|
# "\n"
|
|
"FILETYPES\n"
|
|
" Supported filetypes are Atom, RDF and RSS.\n"
|
|
"\n"
|
|
"AUTHORS\n"
|
|
" Laura Harbinger, Schimon Zackary.\n"
|
|
"\n"
|
|
"THANKS\n"
|
|
" Christian Dersch (SalixOS),"
|
|
" Cyrille Pontvieux (SalixOS, France),"
|
|
"\n"
|
|
" Denis Fomin (Gajim, Russia),"
|
|
" Dimitris Tzemos (SalixOS, Greece),"
|
|
"\n"
|
|
" Emmanuel Gil Peyrot (poezio, France),"
|
|
" George Vlahavas (SalixOS, Greece),"
|
|
"\n"
|
|
" Pierrick Le Brun (SalixOS, France),"
|
|
" Thorsten Mühlfelder (SalixOS, Germany),"
|
|
"\n"
|
|
" Yann Leboulanger (Gajim, France).\n"
|
|
"\n"
|
|
"COPYRIGHT\n"
|
|
" Slixfeed is free software; you can redistribute it and/or\n"
|
|
" modify it under the terms of the GNU General Public License\n"
|
|
" as published by the Free Software Foundation; version 3 only\n"
|
|
"\n"
|
|
" Slixfeed is distributed in the hope that it will be useful,\n"
|
|
" but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
" GNU General Public License for more details.\n"
|
|
"\n"
|
|
"NOTE\n"
|
|
" Make Slixfeed your own.\n"
|
|
"\n"
|
|
" You can run Slixfeed on your own computer, server, and\n"
|
|
" even on a Linux phone (i.e. Droidian, Mobian NixOS,\n"
|
|
" postmarketOS). You can also use Termux.\n"
|
|
"\n"
|
|
" All you need is one of the above and an XMPP account to\n"
|
|
" connect Slixfeed to.\n"
|
|
"\n"
|
|
"DOCUMENTATION\n"
|
|
" Slixfeed\n"
|
|
" https://gitgud.io/sjehuda/slixfeed\n"
|
|
" Slixmpp\n"
|
|
" https://slixmpp.readthedocs.io/\n"
|
|
" feedparser\n"
|
|
" https://pythonhosted.org/feedparser\n"
|
|
"```"
|
|
)
|
|
return msg
|
|
|
|
|
|
def print_help():
|
|
"""
|
|
Print help manual.
|
|
|
|
Returns
|
|
-------
|
|
msg : str
|
|
Message.
|
|
"""
|
|
msg = (
|
|
"```\n"
|
|
"NAME\n"
|
|
"Slixfeed - News syndication bot for Jabber/XMPP\n"
|
|
"\n"
|
|
"DESCRIPTION\n"
|
|
" Slixfeed is a news aggregator bot for online news feeds.\n"
|
|
" This program is primarily designed for XMPP.\n"
|
|
" For more information, visit https://xmpp.org/software/\n"
|
|
"\n"
|
|
"BASIC USAGE\n"
|
|
" start\n"
|
|
" Enable bot and send updates.\n"
|
|
" stop\n"
|
|
" Disable bot and stop updates.\n"
|
|
" URL\n"
|
|
" Add URL to subscription list.\n"
|
|
" add URL TITLE\n"
|
|
" Add URL to subscription list (without validity check).\n"
|
|
" feeds\n"
|
|
" List subscriptions.\n"
|
|
" interval N\n"
|
|
" Set interval update to every N minutes.\n"
|
|
" next N\n"
|
|
" Send N next updates.\n"
|
|
" quantum N\n"
|
|
" Set amount of updates for each interval.\n"
|
|
" read URL\n"
|
|
" Display most recent 20 titles of given URL.\n"
|
|
" read URL NUM\n"
|
|
" Display specified entry from given URL.\n"
|
|
"\n"
|
|
"GROUPCHAT OPTIONS\n"
|
|
" ! (command initiation)\n"
|
|
" Use exclamation mark to initiate an actionable command.\n"
|
|
" demaster NICKNAME\n"
|
|
" Remove master privilege.\n"
|
|
" mastership NICKNAME\n"
|
|
" Add master privilege.\n"
|
|
" ownership NICKNAME\n"
|
|
" Set new owner.\n"
|
|
"\n"
|
|
"FILTER OPTIONS\n"
|
|
" allow\n"
|
|
" Keywords to allow (comma separates).\n"
|
|
" deny\n"
|
|
" Keywords to block (comma separates).\n"
|
|
# " filter clear allow\n"
|
|
# " Reset allow list.\n"
|
|
# " filter clear deny\n"
|
|
# " Reset deny list.\n"
|
|
"\n"
|
|
"EDIT OPTIONS\n"
|
|
" remove ID\n"
|
|
" Remove feed from subscription list.\n"
|
|
" status ID\n"
|
|
" Toggle update status of feed.\n"
|
|
"\n"
|
|
"SEARCH OPTIONS\n"
|
|
" feeds TEXT\n"
|
|
" Search subscriptions by given keywords.\n"
|
|
" search TEXT\n"
|
|
" Search news items by given keywords.\n"
|
|
" recent N\n"
|
|
" List recent N news items (up to 50 items).\n"
|
|
"\n"
|
|
# "STATISTICS OPTIONS\n"
|
|
# " analyses\n"
|
|
# " Show report and statistics of feeds.\n"
|
|
# " obsolete\n"
|
|
# " List feeds that are not available.\n"
|
|
# " unread\n"
|
|
# " Print number of unread news items.\n"
|
|
# "\n"
|
|
# "BACKUP OPTIONS\n"
|
|
# " export opml\n"
|
|
# " Send an OPML file with your feeds.\n"
|
|
# " backup news html\n"
|
|
# " Send an HTML formatted file of your news items.\n"
|
|
# " backup news md\n"
|
|
# " Send a Markdown file of your news items.\n"
|
|
# " backup news text\n"
|
|
# " Send a Plain Text file of your news items.\n"
|
|
# "\n"
|
|
"SUPPORT\n"
|
|
" help\n"
|
|
" Print this help manual.\n"
|
|
" info\n"
|
|
" Print information page.\n"
|
|
" support\n"
|
|
" Join xmpp:slixmpp@muc.poez.io?join\n"
|
|
# "\n"
|
|
# "PROTOCOLS\n"
|
|
# " Supported prootcols are IRC, Matrix and XMPP.\n"
|
|
# " For the best experience, we recommend you to use XMPP.\n"
|
|
# "\n"
|
|
"```"
|
|
)
|
|
return msg
|