def setup():
client = Client(client_id)
client.start()
auth = client.authorize(client_id, ['rpc'])
client.close()
rpcToken = auth["data"]["code"]
if rpcToken != None:
headers = {
"rpcToken": rpcToken,
}
user_object = requests.get("https://rich-presence-api.glitch.me/setup",
headers=headers)
if user_object.status_code == 200:
user_json = user_object.json()
with open(os.path.abspath(os.getcwd()) + '\data.json',
'w') as outfile:
json.dump(user_json, outfile)
return user_json
else:
raise RuntimeWarning("One or more of the apis errored.")
else:
raise RuntimeWarning("Error when obtaining RPC token.")
def _reconnect(self):
if not self._enabled:
try:
self._rpc = Client(self._client_id)
self._rpc.start()
self._enabled = True
except self._errors:
self._enabled = False
def main():
while True:
try:
RPC = Client("806910592983367730")
show_presence(RPC)
except KeyboardInterrupt:
exit()
except:
print("rpc connection failed")
import signal
def signal_handler(signum, frame):
raise Exception("TO")
cluster = MongoClient(
f"mongodb+srv://kingszeto:{config.mongo_password}@cluster0.zfror.mongodb.net/<dbname>?retryWrites=true&w=majority"
)
db = cluster["rootwitch"]
collection = db["teams"]
party = collection.find({"_id": "tlwin2020"})[0]
print(party)
client_id = config.client_id
client = Client(client_id)
client.start()
client.subscribe("ACTIVITY_JOIN")
a = client.set_activity(pid=0, state=f"Watching {party['match']}",\
details= f"Rooting for {party['team']}",\
small_image=party['small'], small_text=party['match'],\
large_image=party['big'], large_text=party['team'], start = time.time(),\
party_size=[1,10000], party_id=party['_id']+'A', join=party['_id'])
print(a)
print("Begin Loop")
while True:
time.sleep(1)
signal.signal(signal.SIGALRM, signal_handler)
from pypresence import Client
import time
client_id = "743296148592263240"
RPC = Client(client_id)
RPC.start()
def register_join_event(syncplay_join_group: callable):
RPC.register_event('activity_join', syncplay_join_group)
def send_presence(
title: str,
subtitle: str,
playback_time: float = None,
duration: float = None,
playing: bool = False,
syncplay_group: str = None,
):
small_image = "play-dark3" if playing else None
start = None
end = None
if playback_time is not None and duration is not None and playing:
start = int(time.time() - playback_time)
end = int(start + duration)
RPC.set_activity(
state=subtitle,
details=title,
instance=False,
large_image="jellyfin2",
def main():
def isDiscordRunning():
counter = 0
r = os.popen('tasklist /v').read().strip().split('\n')
for i in range(len(r)):
s = r[i]
if "Discord.exe" in r[i]:
counter = counter + 1
if counter >= 4:
return True
else:
return False
client_id = "696685746832277534"
previous = {
"details": None,
"state": None,
"image": None,
"gameSize": None,
"gameId": None,
}
start = None
activityCleared = True
client = None
ClientClosed = True
try:
with open(os.path.abspath(os.getcwd()) + '\data.json') as json_file:
data = json.load(json_file)
except FileNotFoundError:
data = setup()
discordToken = data["discordToken"]
robloxId = data["robloxId"]
while True:
while isDiscordRunning() == True:
if ClientClosed == True:
client = Client(client_id)
client.start()
client.authenticate(discordToken)
ClientClosed = False
headers = {
"previous": json.dumps(previous),
"robloxId": str(robloxId),
}
rawData = requests.get(
"https://rich-presence-api.glitch.me/getStatus",
headers=headers)
if rawData.status_code == 200:
data = rawData.json()
details = data["details"]
state = data["state"]
image = data["image"]
gameSize = data["gameSize"]
gameId = data["gameId"]
if details == None:
if activityCleared == False:
client.clear_activity()
activityCleared = True
else:
time.sleep(5)
else:
if data != previous:
if details != previous["details"] or state != previous[
"state"] or gameId != previous["gameId"]:
start = round(time.time())
if details == "Playing":
client.set_activity(
state=state,
details=details,
start=start,
large_image=image,
party_size=gameSize,
large_text="Made by Tweakified")
else:
client.set_activity(
state=state,
details=details,
start=start,
large_image=image,
large_text="Made by Tweakified")
activityCleared = False
time.sleep(15)
else:
time.sleep(5)
previous = data
if ClientClosed == False:
if client != None:
client.close()
ClientClosed = True
return None
def set(self, value):
time = datetime.fromtimestamp(value)
self.year.set(time.year)
self.month.set(time.month)
self.day.set(time.day)
self.hour.set(time.hour)
self.minute.set(time.minute)
self.second.set(time.second)
self.value = value
def get_config_file():
home = pathlib.Path.home()
if sys.platform == "win32":
return home / "AppData/Roaming/StatusChanger/.StatusChanger.json"
elif sys.platform == "linux":
return home / ".local/share/StatusChanger/.StatusChanger.json"
elif sys.platform == "darwin":
return home / "Library/Application Support/StatusChanger/.StatusChanger.json"
if __name__ == "__main__":
configuration = settings.Settings(get_config_file())
get_id = GetId(configuration)
id, pipe, trad = get_id.mainloop()
if not id == 0:
try:
RPC = Client(id, pipe=pipe)
RPC.start()
except exceptions.InvalidPipe:
pass
rpc_tk = RPC_tk(RPC, id, configuration, trad, pipe)
try:
# Import modules
from pypresence import Presence, Client
import time
# Connect to Discord
cid = 706083923431522316
auth = "nV7OxD2xpWnolSxsm9VkGYcmy5re5V"
rpc = Presence(cid)
client = Client(cid, pipe=0)
client.start()
client.authorize(cid, ["rpc", "rpc.notifications.read"])
#client.authenticate(auth)
print(client.get_selected_voice_channel())
#client.authorize(cid)
rpc.connect()
rpc.update(state="Rich Presence using pypresence!")
#client.set_user_voice_settings(cid)
print('RPC set successfully.')
# Update RPC every 15 seconds
while True:
time.sleep(15)
# Custom KeyboardInterrupt message
except KeyboardInterrupt:
print('\nProgram stopped using Ctrl+C.')
import requests
from pypresence import Client
CLIENT_ID = "207646673902501888"
TOKEN_URL = "https://streamkit.discord.com/overlay/token"
rpc = Client(CLIENT_ID)
def get_code():
response = rpc.authorize(CLIENT_ID, ["rpc", "messages.read"])
data = response["data"]
return data["code"]
def get_access_token(code):
response = requests.post(url=TOKEN_URL, json={"code": code})
data = response.json()
return data["access_token"]
def get_selected_voice_channel():
response = rpc.get_selected_voice_channel()
data = response["data"]
return data