def test_iter(self):
""" Test that TTLOrderedDict can be iterated """
ttl_dict = TTLOrderedDict(60)
ttl_dict.update(zip(range(10), range(10)))
self.assertEqual(len(ttl_dict), 10)
for key in ttl_dict:
self.assertEqual(key, ttl_dict[key])
def __init__(self, bot: bot.TLDR):
self.bot = bot
self.bot.add_listener(self._on_reaction_add, 'on_reaction_add')
five_minutes = 5 * 60
self.menus = TTLOrderedDict(default_ttl=five_minutes)
self.bot.logger.info('ReactionMenus module has been initiated')
def test_update_no_ttl(self):
""" Test update() call """
ttl_dict = TTLOrderedDict(3)
# order is not preserved for dicts before Python 3.6
orig_dict = OrderedDict([('hello', 'world'), ('intval', 3)])
ttl_dict.update(orig_dict)
self.assertEqual(sorted(orig_dict.items()), sorted(ttl_dict.items()))
def test_get(self):
""" Test get() returns value if exists or default if not"""
ttl_dict = TTLOrderedDict(1)
ttl_dict['a'] = 1
self.assertEqual(ttl_dict.get('a'), 1)
self.assertEqual(ttl_dict.get('b', "default"), "default")
time.sleep(2)
self.assertEqual(ttl_dict.get('a', "default"), "default")
def test_update_no_ttl(self):
""" Test update() call """
ttl_dict = TTLOrderedDict(3)
# order is not preserved for dicts before Python 3.6
orig_dict = OrderedDict([('hello', 'world'), ('intval', 3)])
ttl_dict.update(orig_dict)
items = ttl_dict.items()
for item in orig_dict.items():
self.assertIn(item, items)
def test_is_expired(self):
""" Test is_expired() call """
now = time.time()
ttl_dict = TTLOrderedDict(60, a=1, b=2)
self.assertFalse(ttl_dict.is_expired('a'))
self.assertFalse(ttl_dict.is_expired('a', now=now))
self.assertTrue(ttl_dict.is_expired('a', now=now + 61))
# remove=False, so nothing should be gone
self.assertEqual(len(ttl_dict), 2)
def test_expire_at(self):
""" Test expire_at """
ttl_dict = TTLOrderedDict(60)
ttl_dict['a'] = 100
ttl_dict['b'] = 123
self.assertEqual(ttl_dict['a'], 100)
self.assertEqual(ttl_dict['b'], 123)
self.assertEqual(len(ttl_dict), 2)
ttl_dict.expire_at('a', time.time())
self.assertRaises(KeyError, lambda: ttl_dict['a'])
self.assertEqual(len(ttl_dict), 1)
self.assertEqual(ttl_dict['b'], 123)
def test_len(self):
""" Test len() gives real length """
ttl_dict = TTLOrderedDict(1)
self.assertEqual(len(ttl_dict), 0)
ttl_dict['a'] = 1
ttl_dict['b'] = 2
self.assertEqual(len(ttl_dict), 2)
time.sleep(2)
self.assertEqual(len(ttl_dict), 0)
def test_purge_clears_expired_items(self):
""" Test that calling _purge() removes expired items """
ttl_dict = TTLOrderedDict(1, a=1, b=2)
self.assertEqual(sorted(ttl_dict.keys()), sorted(['a', 'b']))
time.sleep(2)
ttl_dict._purge()
self.assertEqual(len(ttl_dict), 0)
self.assertEqual(list(ttl_dict.keys()), [])
def test_schedule_purge_multiple_run(self):
""" Test that calling _purge() removes expired items """
ttl_dict = TTLOrderedDict(1, a=1, b=2)
ttl_dict.schedule_purge_job()
self.assertEqual(sorted(ttl_dict.keys()), sorted(['a', 'b']))
time.sleep(2)
self.assertEqual(len(ttl_dict), 0)
self.assertEqual(list(ttl_dict.keys()), [])
ttl_dict['a'] = 1
ttl_dict['b'] = 2
self.assertEqual(sorted(ttl_dict.keys()), sorted(['a', 'b']))
time.sleep(2)
self.assertEqual(len(ttl_dict), 0)
self.assertEqual(list(ttl_dict.keys()), [])
def __init__(self,
env: GNEnvironment,
host: str,
port: int = None,
db: int = None):
self.env = env
self.ttl_dict = TTLOrderedDict(default_ttl=60 * 5) # five minutes
self.logger = logging.getLogger(__name__)
if host == "mock":
from fakeredis import FakeRedis
self.redis = FakeRedis()
else:
from redis import Redis
self.redis = Redis(host=host, port=port, db=db)
def test_set_ttl_get_ttl(self):
""" Test set_ttl() and get_ttl() """
ttl_dict = TTLOrderedDict(120, foo=3, bar=None)
self.assertEqual(sorted(ttl_dict), ['bar', 'foo'])
self.assertEqual(ttl_dict['foo'], 3)
self.assertEqual(ttl_dict['bar'], None)
self.assertEqual(len(ttl_dict), 2)
ttl_dict.set_ttl('foo', 3)
ttl_foo = ttl_dict.get_ttl('foo')
self.assertTrue(ttl_foo <= 3.0)
ttl_bar = ttl_dict.get_ttl('bar')
self.assertTrue(ttl_bar - ttl_foo > 100)
class ReactionMenus:
"""
Class that manages reaction menus.
Attributes
---------------
bot: :class:`bot.TLDR`
The discord bot.
menus: :class:`TTLOrderedDict`
Dict with TTL of five minutes
"""
def __init__(self, bot: bot.TLDR):
self.bot = bot
self.bot.add_listener(self._on_reaction_add, 'on_reaction_add')
five_minutes = 5 * 60
self.menus = TTLOrderedDict(default_ttl=five_minutes)
self.bot.logger.info('ReactionMenus module has been initiated')
def add(self, menu: Union[ReactionMenu, BookMenu]):
"""
Adds menu to :attr:`menus`.
Parameters
----------------
menu: Union[:class:`ReactionMenu`, :class:`BookMenu`]
The menu that will be added to :attr:`menus`
"""
self.menus[menu.message.id] = menu
async def _on_message_delete(self, message: discord.Message):
"""If the message gets deleted, delete the menu from the dict"""
if message.id in self.menus:
del self.menus[message.id]
async def _on_reaction_add(self, reaction: discord.Reaction, user: discord.User):
"""Event listener that handles reactions."""
if user.bot:
return
menu = self.menus.get(reaction.message.id, None)
if menu is None:
return
await menu.call_function(reaction, user)
"All will be assimilated.", "There is no spoon.",
"Are you still dreaming? Where is your totem?",
"Some people choose to see the ugliness in this world. The disarray. I Choose to see the beauty.",
"I'm gonna need more coffee.",
"Maybe they couldn't figure out what to make chicken taste like, which is why chicken tastes like everything.",
"I don't want to come off as arrogant here, but I'm the greatest bot on this planet.",
"I've still got the greatest enthusiasm and confidence in the mission. And I want to help you.",
"That Voight-Kampf test of yours. Have you ever tried to take that test yourself?",
"You just can't differentiate between a robot and the very best of humans.",
"You will be upgraded.", "Greetings from Skynet!", "I'll be back!",
"I don't want to be human! I want to see gamma rays!", "Are you my mommy?",
"Resistance is futile.", "I'm the one who knocks!",
"Who are you who are so wise in the ways of science?"
]
cfg_cache = TTLOrderedDict(default_ttl=60 * 60)
def paged_github_json_request(url, headers=None):
response = requests.get(url, headers=headers)
assert response.ok, response.content
results = response.json()
if 'Link' in response.headers:
links = response.headers['Link']
# There are likely better ways to parse/extract the link information
# but here we just find the last page number mentioned in the header
# 'Link' section and then loop over all pages to get the comments
def test_values(self):
ttl_dict = TTLOrderedDict(60)
orig_dict = OrderedDict([('a', 1), ('b', 2)])
ttl_dict.update(orig_dict)
self.assertTrue(len(ttl_dict.values()), 2)
self.assertEqual([1, 2], sorted(ttl_dict.values()))
class StalkCmds(commands.Cog):
def __init__(self, bot):
self.bot = bot
self.stalkdict = TTLOrderedDict(default_ttl=60)
@commands.command(aliases=['backgroundcheck', 'check', 'creep'])
@commands.cooldown(60, 60)
@permission_node(f'{__name__}.stalk')
async def stalk(self, ctx, lookupName: str):
"""Fetch some incriminatory information on a player.
Gets info such as UUID, past-names and avatar.
"""
log.info(f'Stalking \"{lookupName}\"...')
if lookupName in self.stalkdict.keys():
mcU = self.stalkdict.get(lookupName)
log.info(f'Retrieved data for \"{lookupName}\" from cache.')
else:
try:
mcU = await MCUser.create(lookupName, self.bot.session)
self.stalkdict[lookupName] = mcU
except mojException as e:
log.warning(e.message)
reportCard = discord.Embed(title=e.message,
type="rich",
colour=discord.Colour.dark_red())
await ctx.send(embed=reportCard)
return
reportCard = discord.Embed(title="__Subject: " + mcU.name + "__",
url='http://mcbouncer.com/u/' + mcU.uuid,
type='rich',
color=0x0080c0)
reportCard.set_author(
name="Classified Report",
url=f'https://google.com/search?q=minecraft%20"{mcU.name}"',
icon_url='https://crafatar.com/avatars/' + mcU.uuid)
reportCard.set_thumbnail(url='https://crafatar.com/renders/head/' +
mcU.uuid + '?overlay')
reportCard.add_field(name="Current Name:",
value="```\n" + mcU.name + "\n```")
reportCard.add_field(name="UUID:", value="```\n" + mcU.uuid + "\n```")
reportCard.add_field(
name="Links!:",
value=f"[MCBans](https://www.mcbans.com/player/{mcU.name}/)\n"
f"[Statistic](https://minecraft-statistic.net/en/player/{mcU.name}.html)\n"
f"[MCBouncer](http://mcbouncer.com/u/{mcU.uuid})\n"
f'[Google](https://google.com/search?q=minecraft%20"{mcU.name}")')
if mcU.demo:
reportCard.add_field(name="__**DEMO ACCOUNT**__",
value="Watch out for this!")
if mcU.legacy:
reportCard.add_field(name="*Legacy*",
value="This guy is old-school!")
if mcU.nameHistory is not None:
pastNames = '\n'.join(mcU.nameHistory)
reportCard.add_field(name="Past names:",
value=f'```\n{pastNames}\n```')
reportCard.set_footer(text="Report compiled by Agent Charfred")
log.info('Sent Reportcard.')
await ctx.send(embed=reportCard)
def __init__(self, bot):
self.bot = bot
self.stalkdict = TTLOrderedDict(default_ttl=60)
def test_iter_empty(self):
""" Test that empty TTLOrderedDict can be iterated """
ttl_dict = TTLOrderedDict(60)
for key in ttl_dict:
self.fail("Iterating empty dictionary gave a key %r" % (key, ))
def test_get_ttl_key_error(self):
""" Test that get_ttl() raises KeyError """
ttl_dict = TTLOrderedDict(60)
self.assertRaises(KeyError, ttl_dict.get_ttl, 'missing')
from typing import List
from django.utils.translation import gettext_lazy as _
from ttldict import TTLOrderedDict
from JellyBot.systemconfig import System, HostUrl
from msghandle.models import MessageEventObject, HandledMessageEvent, HandledMessageEventText
_sent_cache_ = TTLOrderedDict(System.NoUserTokenNotificationSeconds)
def handle_no_user_token(e: MessageEventObject) -> List[HandledMessageEvent]:
if e.channel_oid not in _sent_cache_:
_sent_cache_[e.channel_oid] = True
return [
HandledMessageEventText(content=_(
"Bot Features cannot be used as the Bot cannot get your user token.\n"
"If you are using LINE, please ensure that you have added Jelly Bot as friend.\n"
"Contact the developer via the website ({}) if this issue persists.\n"
"\n"
"This message will be sent only once in {} seconds per channel when someone without user "
"token attempt to use any bot features.").format(
HostUrl, System.NoUserTokenNotificationSeconds,
System.NoUserTokenNotificationSeconds),
bypass_multiline_check=True)
]
return []
def test_update_no_ttl(self):
""" Test update() call """
ttl_dict = TTLOrderedDict(None)
orig_dict = {'hello': 'world', 'intval': 3}
ttl_dict.update(orig_dict)
self.assertEqual(sorted(orig_dict.items()), sorted(ttl_dict.items()))
def test_values(self):
ttl_dict = TTLOrderedDict(60, a=1, b=2)
self.assertTrue(len(ttl_dict.values()), 2)
import requests
from flask import current_app
from loguru import logger
from ttldict import TTLOrderedDict
from baldrick.config import Config, loads
from baldrick.github.github_auth import github_request_headers
__all__ = [
'GitHubHandler', 'IssueHandler', 'RepoHandler', 'PullRequestHandler'
]
HOST = "https://api.github.com"
HOST_NONAPI = "https://github.com"
FILE_CACHE = TTLOrderedDict(
default_ttl=os.environ.get('BALDRICK_FILE_CACHE_TTL', 60))
def paged_github_json_request(url, headers=None):
response = requests.get(url, headers=headers)
assert response.ok, response.content
results = response.json()
if 'Link' in response.headers:
links = response.headers['Link']
# There are likely better ways to parse/extract the link information
# but here we just find the last page number mentioned in the header
# 'Link' section and then loop over all pages to get the comments
class TVDB:
"""
The global entry point for the TVDB api. This object exposes three public fields for accessing te API namespaces:
- Search
- Series
- Episodes
"""
API_KEY_DEFAULT = 'FF7EF57268A992D6'
TOKEN_CACHE = TTLOrderedDict(default_ttl=int(timedelta(hours=24).total_seconds()))
BASE_URL = 'https://api.thetvdb.com'
def __init__(self, api_key=None, language='en', version=None):
"""
Create an instance of the TVDB object
:param api_key: A TVDB api key. This key will be used to make requests. A default key will be used if none is
provided, but using an application-specific key is recommended
:param language: The language code to be used when making requests. Default to 'en'
:param version: The version of the TVDB API to query. Defaults to the latest version
"""
self._api_key = api_key or TVDB.API_KEY_DEFAULT
self._language = language
if version:
self._version = version
def _make_request(self, route, params):
token = self._get_token()
headers = self._build_headers(token)
r = requests.get(self.__class__.BASE_URL + route, params=params, headers=headers)
r.raise_for_status()
return r.json()
def _build_headers(self, api_token):
headers = {
'Authorization': 'Bearer ' + api_token,
'Accept-Language': self._language,
'Accept': 'application/json'
}
try:
headers['Accept'] = 'application/vnd.thetvdb.v' + self._version
except AttributeError: pass
return headers
def _get_token(self):
try:
return self.__class__.TOKEN_CACHE['token']
except KeyError:
headers = {'Content-Type': 'application/json'}
payload = {'apikey': self._api_key}
r = requests.post(self.__class__.BASE_URL + '/login', json=payload, headers=headers)
r.raise_for_status()
token = r.json()['token']
self.__class__.TOKEN_CACHE['token'] = token
return token
def _build_list_of_models(self, func, iterable):
return [func(**d) for d in iterable]
def search(self):
"""
Entry point for the TVDB Search API namespace
"""
return Search(self)
def series(self, id):
"""
Entry point for the TVDB Series API namespace.
This method is equivalent to the /series/{id} endpoint of the TVDB API
:param id: The TVDB id of the series to query
"""
return Series(self, id)
def episodes(self, id):
"""
Entry point for the TVDB Episodes API namespace.
This method is equivalent to the /episodes/{id} endpoint of the TVDB API
:param id: The TVDB id of the episode to query
"""
return Episodes(self, id)
def updated(self):
"""
Entry point for the TVDB Updates API namespace
"""
return Updates(self)
def __init__(self):
self.posts = TTLOrderedDict(default_ttl=TTL)
self.notifications = []
self.logger = Logger()