async def main():
if "praw_client_id" not in os.environ:
sys.stderr.write("Environment variable ``praw_client_id`` must be defined\n")
return 1
if "praw_client_secret" not in os.environ:
sys.stderr.write(
"Environment variable ``praw_client_secret`` must be defined\n"
)
return 1
await initialize_refresh_token_file()
refresh_token_manager = FileTokenManager(REFRESH_TOKEN_FILENAME)
async with asyncpraw.Reddit(
token_manager=refresh_token_manager,
user_agent="use_file_token_manager/v0 by u/bboe",
) as reddit:
scopes = await reddit.auth.scopes()
if scopes == {"*"}:
print(f"{await reddit.user.me()} is authenticated with all scopes")
elif "identity" in scopes:
print(
f"{await reddit.user.me()} is authenticated with the following scopes: {scopes}"
)
else:
print(f"You are authenticated with the following scopes: {scopes}")
async def thickhentai(self, ctx):
r = asyncpraw.Reddit(client_id="myVr7vToLuADLQLCMBrfpQ",
client_secret=self.bot.get_config(
"config", "config", "reddit_secret"),
user_agent="meifwa")
subreddit = await r.subreddit("thick_hentai")
all_subs = []
top = subreddit.top(limit=50)
async for submission in top:
all_subs.append(submission)
random_sub = random.choice(all_subs)
url = random_sub.url
embed = discord.Embed(
title=f"r/{subreddit}",
description=
f"[{submission.title}](https://reddit.com{submission.permalink})",
color=ctx.message.author.color,
timestamp=ctx.message.created_at)
embed.set_image(url=url)
embed.set_author(name="Requested By: " + str(ctx.message.author),
icon_url=ctx.message.author.avatar.url)
embed.set_footer(
text=
f"{submission.score} points | {submission.num_comments} comments")
await ctx.reply(embed=embed)
def __init__(self, client):
self.client = client
self.reddit = praw.Reddit(client_id=client_id,
client_secret=client_secret,
username=username,
password=password,
user_agent="thejambot")
def _get_praw_instance(self):
r = asyncpraw.Reddit(user_agent=self.user_agent,
client_id=self.config.client_id,
client_secret=self.config.client_secret,
username=self.config.username,
password=self.config.password)
return r
async def init(self):
await self.bot.wait_until_red_ready()
if await self.config.SCHEMA_VERSION() == 1:
data = await self.config.all_channels()
for channel, _ in data.items():
async with self.config.channel_from_id(
channel).reddits() as sub_data:
for feed in sub_data:
try:
sub_data[feed]["subreddit"] = sub_data[feed][
"url"].split("/")[4]
except IndexError:
sub_data[feed]["subreddit"] = None
await self.bot.send_to_owners(
"Hi there.\nRedditPost has now been given an update to accomodate the new reddit ratelimits. This cog now requires authenthication.\nTo setup the cog create an application via https://www.reddit.com/prefs/apps/. Once this is done, copy the client ID found under the name and the secret found inside.\nYou can then setup this cog by using `[p]set api redditpost clientid CLIENT_ID_HERE clientsecret CLIENT_SECRET_HERE`\n"
)
await self.config.SCHEMA_VERSION.set(2)
token = await self.bot.get_shared_api_tokens("redditpost")
try:
self.client = asyncpraw.Reddit(
client_id=token.get("clientid", None),
client_secret=token.get("clientsecret", None),
user_agent=f"{self.bot.user.name} Discord Bot",
)
self.bg_loop_task = self.bot.loop.create_task(self.bg_loop())
except Exception as exc:
log.error("Exception in init: ", exc_info=exc)
await self.bot.send_to_owners(
"An exception occured in the authenthication. Please ensure the client id and secret are set correctly.\nTo setup the cog create an application via https://www.reddit.com/prefs/apps/. Once this is done, copy the client ID found under the name and the secret found inside.\nYou can then setup this cog by using `[p]set api redditpost clientid CLIENT_ID_HERE clientsecret CLIENT_SECRET_HERE`"
)
async def wouldyourather(self, ctx):
reddit = asyncpraw.Reddit(client_id=os.environ['RAI'],
client_secret=os.environ['RAS'],
username=os.environ['user'],
password=os.environ['pass'],
user_agent='SSagunPraw')
subreddit = await reddit.subreddit("wouldyourather")
all_subs = []
top = subreddit.top(limit=100)
async for submission in top:
all_subs.append(submission)
random_sub = random.choice(all_subs)
name = random_sub.title
embed = discord.Embed(title=name, color=0xEEEEEE)
embed.set_author(name='Would you Rather?')
embed.timestamp = datetime.datetime.utcnow()
embed.set_footer(text=f"Would you rather...this.. or... this?")
await ctx.send(embed=embed)
async def get_sub_futures(sub_ids: List[str],
reddit_details: dict) -> tuple:
# make each sub_id request into a future and
# gather all futures together into a tuple
# have to include init of reddit object inside the async loop
# else async loop raise an error. Should improve this fix :/
# Something has to be done with Timeouts due to large
# number of concurrent requests. Adding try/excepts on each
# request in get_submission function seems lame. Maybe solve
# this with custom client with limited concurrent connections:
# aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=10))
reddit = asyncpraw.Reddit(**reddit_details,
requestor_class=Requestor,
requestor_kwargs={
'session':
ClientSession(connector=TCPConnector(
limit=5000))
})
# use context or else the session above will not be closed
# and warning/errors will pop for each request or session
async with reddit:
tasks = set()
for id in sub_ids:
tasks.add(
asyncio.create_task(
self._parse_single_submission(
reddit.submission(id))))
return await asyncio.gather(*tasks)
def __init__(self, bot):
self.bot = bot
self.base_url = "https://www.reddit.com"
reddit_login = IO.read_settings_as_json()
reddit_data = reddit_login['reddit']
username = reddit_data['username']
password = reddit_data['password']
client_id = reddit_data['client_id']
client_secret = reddit_data['client_secret']
user_agent = reddit_data['user_agent']
self.post_title = reddit_data['post_title']
self.post_url = reddit_data['post_url']
if username is None or password is None or client_id is None or client_secret is None or user_agent is None or \
self.post_title is None or self.post_url is None:
cmds = Reddit.get_commands(self)
for cmd in cmds:
cmd.update(enabled=False)
else:
self.reddit = asyncpraw.Reddit(
username=username,
password=password,
client_id=client_id,
client_secret=client_secret,
user_agent=user_agent
)
def __init__(self, command_prefix, **options):
super().__init__(command_prefix, **options)
pgloop = asyncio.get_event_loop()
f = pickle.load(open('credentials.pkl', 'rb'))
self.pool = pgloop.run_until_complete(
asyncpg.create_pool(dsn=f["postgres_uri"],
host=f["postgres_host"],
user=f["postgres_user"],
port=f["postgres_port"],
password=f["postgres_password"],
database=f["postgres_database"]))
self.reddit = apraw.Reddit(client_id=f['reddit_id'],
client_secret=f['reddit_secret'],
user_agent="Eclipse")
self.memes = []
self.brain_id = f['brain_id']
self.brain_api = f['brain_api']
self.token = f["discord"]
self.sra_api = f['some_random_api']
self.launch_time = datetime.datetime.utcnow()
self.gameboy = False
self.color = discord.Color.from_rgb(156, 7, 241)
with open("config/config.json", "r") as read_file:
data = json.load(read_file)
self.config = data
self.flask_instance: Flask = None
self.flask_thread: multiprocessing.Process = None
async def meme_quote(self, ctx):
reddit = asyncpraw.Reddit(
client_id="cv4eeeqKG-IseA",
client_secret="t3O9tFzRXpYybwLAn4cquJ2QKgLh2Q",
username="******",
password="******",
user_agent="eleop")
subreddit = reddit.subreddit("memes")
all_subs = []
top = subreddit.top(limit=50)
for submission in top:
all_subs.append(submission)
random_sub = choice(all_subs)
name = random_sub.title
url = random_sub.url
embed = Embed(title=name)
embed.set_image(url=url)
embed.set_footer(text=f"Requested by {ctx.author}",
icon_url=ctx.author.avatar_url)
await ctx.send(embed=embed)
async def get_hot_subreddit_images(self, sub_reddit: str, posts_limit: int,
num: int) -> list:
"""Gets a list of subreddit pics
Args:
sub_reddit (str): subreddit to get pics from
pics_limit (int): num of pics to charge
num (int): num of pics to return
Returns:
list: containing reddit posts
"""
reddit = asyncpraw.Reddit(
client_id=self.client_id,
client_secret=self.client_secret,
user_agent=self.user_agent,
check_for_async=False,
)
subreddit = await reddit.subreddit(sub_reddit)
hot_posts = subreddit.hot(limit=posts_limit)
posts = []
async for post in hot_posts:
if "jpg" in post.url or "png" in post.url and not post.over_18:
posts.append(post.url)
await reddit.close()
return posts
async def get_cogcision() -> str:
reddit = asyncpraw.Reddit(
client_id=REDDIT_ID,
client_secret=REDDIT_SECRET,
user_agent="prawddit",
)
subreddit = await reddit.subreddit("wallstreetbets")
symbol_list = []
async for comment in subreddit.comments(limit=10000000):
words = comment.body.split()
for word in words:
if len(word) in range(1, 5) or (word[0] == "$"):
symbol = True
for c in word:
if c.islower() or not c.isalpha():
symbol = False
if symbol:
symbol_list.append(word)
async for comment in subreddit.new(limit=10000000):
words = comment.title.split()
for word in words:
if len(word) in range(1, 5) or (word[0] == "$"):
symbol = True
for c in word:
if c.islower() or not c.isalpha():
symbol = False
if symbol:
symbol_list.append(word)
counter = 0
while True:
# randomly pick a stock
symbol = random.choice(symbol_list)
try:
print(f"trying {symbol}")
stock = api.get_last_trade(symbol)
break
except:
counter += 1
if counter == 100:
return "SORRY IM TOO WEAK. THESE FOOLS ARE SPEWING BULLSHIT."
break
pass
# # randomly pick buy/sell
action = random.choice(["BUY", "SELL"])
# # randomly pick amount
amount = random.randint(1, 100)
# # return sentence
return (
f"I WILL {action} {amount} SHARE{'S' if amount >= 1 else ''} OF {symbol}. THIS LITTLE MANEUVER IS GONNA COST US $"
+ str(stock.price * amount))
def cog_load(self):
self.reddit = asyncpraw.Reddit(client_id=self.tokens['reddit'][0],
client_secret=self.tokens['reddit'][1],
user_agent=self.options['useragent'])
self.subreddit = None
self.auto_refresh.change_interval(
minutes=self.options['refresh_interval'])
self.auto_refresh.start()
def __init__(self, bot):
self.bot = bot
self.reddit = asyncpraw.Reddit(
client_id = os.environ['REDDIT_APP_ID'],
client_secret = os.environ['REDDIT_APP_SECRET'],
user_agent = f"speedwagon-discord-bot:{os.environ['REDDIT_APP_ID']}:1.0",
check_for_async = False
)
def __init__(self, bot):
"""set it up"""
super().__init__()
self.bot = bot
self.reddit = praw.Reddit(
"Hoobot", user_agent="discord:hoobot:1.0 (by u/owldyn)")
self.conf = Config.get_conf(self, identifier=26400735)
self.conf.register_global(**self.default_global_settings)
def __init__(
self,
bot): # This allows the cog to access the bot, and its functions
self.bot = bot
self.reddit = asyncpraw.Reddit(
client_id=os.environ["REDDIT_CLIENT_ID"],
client_secret=os.environ["REDDIT_CLIENT_SECRET"],
user_agent=os.environ["REDDIT_USER_AGENT"])
def __init__(self, config):
self.reddit = asyncpraw.Reddit(
client_id=config["Reddit"]["ClientID"],
client_secret=config["Reddit"]["ClientSecret"],
password=config["Reddit"]["Password"],
user_agent="KoKoBot/0.1 by Kilenaitor",
username=config["Reddit"]["Username"],
)
def __init__(self, bot):
self.bot = bot
self.reddit = asyncpraw.Reddit(
client_id=os.getenv("PRAW_CLIENT_ID"),
client_secret=os.getenv("PRAW_CLIENT_SECRET"),
user_agent="Tortoise Discord Bot",
)
self._cache = RedditPostsCache()
def setup(client):
client.add_cog(
games(client,
reddit=asyncpraw.Reddit(client_id=reddit_client_id,
client_secret=reddit_client_secret,
username=reddit_username,
password=reddit_password,
user_agent=reddit_user_agent)))
async def main():
"""Provide the program's entry point when directly executed."""
print(
"Go here while logged into the account you want to create a token for: "
"https://www.reddit.com/prefs/apps/")
print(
"Click the create an app button. Put something in the name field and select the"
" script radio button.")
print(
"Put http://localhost:8080 in the redirect uri field and click create app"
)
client_id = input(
"Enter the client ID, it's the line just under Personal use script at the top: "
)
client_secret = input(
"Enter the client secret, it's the line next to secret: ")
commaScopes = input(
"Now enter a comma separated list of scopes, or all for all tokens: ")
if commaScopes.lower() == "all":
scopes = ["*"]
else:
scopes = commaScopes.strip().split(",")
reddit = asyncpraw.Reddit(
client_id=client_id.strip(),
client_secret=client_secret.strip(),
redirect_uri="http://localhost:8080",
user_agent="praw_refresh_token_example",
)
state = str(random.randint(0, 65000))
url = reddit.auth.url(scopes, state, "permanent")
print("Now open this url in your browser: " + url)
sys.stdout.flush()
client = receive_connection()
data = client.recv(1024).decode("utf-8")
param_tokens = data.split(" ", 2)[1].split("?", 1)[1].split("&")
params = {
key: value
for (key, value) in [token.split("=") for token in param_tokens]
}
if state != params["state"]:
send_message(
client,
f"State mismatch. Expected: {state} Received: {params['state']}",
)
return 1
elif "error" in params:
send_message(client, params["error"])
return 1
refresh_token = await reddit.auth.authorize(params["code"])
send_message(client, f"Refresh token: {refresh_token}")
await reddit._http.close()
return 0
async def _reddit(self, ctx, subred="meme"): # default subreddit is meme
reddit = asyncpraw.Reddit(client_id=os.environ['RAI'],
client_secret=os.environ['RAS'],
username=os.environ['user'],
password=os.environ['pass'],
user_agent='SSagunPraw')
subreddit = await reddit.subreddit(subred)
all_subs = []
top = subreddit.top(limit=75)
async for submission in top:
all_subs.append(submission)
random_sub = random.choice(all_subs)
if submission.over_18 == True:
if ctx.channel.is_nsfw:
sr_name = random_sub.subreddit
author = random_sub.author
name = random_sub.title
url = random_sub.url
embed = discord.Embed(title=author,
description=name,
color=0xFF4500)
embed.set_author(
name=f'r/{sr_name}',
url=url,
icon_url='https://i.postimg.cc/pTzSdRqC/reddit-logo.png')
embed.set_image(url=url)
embed.timestamp = datetime.datetime.utcnow()
embed.set_footer(
text=
f"If the Image is not loading just click on r/{sr_name}!")
await ctx.send(embed=embed)
else:
await ctx.send("Sorry but this subreddit is marked as NSFW!")
else:
sr_name = random_sub.subreddit
author = random_sub.author
name = random_sub.title
url = random_sub.url
embed = discord.Embed(title=author,
description=name,
color=0xFF4500)
embed.set_author(
name=f'r/{sr_name}',
url=url,
icon_url='https://i.postimg.cc/pTzSdRqC/reddit-logo.png')
embed.set_image(url=url)
embed.timestamp = datetime.datetime.utcnow()
embed.set_footer(
text=f"If the Image is not loading just click on r/{sr_name}!")
await ctx.send(embed=embed)
async def memes(self, ctx):
reddit = asyncpraw.Reddit(client_id=f'{meme()[0]}',
client_secret=f'{meme()[1]}',
user_agent=f'{meme()[2]}')
memes_submissions = await reddit.subreddit('memes').hot()
post_to_pick = random.randint(1, 20)
for i in range(0, post_to_pick):
submission = next(x for x in memes_submissions if not x.stickied)
await ctx.send(submission.url)
def __init__(self, bot):
self.bot = bot
self.bot.logger.debug("Starting reddit client.")
conf = bot.get_config_value('reddit')
self.reddit_client = asyncpraw.Reddit(**conf._asdict())
self.scanners = (RedditScanner(self), )
self.scan_all_feeds.start()
def setup(bot: ButtercupBot) -> None:
"""Set up the Rules cog."""
reddit_config = bot.config["Reddit"]
reddit_api = asyncpraw.Reddit(
client_id=reddit_config["client_id"],
client_secret=reddit_config["client_secret"],
user_agent=reddit_config["user_agent"],
)
bot.add_cog(Rules(bot=bot, reddit_api=reddit_api))
async def reddit_instance():
"""
Return instance of Reddit
"""
reddit = asyncpraw.Reddit(
client_id=os.getenv('REDDIT_CLIENT_ID'),
client_secret=os.getenv('REDDIT_CLIENT_SECRET'),
user_agent=os.getenv('REDDIT_USER_AGENT'),
)
return reddit
def __init__(self, bot):
logger.info(Constants.COG_STARTUP, Constants.FUN)
self.bot = bot
# Reddit API id and secret is stored within my PRAW's praw.ini as [nezuko] entry.
praw_secrets = get_praw_secrets()
self.reddit = asyncpraw.Reddit(user_agent=Constants.NEZUKO_BOT,
client_id=praw_secrets[0],
client_secret=praw_secrets[1])
self.subreddits = Constants.MEME_SUBREDDITS
self.uwu_subreddits = Constants.UWU_SUBREDDITS
def __init__(self) -> None:
self.colour = Colour.purple()
self.historyEventsTable = json.loads(
open(historyEventsPath, "r").read())
self.redditClient = asyncpraw.Reddit(
client_id=Config.redditID,
client_secret=Config.redditSecret,
user_agent="linux:LiSBot:1.0 (by u/JackAshwell1)")
self.bot = None
self.posts = None
def __init__(self, bot):
self.bot = bot
self.engine = cse.Search(self.bot.config['googleapikey'])
self.client = sr_api.Client()
self.reddit = asyncpraw.Reddit(
client_id=self.bot.config['redditauth'][1],
client_secret=self.bot.config['redditauth'][0],
password=self.bot.config['password'],
user_agent=self.bot.config['redditauth'][2],
username="******")
async def get_sub_images(self, subreddit, num=50, invalid_ids=None):
self.reddit = asyncpraw.Reddit(site_name="WardenBotScraper",
user_agent="Warden User Agent")
print(f"get_sub_images was called! Subreddit: {subreddit}! Num: {num}")
if await self.sub_available(subreddit):
print("Valid Sub!")
self.subreddit = await self.reddit.subreddit(subreddit)
else:
self.subreddit = await self.reddit.random_subreddit(nsfw=False)
self.error_flag = True
print(
f"Invalid Subreddit, Random One Assigned: {self.subreddit.display_name}!"
)
self.sub_name = self.subreddit.display_name
post = None
if await self.subreddit.random() is not None:
print("Getting random post!")
for i in range(num):
submission = await self.subreddit.random()
if not test_post(submission):
pass
else:
if invalid_ids:
if submission.id in invalid_ids:
pass
else:
print("Post appended!")
post = submission.url
break
else:
print("Post appended!")
post = submission.url
break
else:
async for submission in self.subreddit.hot(limit=num):
if not test_post(submission):
pass
else:
if invalid_ids:
if submission.id in invalid_ids:
print("Invalid id!")
else:
print("Post appended!")
post = submission.url
break
else:
print("Post appended!")
post = submission.url
break
await self.reddit.close()
if not post:
self.no_img_flag = True
return await self.get_sub_images(None)
else:
return post
def __init__(self, bot: "Bot"):
self.bot = bot
self.subs = ("dankmemes", "memes", "wholesomememes")
self.posted = {}
self.reddit = asyncpraw.Reddit(
client_id=os.environ.get('REDDITCLIENTID'),
client_secret=os.environ.get('REDDITCLIENTSECRET'),
password=os.environ.get('REDDITPASSWORD'),
user_agent="Friday Discord bot v1.0.0 (by /u/Motostar19)",
username="******")
self.reddit.read_only = True
