async def __call__(self):
try:
number = float(self.args.pop("<value>").rstrip("%"))
number = max(min(number, 100.0), 0.0)
self.markov_room.freq = number / 100
await self.markov_room.save()
await self.room.timeline.send(
Notice("Frequency is now %.0f%%" % number))
except (ValueError, KeyError):
await self.room.timeline.send(
Notice("Frequency is %.0f%%" %
(self.markov_room.freq * 100)), )
async def __call__(self):
count = int(self.args.pop("--count"))
count = max(min(count, 100), 2)
starting_word = self.args.pop("<starting_word>") or None
text = await self.markov_room.generate(count, starting_word)
await self.room.timeline.send(Notice(text))
async def __call__(self):
count = int(self.args.pop("<count>") or 10)
count = max(min(count, 30), 1)
reply = f"Total learned pairs: **{len(self.markov_room.pairs)}**\n\n"
reply += f"Top **{count}** pairs:\n\n"
reply += "Word 1 | Word 2 | Count\n"
reply += "--- | --- | ---\n"
reply += "\n".join("%-20s | %-20s | %-5s" % (i[0][0], i[0][1], i[1])
for i in self.markov_room.pairs.most_common(count))
message = Notice(reply)
message.format = "org.matrix.custom.html"
message.formatted_body = markdown(reply)
return await self.room.timeline.send(message)
async def on_timeline_text(
self,
room: Room,
event: TimelineEvent[Textual],
):
body = event.content.stripped_body
markov_room = self.rooms[room.id]
print(f"message: {event.sender}: {body}")
if self.client.user_id == event.sender:
return
for mention in self.mentions:
regex = rf"^\s*(?i){re.escape(mention)}\W"
if re.match(regex, body):
body = "".join(re.split(regex, body)[1:])
return await RootCommand(body, room, event, markov_room)()
await markov_room.register_sentence(body)
if random.random() < markov_room.freq:
# TODO: average word count
text = await markov_room.generate(word_count=20)
await room.timeline.send(Notice(text))
async def remove_pairs(self, pairs) -> None:
deleted = 0
to_remove = zip(pairs[::1], pairs[1::2])
for pair in to_remove:
with suppress(KeyError):
del self.markov_room.pairs[pair]
deleted += 1
return await self.room.timeline.send(
Notice(f"Removed {deleted} pairs"), )
async def help(self, extra_msg: str = "", usage_only: bool = True) -> None:
body = ""
if extra_msg:
body += f"{extra_msg}\n\n"
# Get rid of extra indentation
doc = getattr(self, "__doc__", "").replace("\n ", "\n").strip()
body += "```\n"
if usage_only:
body += docopt.printable_usage(doc)
else:
body += doc
body += "\n```"
message = Notice(body)
message.formatted_body = markdown(body)
message.format = "org.matrix.custom.html"
await self.room.timeline.send(message)
async def __call__(self):
image_id = self.event.content.in_reply_to
if not image_id:
return await self.room.timeline.send(
Notice("Please reply to an image"),
)
if image_id not in self.room.timeline:
return await self.room.timeline.send(
Notice("I cannot see this event"),
)
image: Image = self.room.timeline[image_id].content
if not issubclass(image.__class__, Image):
return await self.room.timeline.send(
Notice("Please reply to an image"),
)
ensure_future(self.download_and_send(image))
async def __call__(self):
add, dele = self.args.pop("add"), self.args.pop("del")
user_str = self.args.pop("<user>") or ""
user = self.room.state.members.get(user_str.lower(), None)
if (add or dele) and not user:
return await self.room.timeline.send(
Notice("Specified user is not a member of this room"), )
if add:
self.markov_room.whitelist.add(user.user_id)
await self.markov_room.save()
return await self.room.timeline.send(
Notice(f"Added {user.user_id} to whitelist"), )
elif dele:
self.markov_room.whitelist.discard(user.user_id)
await self.markov_room.save()
return await self.room.timeline.send(
Notice(f"Removed {user.user_id} from whitelist"), )
await self.room.timeline.send(
Notice(
"Current users in the whitelist:\n\n" +
("\n".join(self.markov_room.whitelist) or "None"), ), )
async def remove_words(self, words) -> None:
to_remove = []
for pair in self.markov_room.pairs.keys():
if (pair[0] in words or pair[1] in words):
to_remove.append(pair)
for pair in to_remove:
del self.markov_room.pairs[pair]
await self.markov_room.save()
body = f"Removed {len(to_remove)} pairs containing "
body += "'"
body += "', '".join(words)
body += "'"
return await self.room.timeline.send(Notice(body))
async def __call__(self):
if (
type(self).admin and not (
self.sender.user_id in self.markov_room.whitelist or
self.sender.power_level == 100
)
):
return await self.room.timeline.send(
Notice("You do not have permission to run this "
"command."))
if not self.args:
return await super().help("Invalid usage")
command = self.args.get("<command>", "")
command = (command or "").lower()
if self.args["--help"] or command == "help" or command == "h":
return await super().help(usage_only=False)
return await super().__call__()
async def download_and_send(self, image: Image) -> None:
angle = int(self.args.pop("<angle>") or 120)
try:
await self.client.media.download(image.mxc)
except Exception as e:
print(e)
return await self.room.timeline.send(
Notice("Error while downloading media"),
)
store: MediaStore = self.client.media
image_path = await store._mxc_path(image.mxc).resolve()
with WImage() as img:
with WImage(filename=image_path) as src_img:
for frame in src_img.sequence:
frame.swirl(degree=angle)
img.sequence.append(frame)
blob = BytesIO(img.make_blob())
media = await Image.from_data(self.client, blob)
await self.room.timeline.send(media)