def test_peony_client_init_tasks_oauth2(event_loop):
client = PeonyClient("", "", loop=event_loop, auth=oauth.OAuth2Headers)
conf_n = random.randrange(1 << 16)
with patch.object(peony.BasePeonyClient, 'init_tasks',
return_value=[conf_n]):
tasks = client.init_tasks()
assert conf_n in tasks
assert len(tasks) == 1
def client_oauth(key, event_loop):
global clients
if clients[key] is None:
creds = {
k: os.environ[envk]
for k, envk in zip(creds_oauth[key], keys_oauth[key])
}
clients[key] = PeonyClient(auth=headers[key], **creds)
clients[key].loop = event_loop
clients[key]._session = aiohttp.ClientSession(loop=event_loop)
return clients[key]
def __init__(self, bot):
self.bot = bot
self.tweetson = True
with open("twitter.json") as f:
self.track = json.load(f)
self.pclient = PeonyClient(**self.bot.credentials['Twitter'])
self.bot.twitask = self.bot.loop.create_task(self.twat())
class Cron(commands.Cog):
_fider_colour = 0x8B572A
def __init__(self, bot, config):
self.bot = bot
self.config = config
# this will be the channels the cron updates are sent to
self.fider_channel = None
self.twitter_channel = None
if intv := self.config.get('interval'):
logger.info(f'Changing task interval to {intv} seconds')
self.fider.change_interval(seconds=intv)
self.twitter.change_interval(seconds=intv)
if 'twitter' in self.config and (
creds := self.config['twitter'].get('credentials')):
# silence peony
logging.getLogger('peony.data_processing').setLevel(
logging.WARNING)
self.twitter_client = PeonyClient(**creds,
loop=self.bot.loop,
session=self.bot.session)
logger.info('Starting twitter cronjob...')
self.twitter.add_exception_type(PeonyException)
self.twitter.start()
async def test_oauth2_bearer_token(oauth2_client):
await oauth2_client.headers.sign()
token = oauth2_client.headers.token
client2 = PeonyClient("", "", bearer_token=token, auth=oauth.OAuth2Headers)
assert client2.headers.token == oauth2_client.headers.token
def initialize_twitter():
global client
missing = False
required_keys = [
("consumer key", TWITTER_CONSUMER_KEY),
("consumer secret", TWITTER_CONSUMER_SECRET),
("access token", TWITTER_ACCESS_TOKEN),
("access token secret", TWITTER_ACCESS_TOKEN_SECRET),
]
for name in [x for x, y in required_keys if y is None]:
logger.info(f"Twitter {name} not provided.")
missing = True
if missing:
logger.info("Twitter disabled.")
else:
client = PeonyClient(
consumer_key=TWITTER_CONSUMER_KEY,
consumer_secret=TWITTER_CONSUMER_SECRET,
access_token=TWITTER_ACCESS_TOKEN,
access_token_secret=TWITTER_ACCESS_TOKEN_SECRET,
)
def _get_twitter_client() -> PeonyClient:
creds = dict(
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
access_token=ACCESS_TOKEN,
access_token_secret=ACCESS_TOKEN_SECRET,
)
return PeonyClient(**creds)
def __init__(self, bot):
self.bot = bot
self.client = PeonyClient(
consumer_key=TWITTER_API_KEY,
consumer_secret=TWITTER_API_S,
access_token=TWITTER_ACCESS_TOKEN,
access_token_secret=TWITTER_ACCESS_TOKEN_S,
)
self.twitter.start()
def __init__(self, api_creds):
self._index = 0
self._clients = clients = [
PeonyClient(consumer_key=creds['consumer_key'],
consumer_secret=creds['consumer_secret'],
access_token=creds['access_token'],
access_token_secret=creds['access_token_secret'])
for creds in api_creds
]
self.client_num = len(self._clients)
async def follow_stream():
client = PeonyClient(
consumer_key=cfg.consumer_key,
consumer_secret=cfg.consumer_secret,
access_token=cfg.access_token_key,
access_token_secret=cfg.access_token_secret,
proxy=cfg.proxy,
)
router = TweetRouter()
router.load(cfg.follows, cfg.media_only_users)
user_id_cache = UserIdCache()
async with client:
follow_ids = await user_id_cache.convert(client, router.follows)
sv.logger.info(f"订阅推主={router.follows.keys()}, {follow_ids=}")
stream = client.stream.statuses.filter.post(follow=follow_ids)
async for tweet in stream:
sv.logger.info("Got twitter event.")
if peony.events.tweet(tweet):
screen_name = tweet.user.screen_name
if screen_name not in router.follows:
continue # 推主不在订阅列表
if peony.events.retweet(tweet):
continue # 忽略纯转推
reply_to = tweet.get("in_reply_to_screen_name")
if reply_to and reply_to != screen_name:
continue # 忽略对他人的评论，保留自评论
entry = router.follows[screen_name]
media = tweet.get("extended_entities", {}).get("media", [])
if entry.media_only and not media:
continue # 无附带媒体，订阅选项media_only=True时忽略
msg = format_tweet(tweet)
if "quoted_status" in tweet:
quoted_msg = format_tweet(tweet.quoted_status)
msg = f"{msg}\n\n>>>>>\n{quoted_msg}"
old_profile_img = entry.profile_image
entry.profile_image = tweet.user.get(
"profile_image_url_https") or entry.profile_image
if old_profile_img and entry.profile_image != old_profile_img:
big_img = re.sub(
r'_normal(\.(jpg|jpeg|png|gif|jfif|webp))$', r'\1',
entry.profile_image, re.I)
msg = [msg, f"@{screen_name} 更换了头像\n{ms.image(big_img)}"]
sv.logger.info(f"推送推文：\n{msg}")
for s in entry.services:
await s.broadcast(msg, f" @{screen_name} 推文", 0.2)
else:
sv.logger.debug("Ignore non-tweet event.")
def __init__(
self,
*,
auth: OAuth10aTokens,
) -> None:
self._peony_client = PeonyClient(
consumer_key=auth.consumer_key,
consumer_secret=auth.consumer_secret,
access_token=auth.access_token,
access_token_secret=auth.access_token_secret,
)
def get_twitter_client(cls):
try:
return cls._twitter_client
except AttributeError:
cls._twitter_client = PeonyClient(
consumer_key=conf.TWITTER_CONSUMER_KEY,
consumer_secret=conf.TWITTER_CONSUMER_SECRET,
access_token=conf.TWITTER_ACCESS_KEY,
access_token_secret=conf.TWITTER_ACCESS_SECRET,
session=SessionManager.get(),
loop=LOOP)
return cls._twitter_client
def __init__(self, getter, locales):
if config.ACCESS_TOKEN == 'access_token':
self.client = None
else:
self.client = PeonyClient(
consumer_key=config.CONSUMER_KEY,
consumer_secret=config.CONSUMER_SECRET,
access_token=config.ACCESS_TOKEN,
access_token_secret=config.ACCESS_TOKEN_SECRET)
self.get_param = getter
self.locales = locales
async def get_client():
settings = await utils.get_settings(
'consumer-key',
'consumer-secret',
'access-token',
'access-secret')
return PeonyClient(
consumer_key=settings['consumer-key'],
consumer_secret=settings['consumer-secret'],
access_token=settings['access-token'],
access_token_secret=settings['access-secret'])
async def track_stream():
client = PeonyClient(
consumer_key=cfg.consumer_key,
consumer_secret=cfg.consumer_secret,
access_token=cfg.access_token_key,
access_token_secret=cfg.access_token_secret,
proxy=cfg.proxy,
)
async with client:
stream = client.stream.statuses.filter.post(track=['URA9'])
async for tweet in stream:
sv.logger.info("Got twitter event.")
if peony.events.tweet(tweet):
screen_name = tweet.user.screen_name
if screen_name in cfg.uma_ura9_black_list:
continue # black list
if peony.events.retweet(tweet):
continue # 忽略纯转推
if tweet.get("quoted_status"):
continue # 忽略引用转推
if tweet.get("in_reply_to_screen_name"):
continue # 忽略评论
if not re.search(r'\d{9}', tweet.text):
continue # 忽略无id的推特
if re.search(r'ura(シナリオ)?([:：])?\s*[0-5０１２３４５]', tweet.text,
re.I):
continue # 忽略低ura因子
if re.search(r'目指|狙|チャレンジ|微妙', tweet.text, re.I):
continue # 忽略未达成
if re.search(r'青(因子)?\s*[0124578０１２４５７８]', tweet.text, re.I):
continue # 忽略低星蓝
if re.search(
r'(スピ(ード)?|スタ(ミナ)?|パワー?|根性?|賢さ?)\s*[0124578０１２４５７８]',
tweet.text, re.I):
continue # 忽略低星蓝
if re.search(r'ura(シナリオ)?([:：])?9(では|じゃ|周回)', tweet.text,
re.I):
continue # 忽略否定型
if re.search(r'青(因子)?9(では|じゃ|周回)', tweet.text, re.I):
continue # 忽略否定型
msg = format_tweet(tweet)
sv.logger.info(f"推送推文：\n{msg}")
await sv.broadcast(msg, f" @{screen_name} 推文", 0.2)
else:
sv.logger.debug("Ignore non-tweet event.")
def __init__(self, config):
super().__init__(
command_prefix=_prefix_callable,
case_insensitive=True,
intents=intents,
help_command=commands.DefaultHelpCommand(no_category="Assorted",
dm_help=True,
verify_checks=False),
)
self.config = config
self.database = Database(config.database_url, config.database_conns)
self.destiny = Pydest(
api_key=config.destiny.api_key,
client_id=config.destiny.client_id,
client_secret=config.destiny.client_secret,
)
self.the100 = The100(config.the100.api_key, config.the100.base_url)
self.twitter = None
if (config.twitter.consumer_key and config.twitter.consumer_secret
and config.twitter.access_token
and config.twitter.access_token_secret):
self.twitter = PeonyClient(**config.twitter.asdict())
self.ext_conns = {
"database": self.database,
"destiny": self.destiny,
"twitter": self.twitter,
"the100": self.the100,
"redis_cache": None,
"redis_jobs": None,
}
for extension in STARTUP_EXTENSIONS:
try:
self.load_extension(extension)
except Exception as e:
exc = traceback.format_exception(type(e), e, e.__traceback__)
log.error(f"Failed to load extension {extension}: {exc}")
if config.enable_activity_tracking:
self.update_members.start()
self.cache_clan_members.start()
async def tweet(session, logger):
twitter_client = PeonyClient(
consumer_key=os.getenv("TWITTER_CONSUMER_KEY"),
consumer_secret=os.getenv("TWITTER_CONSUMER_SECRET"),
access_token=os.getenv("TWITTER_ACCESS_TOKEN"),
access_token_secret=os.getenv("TWITTER_ACCESS_TOKEN_SECRET"),
session=session)
# Need to do a manual connection to order by random
conn = Tortoise.get_connection("default")
haiku_rows = await conn.execute_query_dict(
"select id from haiku where tweet_id IS NULL AND article_id NOT IN (select article_id from haiku where tweet_id IS NOT NULL and tweeted_at > datetime('now','-2 hour')) ORDER BY RANDOM() limit 1"
)
if len(haiku_rows) > 0:
haiku = await models.Haiku.get(id=haiku_rows[0]["id"])
await haiku.fetch_related('article')
haiku.tweet = tweet_from_haiku(haiku)
response = await twitter_client.api.statuses.update.post(
status=haiku.tweet, trim_user=True)
haiku.tweet_id = response['id_str']
haiku.tweeted_at = parser.parse(response['created_at'])
log_line = f"{haiku.line0} / {haiku.line1} / {haiku.line2}"
logger.info(f"TWEET {haiku.tweet_id} {log_line}")
await haiku.save()
response = await twitter_client.api.statuses.user_timeline.get(
count=200, screen_name=os.getenv("TWITTER_USERNAME"), trim_user=True)
for t in response:
haiku = await models.Haiku.filter(tweet_id=t['id_str']).first()
if haiku:
favorite_count = t['favorite_count']
retweet_count = t['retweet_count']
if change_in_counts(haiku, favorite_count, retweet_count):
logger.info(
f"TWEET {t['id_str']} FAVES: {haiku.favorite_count} -> {favorite_count} RT: {haiku.retweet_count} -> {retweet_count}"
)
haiku.favorite_count = favorite_count
haiku.retweet_count = retweet_count
await haiku.save()
logger.info("TWEET STATISTICS updated")
async def twitter_stream_daemon():
client = PeonyClient(consumer_key=cfg.consumer_key,
consumer_secret=cfg.consumer_secret,
access_token=cfg.access_token_key,
access_token_secret=cfg.access_token_secret)
async with client:
while True:
try:
await open_stream(client)
except KeyboardInterrupt:
return
except Exception as e:
salmon.logger.exception(e)
salmon.logger.error(
f"Error {type(e)} Occurred in twitter stream. Restarting stream in 5s."
)
await asyncio.sleep(5)
async def start(self) -> None:
self.config: twitter = Edi().config.twitter
if not all([
self.config.consumer_key,
self.config.consumer_secret,
self.config.access_key,
self.config.access_secret,
]):
log.debug(f"missing twitter credentials")
return
logging.getLogger("peony").setLevel(logging.WARNING)
self.client = PeonyClient(
consumer_key=self.config.consumer_key,
consumer_secret=self.config.consumer_secret,
access_token=self.config.access_key,
access_token_secret=self.config.access_secret,
)
self.task = asyncio.ensure_future(self.timeline())
async def run(self):
try:
if not self.twitter_model.verified:
raise ValueError('Oauth Handshake not completed')
self.client = PeonyClient(
consumer_key=config['twitter']['consumer_key'],
consumer_secret=config['twitter']['consumer_secret'],
access_token=self.twitter_model.access_token,
access_token_secret=self.twitter_model.access_token_secret,
)
if self.twitter_model.mentions_since_id is None:
logger.debug(
'since_id is None in model, fetch newest mention id')
await self._poll_mentions()
if self.twitter_model.dms_since_id is None:
logger.debug('since_id is None in model, fetch newest dm id')
await self._poll_direct_messages()
user = await self.client.user
if user.screen_name:
await self.twitter_model.update(username=user.screen_name)
logger.debug('Starting Twitter bot: %s' %
self.twitter_model.__dict__)
await gather(self.poll(), self.push())
except CancelledError:
logger.debug(
f'Bot {self.twitter_model.hood.name} received Cancellation.')
except exceptions.Unauthorized:
logger.debug(
f'Bot {self.twitter_model.hood.name} has invalid auth token.')
await self.twitter_model.update(enabled=False)
self.enabled = self.twitter_model.enabled
except (KeyError, ValueError, exceptions.NotAuthenticated):
logger.warning(
'Missing consumer_keys for Twitter in your configuration.')
await self.twitter_model.update(enabled=False)
self.enabled = self.twitter_model.enabled
finally:
logger.debug(f'Bot {self.twitter_model.hood.name} stopped.')
def __init__(self, config):
super().__init__(command_prefix=_prefix_callable,
case_insensitive=True,
help_command=commands.DefaultHelpCommand(
no_category="Assorted",
dm_help=True,
verify_checks=False))
self.config = config
self.database = Database(config.database_url)
self.database.initialize()
self.destiny = Pydest(
api_key=config.bungie.api_key,
client_id=config.bungie.client_id,
client_secret=config.bungie.client_secret,
)
self.the100 = The100(config.the100.api_key, config.the100.base_url)
self.twitter = None
if (config.twitter.consumer_key and config.twitter.consumer_secret
and config.twitter.access_token
and config.twitter.access_token_secret):
self.twitter = PeonyClient(**config.twitter.asdict())
for extension in STARTUP_EXTENSIONS:
try:
self.load_extension(extension)
except Exception as e:
exc = traceback.format_exception(type(e), e, e.__traceback__)
log.error(f"Failed to load extension {extension}: {exc}")
self.bungie_maintenance = False
if config.enable_activity_tracking:
self.update_last_active.start()
self.update_member_games.start()
async def twitter_update(self):
await self.bot.wait_until_ready()
while not self.bot.is_closed():
try:
recent = None
twitter_client = PeonyClient(
consumer_key=authDeets.consumer_key,
consumer_secret=authDeets.consumer_secret,
access_token=authDeets.access_token,
access_token_secret=authDeets.access_token_secret)
data = await twitter_client.api.statuses.user_timeline.get(
screen_name='DoorMonster', count=1)
recent = data[0]['id']
if recent:
if self.last_twitter_update is None:
self.last_twitter_update = recent
print("Twitter link established, got tweet {}".format(
recent))
if self.last_twitter_update != recent:
self.last_twitter_update = recent
if data[0][
'in_reply_to_status_id'] is None and not data[
0]['text'].startswith('RT @'):
the_channel = discord.utils.get(
self.bot.get_all_channels(),
guild__name="Door Monster",
name="social-media-feed")
await the_channel.send(
"https://twitter.com/DoorMonster/status/{0}".
format(recent))
log("Twitter update", None, None,
self.last_twitter_update, None)
await asyncio.sleep(300)
except:
print("Error retreiving tweet, sleeping")
await asyncio.sleep(3000)
from requests_oauthlib import OAuth1
import hmac, base64, hashlib
import json
from flask import Flask, request
from http import HTTPStatus
import tf_connect
from configuration import Configuration
app = Flask(__name__)
# create the client using the api keys
CLIENT = PeonyClient(
consumer_key=Configuration.CONSUMER_KEY,
consumer_secret=Configuration.CONSUMER_SECRET,
access_token=Configuration.ACCESS_TOKEN,
access_token_secret=Configuration.ACCESS_TOKEN_SECRET,
)
AUTH = OAuth1(
Configuration.CONSUMER_KEY,
Configuration.CONSUMER_SECRET,
Configuration.ACCESS_TOKEN,
Configuration.ACCESS_TOKEN_SECRET,
)
TF_SERVER_URL = Configuration.TF_SERVER_URL
CURRENT_USER_ID = None
loop = asyncio.get_event_loop()
# ACCESS_TOKEN = os.getenv("ACCESS_TOKEN", None)
ACCESS_TOKEN_SECRET = ''
# ACCESS_TOKEN_SECRET = os.getenv("ACCESS_TOKEN_SECRET", None)
# Users to watch for should be a list. This will be joined by Twitter and the
# data returned will be for any tweet mentioning:
# @twitter *OR* @twitterapi *OR* @support.
USERS = ['@survivetheark']
# Languages to filter tweets by is a list. This will be joined by Twitter
# to return data mentioning tweets only in the english language.
LANGUAGES = ['en']
# Since we're going to be using a streaming endpoint, there is no need to worry
# about rate limits.
pclient = PeonyClient(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN,
ACCESS_TOKEN_SECRET)
client = discord.Client()
loop = asyncio.get_event_loop()
app = web.Application()
link = 'https://survivetheark.com/index.php?/forums/topic/388254-pc-patch-notes-client-v31067-server-v31076/'
debug = False
@client.event
async def on_ready():
print(f'Logged on as {client.user}')
print('Tracking of Twitter, Youtube, and RSS Feeds Started')
@client.event
from peony import events
from pushbullet import Pushbullet
loop = asyncio.get_event_loop()
PUSHBULLET_TOKEN = os.getenv('PUSHBULLET_TOKEN')
CONSUMER_KEY = os.getenv('CONSUMER_KEY')
CONSUMER_SECRET = os.getenv('CONSUMER_SECRET')
ACCESS_TOKEN = os.getenv('ACCESS_TOKEN')
ACCESS_TOKEN_SECRET = os.getenv('ACCESS_TOKEN_SECRET')
ALERTS = os.getenv('ALERTS', '').split(',')
client = PeonyClient(consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
access_token=ACCESS_TOKEN,
access_token_secret=ACCESS_TOKEN_SECRET)
pushbullet = Pushbullet(PUSHBULLET_TOKEN)
async def send(alert, tweet_text):
title = f'New {alert} alert'
body = tweet.text
await pushbullet.push_note(title, body)
async def process(tweet):
print(f'Got tweet {tweet.text}')
for alert in ALERTS:
#!/usr/bin/env python3
#import
from peony import PeonyClient
import datetime
from dateutil.parser import parse
from trusted import userid
creds = dict(consumer_key=YOUR_CONSUMER_KEY,
consumer_secret=YOUR_CONSUMER_SECRET,
access_token=YOUR_ACCESS_TOKEN,
access_token_secret=YOUR_ACCESS_TOKEN_SECRET) #Init a async client
client = PeonyClient(**creds)
async def isAlive(bot):
latest = await client.api.statuses.user_timeline.get(screen_name="screenname")
now = datetime.datetime.now(datetime.timezone.utc)
time = datetime.datetime.now(datetime.timezone.utc) - parse(latest.created_at)
if time.days > 2:
await bot.sendMessage(bot.sendMessage(msg['chat']['id'],"""
The Twitter account of `PlaceHolder` has been nonactive for over 2 days, now sending life confirmation request to pre-defined trusted user, please confirm this user life activitiy.
You may send confirmation email to [email protected] with email titiled 'Confirmed' (Case Sensitive)
""")
WORKER_SLEEP = int(os.getenv('COMKC_WORKER_SLEEP', 60 * 60 * 8))
MAX_LIMIT = 20
MAX_OFFSET = 500
if DEBUG:
level = logging.DEBUG
else:
level = logging.INFO
format_str = '%(levelname)s %(asctime)s %(module)s %(name)s %(message)s'
logging.basicConfig(level=level, format=format_str)
SENTRY_DSN = os.environ.get('COMKC_SENTRY_DSN')
if SENTRY_DSN:
from raven.conf import setup_logging
from raven.handlers.logging import SentryHandler
handler = SentryHandler(SENTRY_DSN)
handler.setLevel(logging.ERROR)
setup_logging(handler)
TWITTER = {
'consumer_key': os.environ.get('COMKC_TWITTER_CONSUMER_KEY'),
'consumer_secret': os.environ.get('COMKC_TWITTER_CONSUMER_SECRET'),
'access_token': os.environ.get('COMKC_TWITTER_ACCESS_TOKEN'),
'access_token_secret': os.environ.get('COMKC_TWITTER_ACCESS_TOKEN_SECRET'),
}
peony_client = None
if TWITTER['consumer_key']:
from peony import PeonyClient
peony_client = PeonyClient(**TWITTER)
def dummy_peony_client(event_loop):
client = PeonyClient("", "", loop=event_loop)
with patch.object(client, 'init_tasks', return_value=[]):
yield client
def peony_client(event_loop):
return PeonyClient("", "", loop=event_loop)
async def _ainit(self):
self.client = PeonyClient(**self.keys, loop=self.bot.loop)
self.restart_stream_task = asyncio.create_task(
self.restart_stream_sub())