def updateUserdata(self, userdata, connection, cursor):
# This updates: LastPlayedDate, Playcount
embyId = userdata['ItemId']
MBitem = ReadEmbyDB().getItem(embyId)
if not MBitem:
self.logMsg("UPDATE userdata to Kodi library FAILED, Item %s not found on server!" % embyId, 1)
return
# Get details
checksum = API().getChecksum(MBitem)
userdata = API().getUserData(MBitem)
# Find the Kodi Id
cursor.execute("SELECT kodi_id, media_type FROM emby WHERE emby_id = ?", (embyId,))
try:
result = cursor.fetchone()
kodiid = result[0]
mediatype = result[1]
self.logMsg("Found embyId: %s in database - kodiId: %s type: %s" % (embyId, kodiid, mediatype), 1)
except:
self.logMsg("Id: %s not found in the emby database table." % embyId, 1)
else:
if mediatype in ("song"):
playcount = userdata['PlayCount']
dateplayed = userdata['LastPlayedDate']
query = "UPDATE song SET iTimesPlayed = ?, lastplayed = ? WHERE idSong = ?"
cursor.execute(query, (playcount, dateplayed, kodiid))
#update the checksum in emby table
query = "UPDATE emby SET checksum = ? WHERE emby_id = ?"
cursor.execute(query, (checksum, embyId))
def getPlayerData(self, clanID):
api = API()
clantag = api.getClanTag(ID)
players = api.getClanMembers(ID)
if players is not None:
for player in players:
name = api.getPlayerName(player)
def addPlaylistItem(self, playlist, item):
id = item['Id']
username = utils.window('currUser')
server = utils.window('server%s' % username)
playurl = PlayUtils().getPlayUrl(server, id, item)
if utils.window('playurlFalse') == "true":
# Playurl failed - set in PlayUtils.py
utils.window('playurlFalse', clear=True)
self.logMsg(
"Failed to retrieve the playback path/url or dialog was cancelled.",
1)
return
self.logMsg("Playurl: %s" % playurl)
thumb = API().getArtwork(item, "Primary")
listItem = xbmcgui.ListItem(path=playurl,
iconImage=thumb,
thumbnailImage=thumb)
self.setListItemProps(server, id, listItem, item)
self.setProperties(playurl, item, listItem)
playlist.add(playurl, listItem)
def run_API(self):
api = API(
host=self.__host,
port=self.__port,
key=self.__key,
moni_port=self.__moni_port)
api.run()
def saveExpValues(self):
dt = Data()
api = API()
temp = api.expectedValues()
time = temp['time']
out = []
for shipid, shipdata in temp['data'].items():
lst = []
lst.append(shipid)
print(
shipid
) #this function takes a while so print ship ID's to keep us occupied. The dark is scary
#print(shipdata)
name = api.getShipName(shipid)
if name is None:
lst.append("None")
else:
lst.append(name)
if (len(shipdata) != 0):
lst.append(shipdata['average_damage_dealt'])
lst.append(shipdata['average_frags'])
lst.append(shipdata['win_rate'])
out.append(lst)
#print(out)
dt.write('wowsnumbers', (str(time) + '.csv').strip(), out)
return temp['data']
def paridades():
api = API()
api.connect()
data = request.get_json()
print(data)
binary, digital = api.paridades()
return {'binary': binary, 'digital': digital}
def setListItemProps(self, server, id, listItem, result):
# Set up item and item info
api = self.api
type = result.get('Type')
people = api.getPeople(result)
studios = api.getStudios(result)
metadata = {
'title': result.get('Name', "Missing name"),
'year': result.get('ProductionYear'),
'plot': api.getOverview(result),
'director': people.get('Director'),
'writer': people.get('Writer'),
'mpaa': api.getMpaa(result),
'genre': api.getGenre(result),
'studio': " / ".join(studios),
'aired': api.getPremiereDate(result),
'rating': result.get('CommunityRating'),
'votes': result.get('VoteCount')
}
if "Episode" in type:
# Only for tv shows
thumbId = result.get('SeriesId')
season = result.get('ParentIndexNumber', -1)
episode = result.get('IndexNumber', -1)
show = result.get('SeriesName', "")
metadata['TVShowTitle'] = show
metadata['season'] = season
metadata['episode'] = episode
listItem.setProperty('IsPlayable', 'true')
listItem.setProperty('IsFolder', 'false')
listItem.setLabel(metadata['title'])
listItem.setInfo('video', infoLabels=metadata)
# Set artwork for listitem
self.setArt(listItem, 'poster', API().getArtwork(result, "Primary"))
self.setArt(listItem, 'tvshow.poster',
API().getArtwork(result, "SeriesPrimary"))
self.setArt(listItem, 'clearart', API().getArtwork(result, "Art"))
self.setArt(listItem, 'tvshow.clearart',
API().getArtwork(result, "Art"))
self.setArt(listItem, 'clearlogo', API().getArtwork(result, "Logo"))
self.setArt(listItem, 'tvshow.clearlogo',
API().getArtwork(result, "Logo"))
self.setArt(listItem, 'discart', API().getArtwork(result, "Disc"))
self.setArt(listItem, 'fanart_image',
API().getArtwork(result, "Backdrop"))
self.setArt(listItem, 'landscape', API().getArtwork(result, "Thumb"))
def clanReport(self, ID):
dt = Data()
api = API()
ut = Util()
stats = Stats()
curtime = ut.getGMTTime()
clanlist = dt.read('', 'ClanList')
def main():
# get args
parser = argparse.ArgumentParser(description='Facial recognition')
parser.add_argument('--camera',
help='Camera device number.',
type=int,
default=0)
parser.add_argument('--api', help='Base address for the API')
parser.add_argument('--frame',
help='Picture path if you do not want to use the cam')
parser.add_argument(
'--debug',
help=
'Boolean if you want to send hardcoded picture to test the server handling',
action='store_true')
args = parser.parse_args()
username = os.environ['wiface_username']
password = os.environ['wiface_password']
creds = User(username, password)
MyAPI = API(creds, args.api)
if args.debug and args.frame is not None:
TestWithoutOpenCV(args.frame, MyAPI)
return
if args.frame is not None:
frame = cv.imread(args.frame)
process_frame(frame, MyAPI)
else:
camera_device = args.camera
# Read the video stream
cam = cv.VideoCapture(camera_device)
# setting the buffer size and frames per second, to reduce frames in buffer
cam.set(cv.CAP_PROP_BUFFERSIZE, 1)
cam.set(cv.CAP_PROP_FPS, 2)
if not cam.isOpened:
print('--(!)Error opening video capture')
exit(0)
while True:
frame = {}
# calling read() twice as a workaround to clear the buffer.
cam.read()
cam.read()
ret, frame = cam.read()
if frame is None:
print('--(!) No captured frame -- Break!')
break
process_frame(frame, MyAPI)
# When everything done, release the capture
cam.release()
cv.destroyAllWindows()
def __get_apis(self):
apis = []
for instance in self.__instances:
endpoint = "http://" + instance["hostname"] + ":5000"
host = "bwapi"
if "API_SERVER_NAME" in instance["env"]:
host = instance["env"]["API_SERVER_NAME"]
apis.append(API(endpoint, host=host))
return apis
def getClanData(self, clanID):
api = API()
clantag = str(api.getClanTag(clanID))
temp = d.getMostRecent(clantag)
tempdata = d.read(clantag, str(temp))
data = []
for i in tempdata:
val = float(i[0])
data.append(val)
return data
def Init(self, teams):
for team in teams:
self.add_team(team)
# рандомим места для баз, размещаем их там и инициализируем
coord_for_bases = sample(self.obj_by_coord, len(teams))
for base, coord in zip(self.teams_by_base, coord_for_bases):
API_for_setup = API(world=self)
API_for_setup.Init(base)
base.Init(API=API_for_setup)
self.set_obj(obj=base, coord=coord)
def ML():
tfidfconverter = load("tfidfconverter.joblib")
sentiment_regression_classifier = load(
"sentiment_regression_classifier.joblib")
tweet_df = API()
##trump_df=pd.read_csv("Trump_tweets_scraped.csv")
#cleaning up the trump tweets:
tweet_text = tweet_df['Tweet Text'].to_list()
edited_text = []
sentiment_list = []
#Lowercase tweets
for tweet in range(0, len(tweet_text)):
#lower case
#removing speocial cahracters
edited_tweet = re.sub(r'\W', ' ', str(tweet_text[tweet]))
# remove sinflue
edited_tweet = re.sub(r'\s+[a-zA-Z]\s+', ' ', edited_tweet)
# Remove single characters from the start
edited_tweet = re.sub(r'\^[a-zA-Z]\s+', ' ', edited_tweet)
# Substituting multiple spaces with single space
edited_tweet = re.sub(r'\s+', ' ', edited_tweet, flags=re.I)
# Removing prefixed 'b'
edited_tweet = re.sub(r'^b\s+', '', edited_tweet)
#removing stopwords tweets
edited_tweet = edited_tweet.lower()
edited_text.append(edited_tweet)
sentiment_trump = sentiment_regression_classifier.predict(
tfidfconverter.transform([edited_tweet]).toarray())
sentiment_list.append(sentiment_trump)
sentiment_list_edited = []
for item in sentiment_list:
if "positive" in item:
sentiment_list_edited.append("positive")
else:
sentiment_list_edited.append("negative")
tweet_df["sentiment"] = sentiment_list_edited
return tweet_df
def __init__(self):
self.status = SS.startup
self.file(SE.notify, "Initalizing MCO...")
# Configuration
self.file(SE.notify, "Loading configuration")
self.config = Config('./config/config.json', defaultConfig)
# Controller
self.file(SE.notify, "Loading controller")
self.controller = Config('./config/controller.json', defaultController)
# Set refresh rate
self.sleepPerCycle = 1/self.config.get("refreshesPerSecond")
# LogMonitor
self.file(SE.notify, "Loading log monitor")
self.logger = LogMonitor(
self.config.get("logFolder"),
self.config.get("ownUsername"),
self.config.get("debug")["Logs"]
)
self.status = SS.oldLogs
self.file(SE.notify, "Loading old logs (if any)")
self.logger.tick(True)
self.logger.tick(True)
self.logger.resetExposed()
self.status = SS.startup
self.file(SE.notify, "Loaded old logs")
# API
self.file(SE.notify, "Loading API")
self.api = API(
self.config.get("token"),
int(self.config.get("threads")) - 1,
self.config.get("debug")["API"]
)
self.api.printHypixelStats()
self.api.printMinecraftStats()
# CommandSender
self.file(SE.notify, "Loading Command Sender")
self.commandSender = CommandSender(self.config.get("commandCooldown"))
# Init GUI
self.file(SE.notify, "Loading GUI")
#self.GUI = GUI(800, 600, "1.0", ["a", "b", "c"], {})
#self.GUI = GUI()
# Update status
self.status = SS.waiting
self.file(SE.notify, "Finished initializing")
def run(self):
# Instancia del juego
self.size()
api = API(self.sizev)
sudoku = Sudoku(api.Table(), self.sizev)
while not sudoku.is_over():
print(sudoku.showTable())
check, error_message = sudoku.playing(self.getValues())
if not check:
print(error_message)
print("\n\nFelicitaciones!!!!")
print("Terminaste el juego de Sudoku\n\n")
print(sudoku.showTable())
def addPlaylistItem(self, playlist, item, server, userid):
id = item.get("Id")
playurl = PlayUtils().getPlayUrl(server, id, item)
utils.logMsg("PlayBackUtils", "Play URL: " + playurl)
thumbPath = API().getArtwork(item, "Primary")
listItem = xbmcgui.ListItem(path=playurl, iconImage=thumbPath, thumbnailImage=thumbPath)
self.setListItemProps(server, id, listItem, item)
WINDOW = xbmcgui.Window(10000)
username = WINDOW.getProperty('currUser')
userid = WINDOW.getProperty('userId%s' % username)
server = WINDOW.getProperty('server%s' % username)
# Can not play virtual items
if (item.get("LocationType") == "Virtual") or (item.get("IsPlaceHolder") == True):
xbmcgui.Dialog().ok(self.language(30128), self.language(30129))
return False
else:
watchedurl = "%s/mediabrowser/Users/%s/PlayedItems/%s" % (server, userid, id)
positionurl = "%s/mediabrowser/Users/%s/PlayingItems/%s" % (server, userid, id)
deleteurl = "%s/mediabrowser/Items/%s" % (server, id)
# set the current playing info
WINDOW = xbmcgui.Window( 10000 )
WINDOW.setProperty(playurl + "watchedurl", watchedurl)
WINDOW.setProperty(playurl + "positionurl", positionurl)
WINDOW.setProperty(playurl + "deleteurl", "")
if item.get("Type") == "Episode" and addon.getSetting("offerDelete")=="true":
WINDOW.setProperty(playurl + "deleteurl", deleteurl)
WINDOW.setProperty(playurl + "runtimeticks", str(item.get("RunTimeTicks")))
WINDOW.setProperty(playurl+"type", item.get("Type"))
WINDOW.setProperty(playurl + "item_id", id)
if (item.get("Type") == "Episode"):
WINDOW.setProperty(playurl + "refresh_id", item.get("SeriesId"))
else:
WINDOW.setProperty(playurl + "refresh_id", id)
utils.logMsg("PlayBackUtils", "PlayList Item Url : " + str(playurl))
playlist.add(playurl, listItem)
return True
async def postValues(clanname,start,end):
start_time=time.time()
embed = discord.Embed()
#TODO: Check member size to determine if multiple embeds are required
p = Post()
a = API()
u = Util()
embed = p.createEmbed(clanname,embed,start,end)
postname = "["+str(clanname)+"] "+a.getClanName(a.getClanID(clanname))+" Statistics"
embed.set_author(name=postname, icon_url=client.user.default_avatar_url)
runtime = "Runtime: "+str(u.round3(time.time()-start_time))+" Seconds"
embed.set_footer(text=str(runtime))
return embed
def calcOverallPR(self, playerID): #player PR calculation
"""
Parameters:
playerID: WG player ID
Returns:
PR value of player (float)
"""
a = API()
d = Data()
u = Util()
eDmg = 0
eWin = 0
eKil = 0
aDmg = 0
aWin = 0
aKil = 0
btot = 0
data = a.getPlayerShipStats(playerID)
for shipdata in data:
#print(shipdata)
b = a.getShipBattles(shipdata)
id = a.getShipID(shipdata)
expectedstats = d.getShipStats(id)
#print(expectedstats)
if expectedstats is not None:
eDmg += float(expectedstats[0]) * b
eKil += float(expectedstats[1]) * b
eWin += float(expectedstats[2]) * b / 100
aDmg += a.getShipDmg(shipdata)
aKil += a.getShipKills(shipdata)
aWin += a.getShipWins(shipdata)
btot += b
#print(b)
#print(str(aWin))
dmg = self.PRnormDmg(aDmg, eDmg)
kills = self.PRnormKil(aKil, eKil)
wins = self.PRnormWin(aWin, eWin)
#print(str(dmg)+" "+str(kills)+" "+str(wins))
return (700 * dmg + 300 * kills + 150 * wins)
def __init__(self, farmwarename):
self.farmwarename = farmwarename
self.input_sequence_init_dic = {}
self.input_sequence_beforemove_dic = {}
self.input_sequence_aftermove_dic = {}
self.input_sequence_end_dic = {}
self.input_title = get_config_value(self.farmwarename,
'title',
value_type=str)
self.input_filter_min_x = get_config_value(self.farmwarename,
'filter_min_x',
value_type=str)
self.input_filter_max_x = get_config_value(self.farmwarename,
'filter_max_x',
value_type=str)
self.input_filter_min_y = get_config_value(self.farmwarename,
'filter_min_y',
value_type=str)
self.input_filter_max_y = get_config_value(self.farmwarename,
'filter_max_y',
value_type=str)
self.input_sequence_init = get_config_value(self.farmwarename,
'sequence_init',
value_type=str).split(",")
self.input_sequence_beforemove = get_config_value(
self.farmwarename, 'sequence_beforemove',
value_type=str).split(",")
self.input_sequence_aftermove = get_config_value(
self.farmwarename, 'sequence_aftermove', value_type=str).split(",")
self.input_sequence_end = get_config_value(self.farmwarename,
'sequence_end',
value_type=str).split(",")
self.input_offset_x = get_config_value(self.farmwarename,
'offset_x',
value_type=int)
self.input_offset_y = get_config_value(self.farmwarename,
'offset_y',
value_type=int)
self.input_default_z = get_config_value(self.farmwarename,
'default_z',
value_type=int)
self.input_default_speed = get_config_value(self.farmwarename,
'default_speed',
value_type=int)
self.input_debug = get_config_value(self.farmwarename,
'debug',
value_type=int)
self.api = API(self.input_debug)
def __init__(self):
# Initialize variables to None
self.host = None
self.port = None
self.chan = None
self.nick = None
self.auth = None
capability = ["tags"]
self.access_token = None
self.cooldown = 0
self.last_command_time = 0
self.allowed_ranks = []
self.allowed_users = []
self.custom_prompt = ""
with open("blacklist.txt", "r") as f:
censor = [l.replace("\n", "") for l in f.readlines()]
self.pf = ProfanityFilter(custom_censor_list=censor)
# Create an Api instance to connect to AI Dungeon 2.
logging.debug("Creating API instance.")
self.api = API(self)
# Update variables
logging.debug("Setting settings.")
Settings(self)
# Create a Database instance for storing which users do not want to be whispered
logging.debug("Creating Database instance.")
self.db = Database(self.chan)
# Get the session_id
self.session_id = self.api.get_session_id()
# Create Websocket object
logging.debug("Creating TwitchWebsocket object.")
self.ws = TwitchWebsocket(host=self.host,
port=self.port,
chan=self.chan,
nick=self.nick,
auth=self.auth,
callback=self.message_handler,
capability=capability,
live=True)
# Start a blocking websocket connection
logging.debug("Starting Websocket connection.")
self.ws.start_bot()
def daftaradmin(self, pegawaiid, nama):
hasil = False
status = None
statusTemplate = []
try:
if not self.cekpegawai(pegawaiid):
#Proses Pendaftaran
loadtemplate = API().TEMPLATE(pegawaiid)
rootUser = self.do.SetAdminUser(nama, pegawaiid)
if rootUser is not None:
for row in rootUser.findall('Row'):
status = row.find('Information').text
if status == 'Successfully!':
for templateid in range(0, len(loadtemplate)):
size = loadtemplate[templateid]['size']
valid = loadtemplate[templateid]['valid']
finger_template = loadtemplate[templateid][
'templatefinger']
rootTemplate = self.do.SetUserTemplate(
pegawaiid, templateid, size, valid,
finger_template)
if rootTemplate is not None:
for row in rootTemplate.findall('Row'):
statusTemplate.append(
row.find('Information').text)
else:
hasil = False
if statusTemplate:
if statusTemplate[
0] == 'Successfully!' and statusTemplate[
1] == 'Successfully!':
hasil = True
else:
hasil = False
else:
hasil = False
else:
hasil = False
else:
hasil = True
finally:
if hasil:
return hasil
else:
gagal = self.hapuspegawai(pegawaiid)
return hasil
def process_row(rw):
logging.debug("process.process_row() start")
fromdate = rw[0].strip()
todate = rw[1].strip()
isin = rw[2].strip()
transactions = rw[3].strip()
turnover = rw[4].strip()
line = 0
try:
api = API() # TODO: Maybe move this up
sentence = api.handle_response(isin)
for collection in sentence:
# Original ESMA values including ISIN
print(fromdate,
",",
todate,
",",
isin,
",",
transactions,
",",
turnover,
",",
end="")
line += 1
if (sentence == "No identifier found."):
# This ISIN is unknown, so print "None", and exit loop
print(
"None, None, None, None, None, None, None, None, None, None, None, None, "
)
raise Exception(sentence)
else:
# Go through received data, and print each line
for key, valuex in collection.items():
value_no_comma = kill_comma(str(valuex))
print(value_no_comma, ",", end="")
print("")
except Exception as e:
ex = str(e)
logging.error(f"Exception: {ex} at line: {line}")
logging.debug("process.process_row() end")
def initialize(playerID):
global _api
global _initCallbacks
if not _api:
from API import API
_api = API(playerID)
import Settings
settings = Settings.g_instance.getVoipSettings()
_api.updateSettings(voiceActivationLevel=settings['micVolume'], voiceVolume=settings['masterVolume'], muffledMasterVolume=settings['fadeVolume'], autoConnectArenaChannel=settings['autoConnectArenaChannel'], captureDevice=settings['captureDevice'])
_api.enabled = settings['isVoipEnabled']
for func in _initCallbacks:
func()
_initCallbacks = []
elif playerID != _api.playerID:
LOG_ERROR('VOIP.initialize failed: attempt to change player ID from {0} to {1}'.format(_api.playerID, playerID))
else:
_api._initialize()
def userPreferences():
doUtils = DownloadUtils()
addonSettings = xbmcaddon.Addon(id='plugin.video.emby')
userPreferencesPage = UserPreferences(
"script-emby-kodi-UserPreferences.xml",
addonSettings.getAddonInfo('path'), "default", "1080i")
url = "{server}/mediabrowser/Users/{UserId}"
result = doUtils.downloadUrl(url)
configuration = result[u'Configuration']
userPreferencesPage.setConfiguration(configuration)
userPreferencesPage.setName(result[u'Name'])
userPreferencesPage.setImage(API().getUserArtwork(result, "Primary"))
userPreferencesPage.doModal()
if userPreferencesPage.isSave():
url = "{server}/mediabrowser/Users/{UserId}/Configuration"
postdata = userPreferencesPage.getConfiguration()
doUtils.downloadUrl(url, postBody=postdata, type="POST")
class Root:
def __init__(self):
self.dal = DAL("../bin/settings.ini")
api = API(DAL("../bin/settings.ini"))
# Route("/")
@cherrypy.expose()
def index(self):
game_list_links = ""
game_list = self.dal.get_games()
for game in game_list:
game_list_links += "<a href='/gamecharacters/{id}'>{name}</a><br/>".format(
id=game["id"], name=game["name"])
game_list_links += "<a href='/add_page'>Add Data</a>"
return make_page("Select a game!", game_list_links)
# Route("/gamecharacters/{game_id}
@cherrypy.expose()
def gamecharacters(self, game_id):
game = self.dal.get_game(game_id)
page_title = game.name
return_str = """
<body class='{game_class}'>
<div id='root' class='root'></div>
<script>
var gameId = {game_id}
</script>
</body>
""".format(game_class=game.name.replace(" ", ""), game_id=game_id)
return make_page(page_title, return_str, react_page=True)
# Route("/add_page/")
@cherrypy.expose()
def add_page(self):
page_title = "Add Data"
body = """<div id="reactForm" />"""
return make_page(page_title, body, react_page=True)
def notify_difference(item, original_text):
print("#######################################")
print(f" {item.get_model()} STOCK ALERT ")
print(f" {time.ctime()}")
print(
f"Button has changed from {original_text} to {item.get_button_text()} for {item.get_name()}."
)
if "newegg" in item.get_url():
print(
f"Add it to your cart: https://secure.newegg.com/Shopping/AddToCart.aspx?ItemList={item.get_item_id()}&Submit=ADD&target=NEWEGGCART\n\n"
)
webbrowser.open_new(
f"https://secure.newegg.com/Shopping/AddToCart.aspx?ItemList={item.get_item_id()}&Submit=ADD&target=NEWEGGCART"
)
print(f"Current price: {item.get_price()}.")
print(f"Please visit {item.get_url()} for more information.")
webbrowser.open_new(item.get_url())
print("#######################################")
print("")
print("")
if Util.get_tweepy_enabled():
api = API()
auth = tweepy.OAuthHandler(api.get_api_key(), api.get_api_secret())
auth.set_access_token(api.get_access_token(),
api.get_access_token_secret())
api = tweepy.API(auth)
tweet = f"{item.get_model()} STOCK ALERT\n\n"
tweet += f"{item.get_name()[0:19].rstrip()}...\n"
tweet += f"{item.get_price()}\n\n"
if "newegg" in item.get_url():
tweet += f"Add to Cart: https://secure.newegg.com/Shopping/AddToCart.aspx?ItemList={item.get_item_id()}&Submit=ADD&target=NEWEGGCART\n\n"
tweet += f"More Info: {item.get_url()}"
try:
api.update_status(tweet)
except tweepy.error.TweepError as te:
if te.api_code == 187:
# duplicate tweet
pass
def setUserPref(self):
player = Player()
server = self.getServer()
userId = self.getUserId()
url = "{server}/mediabrowser/Users/{UserId}?format=json"
result = self.doUtils.downloadUrl(url)
# Set user image for skin display
self.WINDOW.setProperty("EmbyUserImage",
API().getUserArtwork(result, "Primary"))
# Load the resume point from Emby and set as setting
url = "{server}/mediabrowser/System/Configuration?format=json"
result = self.doUtils.downloadUrl(url)
utils.settings('markPlayed', value=str(result['MaxResumePct']))
return True
async def saveExpValues(self):
dt = Data()
api = API()
temp = api.expectedValues()
time = temp['time']
#print(temp)
out = []
def save(shipid, shipdata):
lst = []
lst.append(shipid)
#print(shipid) #this function takes a while so print ship ID's to keep us occupied. The dark is scary
#print(shipdata)
name = api.getShipName(shipid)
if name is None:
lst.append("None")
else:
lst.append(name)
if (len(shipdata) != 0):
lst.append(shipdata['average_damage_dealt'])
lst.append(shipdata['average_frags'])
lst.append(shipdata['win_rate'])
print(lst)
out.append(lst)
from concurrent.futures import ThreadPoolExecutor
executor = ThreadPoolExecutor(max_workers=5)
loop = asyncio.get_event_loop()
futures = [
loop.run_in_executor(executor, save, ship, data)
for ship, data in temp['data'].items()
]
await asyncio.wait(futures)
#print(out)
dt.write('wowsnumbers', (str(time) + '.csv').strip(), out)
return 0
def __init__(self,clan,name):
#TODO:get Player 'name' Data from WG API
api = API()
dt = Data()
self.playerName=name
self.playerID=api.getPlayerID(name)
#TODO:If directory playerclan/playername does not exist and contains no files, then pull data directly from wg api without saving (temp lookup)
temppath = str(str(clan).strip()+"/"+str(name).strip())
filestring = dt.getSMostRecent(temppath)
#print(filestring)
filestring = filestring.replace("'",'"')
filestring = filestring.replace("None",'0')
filestring = filestring.replace("False",'0')
#print(filestring)
#print(filestring[189])
lst = json.loads(filestring)
print(lst)
print()
stats = lst['statistics']
self.battles = stats['battles']
self.distance = stats['distance']
stats = stats['pvp']
for i in stats:
print(i)
print(stats[i])
for i in lst:
#print(str(i)+": "+str(lst[i]))
break
#print(lst['statistics'])
#print(Player.calcwr(self.wins,self.losses))
pass
def createEmbed(self, clantag, embed, start, end):
api = API()
d = Data()
u = Util()
players = api.getClanMembers(api.getClanID(clantag))
#print(players[start:])
templen = 0
if (end > len(players)):
end = len(players)
for i in players[start:end]:
name = api.getPlayerName(i)
bt = api.getPlayerBattles(i)
if (bt == 0):
break
rpath = str(clantag) + "/" + str(name)
#print(rpath)
temp = d.read(rpath, d.getMostRecent(rpath))
postname = api.getPlayerName(i) + " (ID: " + str(i) + ")"
cur = []
cur.append(u.round3(float(temp[2][0])))
cur.append(int(temp[3][0]))
cur.append(float(temp[4][0]))
cur.append(float(temp[5][0]))
cur.append(float(temp[6][0]))
wdelta = self.getWeekDeltas(rpath)
mdelta = self.getMonthDeltas(rpath)
ret = self.formatString(cur, wdelta, mdelta)
templen += len(ret)
#print(len(ret))
#print(ret)
embed.add_field(name=postname, value=ret, inline=False)
#print(templen)
return embed
