def NREL_station_lookup(lat, lon, year, interval='60', utc='false'):
"""
Returns dataframe of NREL weather observations for the given latitude, longitude, and year
:param float lat: lat to lookup weather data on
:param float lon: lon to lookup weather data on
:param integer year: year to look date up in
:param string interval: 30 or 60 intervals for weather observations (string to fit in url)
:param string utc: TRUE/FALSE to convert observations to UTC (string to fit in url)
:return: dataframe of NREL weather observations for that year
:rtype: dataframe
"""
cred = Credentials.Credentials()
leap_year = is_leap_year(year)
# According to site pressure could also be added but was unable to work it out
# https://nsrdb.nrel.gov/data-sets/api-instructions.html
attributes = 'wind_speed,air_temperature,solar_zenith_angle,wind_direction,dew_point,relative_humidity'
attributes = 'ghi,dhi,dni,wind_speed,air_temperature,solar_zenith_angle,wind_direction,dew_point,relative_humidity'
api_key = cred.api_key()
your_name = cred.your_name()
reason_for_use = cred.reason_for_use()
your_affiliation = cred.your_affiliation()
your_email = cred.your_email()
mailing_list = cred.mailing_list()
url = 'https://developer.nrel.gov/api/nsrdb/v2/solar/psm3-download.csv?wkt=POINT({lon}%20{lat})&names={year}&leap_day={leap}&interval={interval}&utc={utc}&full_name={name}&email={email}&affiliation={affiliation}&mailing_list={mailing_list}&reason={reason}&api_key={api}&attributes={attr}'.format(
year=year,
lat=lat,
lon=lon,
leap=leap_year,
interval=interval,
utc=utc,
name=your_name,
email=your_email,
mailing_list=mailing_list,
affiliation=your_affiliation,
reason=reason_for_use,
api=api_key,
attr=attributes)
dftemp = pd.read_csv(url, skiprows=2)
dftemp['Wind Speed'] = dftemp[
'Wind Speed'] * 2.236936 # Convert wind speed from m/s to mph
dftemp['lat'] = lat
dftemp['lon'] = lon
# Set the time index in the pandas dataframe:
dftemp = dftemp.set_index(
pd.date_range('1/1/{yr}'.format(yr=year),
freq=interval + 'Min',
periods=525600 / int(interval)))
return dftemp
def __init__(self, coms, master=None):
super().__init__(master)
# initializing the gui window
self.coms = coms
self.width = 1000
self.height = 700
master.geometry("" + str(self.width) + "x" + str(self.height))
master.title("Pacemaker Control Center")
self.pack()
self.master = master
self.create_login()
self.creds = Credentials()
def connect(self, given_password):
# type: (Optional[str]) -> None
if not given_password:
creds = Credentials(self.account_key, self.username, None)
try:
stored_access_token = self.get_credentials(creds)
except Exception as e:
print(e)
raise Exception("For user %s: Password not provided and not found in keyring" % self.username)
self.connection = teslajson.Connection(email=self.username, access_token=stored_access_token)
else:
self.connection = teslajson.Connection(email=self.username, password=given_password)
def test_that_user_can_create_an_account_with_valid_data(self):
driver = self.driver
driver.get(URL)
time.sleep(5)
register = HomePage(driver)
register.accept_agreement()
register.select_signup()
time.sleep(5)
register.enter_email_to_register(email=Credentials.random_char(7)+"@gmail.com")
register.enter_password_to_register(password=Credentials.password)
register.verify_password_entered(password=Credentials.password)
register.accept_condition()
register.register()
time.sleep(10)
MyAccount = MyAccountPage(driver)
text = MyAccount.get_my_account_text()
if text == 'MIJN ACCOUNT':
print("User registered successfully")
time.sleep(10)
def __init__(self,
hostname='10.128.0.7',
credentials='cred.yml',
db='bubbles',
port=49162):
self.hostname = hostname
self.cred = Credentials(credentials).get()
self.db = db
self.port = port
#Create Connection information
conn_url = {
'drivername': 'postgres',
'username': self.cred['user'],
'password': self.cred['password'],
'host': self.hostname,
'port': self.port,
'database': self.db
}
self.eng = create_engine(URL(**conn_url), client_encoding='utf8')
self.meta = MetaData(bind=self.eng, reflect=True)
class Imap:
creds = Credentials.Credentials()
def init(self):
pass
def checkAccount(self, email, pw):
con = Imap.creds.getConnectionInfo(email)
if (con == False):
print(Fore.RED + "[!]\tNo connection data in connections.json!" + Style.RESET_ALL + "\n")
else:
print("[!]\tTesting Imap connection: " + con['host'] + " ...")
c = None
# print(con['host'])
try:
c = imaplib.IMAP4_SSL(con['host'])
#5 second timeout
# socket.setdefaulttimeout(5)
c.login(email, pw)
print(Style.BRIGHT + Fore.GREEN + "[+]\tSuccess!" + Style.RESET_ALL + "\n")
return True
except imaplib.IMAP4.abort as e:
print(Style.BRIGHT + Fore.YELLOW + "[-]\tIMAP Aborted: " + str(e) + Style.RESET_ALL + "\n")
except imaplib.IMAP4.error as ie:
print(Style.BRIGHT + Fore.RED + "[-]\tIMAP Error: " + str(ie) + Style.RESET_ALL + "\n")
except Exception as e:
print(Style.BRIGHT + Fore.RED + "[-]\tFail: " + str(e) + Style.RESET_ALL + "\n")
print traceback.format_exc()
finally:
if (c is not None):
c.logout()
return False
def test_that_registered_user_can_add_a_new_address(self):
driver = self.driver
driver.get(URL)
time.sleep(5)
register = HomePage(driver)
register.accept_agreement()
register.select_signup()
time.sleep(5)
email = Credentials.random_char(7)+"@gmail.com"
password = Credentials.password
register.enter_email_to_register(email)
register.enter_password_to_register(password)
register.verify_password_entered(password)
register.accept_condition()
register.register()
MyAccount = MyAccountPage(driver)
time.sleep(15)
MyAccount.go_to_address_book()
time.sleep(10)
MyAccount.add_new_address()
time.sleep(10)
MyAccount.enter_first_name(fname=Credentials.fName)
MyAccount.enter_last_name(lname=Credentials.lName)
MyAccount.enter_street(street=Credentials.street)
MyAccount.enter_house_number(house_number=Credentials.houseno)
MyAccount.enter_city(city=Credentials.city)
MyAccount.enter_zip_code(zip=Credentials.zip)
MyAccount.save_address()
time.sleep(10)
#After hitting save, the My Account page loaded with given address details, in this page title = My Account and sub title is addressbook
title = MyAccount.get_my_account_text()
sub_title = MyAccount.get_address_as_subtitle()
if title == 'MIJN ACCOUNT' and sub_title == 'ADRESBOEK':
print('address added successfully by newly registered user')
time.sleep(10)
import Credentials
youtube = Credentials.run()
def add_playlist(youtube, title, description=None, privacyStatus='private'):
body = dict(snippet=dict(title=title, description=None),
status=dict(privacyStatus='private'))
try:
playlists_insert_response = youtube.playlists().insert(
part='snippet,status', body=body).execute()
except:
print("CreatePlaylist Error")
return None
print('New playlist Name: %s' % title)
print('New playlist ID: %s' % playlists_insert_response['id'])
return playlists_insert_response['id']
def run(youtube, title, privacy):
playlistID = []
for index in range(len(title)):
playlistID = add_playlist(youtube, title[index], privacy)
return playlistID
import Credentials
import State
import pprint
from json import loads, dumps
from watson_developer_cloud import PersonalityInsightsV3 as PIV3
from watson_developer_cloud.personality_insights_v3 import Content
service = PIV3(version='2017-10-13', iam_apikey=Credentials.watsonKey(),
url='https://gateway.watsonplatform.net/personality-insights/api')
def analisarTexto():
texto = 'Just arrived in the United Kingdom. The only problem is that @CNN is the primary source of news available from the U.S. After watching it for a short while, I turned it off. All negative & so much Fake News, very bad for U.S. Big ratings drop. Why doesn’t owner @ATT do something? London part of trip is going really well. The Queen and the entire Royal family have been fantastic. The relationship with the United Kingdom is very strong. Tremendous crowds of well wishers and people that love our Country. Haven’t seen any protests yet, but I’m sure the Fake News will be working hard to find them. Great love all around.Also, big Trade Deal is possible once U.K. gets rid of the shackles. Already starting to talk!'
#texto = State.load()
#json content_type='application/json'
profile = service.profile(texto, content_type='text/plain;charset=utf-8', raw_scores=True,
consumption_preferences=False, accept_language='pt-br').get_result()
pprint.pprint(profile)
State.save(profile)
def run(self):
self.done = False
print "Welcome! Type '/quit' to exit or '/help' for assistance."
print "Login/sign-up below:\n"
while True:
tempUser = raw_input("Please enter a username: "******"InvalidUsername"] +
"\n").strip()
if tempUser == "/quit":
self.quit()
elif tempUser == "/help":
print self.helpText
continue
tempPass = raw_input(
"Please enter your password, if your account does not exist, you will be prompted to sign up: "
+ self.credential_errors["InvalidPassword"] + "\n").strip()
if tempPass == "/quit":
self.quit()
elif tempPass == "/help":
print self.helpText
continue
try:
self.userId = self.wrapper.login(tempUser, tempPass)
print "Login complete!"
break
except (invalidCredentialsException, parametersMissingException,
ServerWrapperException) as ex:
if type(ex) == invalidCredentialsException:
print self.credential_errors["Invalid_pairing"]
elif type(ex) == parametersMissingException:
print self.credential_errors["ParametersMissing"]
else:
print "Error occured while trying to perform operation"
while True:
response = raw_input(
"Press 's' to sign up as a new user with the credentials you enetered or press any key to retry login\n"
).strip()
if response == 's':
print "Beginnng sign up process..."
try:
self.userId = self.wrapper.signup(
tempUser, tempPass)
print "Sign up complete, you are now logged in"
self.done = True
break
except (duplicateUsernameException,
invalidUsernameException,
invalidPasswordException,
parametersMissingException,
ServerWrapperException) as exx:
if type(ex) == duplicateUsernameException:
print self.credential_errors[
"DuplicateUsername"]
elif type(ex) == invalidUsernameException:
print self.credential_errors["InvalidUsername"]
elif type(ex) == invalidPasswordException:
print self.credential_errors["InvalidPassword"]
elif type(ex) == ServerWrapperException:
print "Error occured while trying to perform operation"
else:
print self.credential_errors[
"ParametersMissing"]
elif response == "/quit":
self.quit()
elif response == "/help":
print self.helpText
continue
else:
break
if self.done:
break
print self.helpText
print "This guide can be accessed again with the /help command\n"
self.cred = Credentials(self.userId, tempPass)
self.chat = Chat(self.cred, self.wrapper)
self.chat.run()
def main():
data_df = pd.read_csv("companies_list.csv")
cred = CD.Credentials()
accessToken = cred.getAccessToken()
counter = 1
row_count = 0
searchCriteria = SC.SearchCriteria(accessToken)
dataConnection = DC.DataConnection(accessToken)
folderName = str(time.strftime("%d%m%Y_%H%M%S"))
os.makedirs(folderName)
print("Data is being stored in the " + folderName + " folder")
path_list = []
for index, row in data_df.iterrows():
if counter + 71 <= 1000:
timer = random.randrange(5, 60, 1)
duns_list = searchCriteria.getDunsNumber(row["searchTerm"],
row["countryCode"])
counter += 1
#time.sleep(timer)
for duns in duns_list:
api_retrived_data = dataConnection.AASMCU(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName + "/AASMCU.txt").write(
api_retrived_data, duns, "AASMCU")
if path not in path_list:
if path is not None:
path_list.append(path)
api_retrived_data = dataConnection.AASDHQ(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName + "/AASDHQ.txt").write(
api_retrived_data, duns, "AASDHQ")
if path not in path_list:
if path is not None:
path_list.append(path)
api_retrived_data = dataConnection.LNKALT(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName + "/LNKALT.txt").write(
api_retrived_data, duns, "LNKALT")
if path not in path_list:
if path is not None:
path_list.append(path)
api_retrived_data = dataConnection.LNKUPD(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName + "/LNKUPD.txt").write(
api_retrived_data, duns, "LNKUPD")
if path not in path_list:
if path is not None:
path_list.append(path)
api_retrived_data = dataConnection.CMPELK(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName + "/CMPELK.txt").write(
api_retrived_data, duns, "CMPELK")
if path not in path_list:
if path is not None:
path_list.append(path)
if row["countryCode"] == "US":
api_retrived_data = dataConnection.AASBIG(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName +
"/AASBIG.txt").write(
api_retrived_data, duns,
"AASBIG")
if path not in path_list:
if path is not None:
path_list.append(path)
api_retrived_data = dataConnection.LNKMIN(duns)
counter += 1
#time.sleep(timer)
path = JFW.JsonFileWriter(folderName +
"/LNKMIN.txt").write(
api_retrived_data, duns,
"LNKMIN")
if path not in path_list:
if path is not None:
path_list.append(path)
row_count = row_count + 1
fileCloser(path_list)
data_df[0:row_count].to_csv("completed_list.csv")
data_df[row_count:].to_csv("companies_list.csv")
def __parseCSV(self):
c = None
cred = Credentials.Credentials()
try:
pprint(self.app.pargs)
# if tor flag isset will attempt to connect
if (self.app.pargs.tor):
self.tor.connect(self.app.pargs.torport)
lines = 0
c = open(self.app.pargs.csv)
ch = csv.reader(c)
# lines = int(len(list(ch)))
# if (self.app.pargs.verbose):
# print("[!] Total Lines: %u" % lines)
#default email/password columns
emailCol = 0
passwdCol = 1
hasHeader = True
# gets some basic info about file to properly parse file
firstLineHeader = raw_input(
"[?] Does the first row contain column titles? [Y/n]: ")
if (firstLineHeader.upper() == 'N'):
hasHeader = False
lines -= 1
emailCol = int(
raw_input(
"[?] Enter column number of email login. 0 equals column A. [0]: "
) or emailCol)
passwdCol = int(
raw_input("[?] Enter column number of passwords [1]: ")
or passwdCol)
o = Output.Output()
if (self.app.pargs.output is not None):
# print("OUTPUT:" + self.app.pargs.output)
oFile = o.createFile(self.app.pargs.output)
for k, r in enumerate(ch):
if (k == 0 and hasHeader == True):
if (self.app.pargs.verbose):
print("\n[!] Skipping header row")
continue
email = cred.checkEmail(r[emailCol])
pw = cred.checkPassword(r[passwdCol])
if (email == False):
print("[-] Not a valid email address... skipping.")
continue
if (pw == False):
print(Fore.RED + "[-] " + email +
": Password is empty... skipping." +
Style.RESET_ALL + "\n")
continue
print(Style.BRIGHT + "[" + str(k + 1) + "] Checking: " +
email + ":" + pw + Style.RESET_ALL)
if (self.app.pargs.imap):
validImap = self.imap.checkAccount(email, pw)
if (validImap == True
and self.app.pargs.output is not None):
o.addRow(email, pw)
# if valid login and saving success result - will add csv row
if (self.app.pargs.pop):
print("POP not currently supported")
# if delay is set
# print('DELAY:' + self.app.pargs.delay)
if float(self.app.pargs.delay or 0.5) > 0:
sleep(float(self.app.pargs.delay or 0.5))
except ValueError:
print(Style.BRIGHT + Fore.RED + "[-] Invalid input value: " +
str(e) + Style.RESET_ALL)
except Exception as e:
print(Style.BRIGHT + Fore.RED + "[-] Error parsing CSV File: " +
str(e) + Style.RESET_ALL)
print traceback.format_exc()
finally:
c.close()
# if tor flag is set, will disconnect before exiting
if (self.app.pargs.tor):
baseController.tor.disconnect()
print("\n" + Style.BRIGHT + "[*] Finished. Exiting!" +
Style.RESET_ALL + "\n")
return True
# Show how many tweets have been stored
self.tweetsStored += 1
print('Tweets stored: ' + str(self.tweetsStored))
# Check if time limit has been surpassed
current_time = time.time()
has_duration_ended = (current_time - self.start_time) > self.duration
# Returning false will stop collection of tweets
return not has_duration_ended
def on_error(self, status_code):
print status_code
return False
if __name__ == '__main__':
credentials_Location = "TwitterAPICredentials.json"
auth = Credentials.getAuthentication(credentials_Location)
output_location = 'tweets.db'
streaming_duration = input('How many seconds would you like to collect Tweets for? ')
myStreamListener = SQLDurationStreamListener(streaming_duration, output_location.strip())
myStream = tweepy.Stream(auth, myStreamListener)
try:
myStream.filter(track=['python'])
except KeyboardInterrupt:
pass
print_db_values(output_location, 'tweets')
def main(topic_list, conf_matrix, save_master_data):
skill_list = process_list_argument(topic_list, val_type=str)
master_skill_id = None # so exception works
master_thresh = Credentials.calculate_workspace_thresh("master")
try:
id_dict = {
skill: Credentials.workspace_id[active_adoption][skill]
for skill in skill_list
}
timestr = generate_timestamp() # for use in all filenames
# authenticate
if "apikey" in instance_creds:
logger.debug("Authenticating (apikey)")
bs = blindset.blindset(
apikey=instance_creds["apikey"],
url=instance_creds["url"],
version=conversation_version,
)
elif "password" in instance_creds:
logger.debug("Authenticating (username/password)")
bs = blindset.blindset(
username=instance_creds["username"],
password=instance_creds["password"],
url=instance_creds["url"],
version=conversation_version,
)
# check skills exist
check_skills_exist(skill_list)
# import blindsets and generate master
logger.info("Importing all blindsets and combining into master")
blind_dict = dict()
for skill in skill_list:
bs_path = os.path.join(config.data_dir, f"{skill}_blindset.csv")
blind_dict[skill] = bs.import_blindset(bs_path)
master_blind_allcols = pd.concat(
[v.assign(topic=k) for k, v in blind_dict.items()],
axis=0,
ignore_index=True,
sort=False,
)
master_blind = master_blind_allcols[[
"utterance", "topic"
]].rename(columns={"topic": "expected intent"})
# generate master from topic training and push to WA
logger.info("Getting training data from WA")
train_dict = dict()
for skill in skill_list:
train_dict[skill] = wa_utils.get_training_data(
bs.assistant, id_dict[skill])
logger.info("Creating temporary master skill")
master_train = pd.concat(
[
v.drop(columns=["intent"]).assign(intent=k)
for k, v in train_dict.items()
],
axis=0,
ignore_index=True,
sort=False,
)
master_skill_id = wa_utils.create_workspace_from_df(
bs.assistant,
name="master",
train_df=master_train,
description="generated by intent_training_tools",
)
# run blindset on master
logger.info("Running blindset on master..")
results_master = bs.run_blind_test(master_blind,
master_skill_id,
threshold=master_thresh)
results_master["routing"] = results_master["intent1"]
results_master.loc[results_master["confidence1"] < master_thresh,
"routing"] = "anything_else"
# create blindsets for topics based on master results
newblind_dict = dict()
for skill in skill_list:
# blindset for each skill is made up of utterances that have landed in that skill for master
blind_utterances = results_master.loc[
(results_master["intent1"] == skill)
& (results_master["confidence1"] >= master_thresh),
"original_text", ].tolist()
newblind = master_blind_allcols[master_blind_allcols["utterance"].
isin(blind_utterances)].copy()
newblind.loc[newblind["topic"] != skill,
"expected intent"] = "anything_else"
newblind_dict[skill] = newblind[["utterance", "expected intent"
]].reset_index(drop=True)
# run blindsets on topics
logger.info("Running blindset on topic skills..")
results_dict = dict()
for skill in skill_list:
results_dict[skill] = bs.run_blind_test(
newblind_dict[skill],
id_dict[skill],
threshold=Credentials.calculate_workspace_thresh(skill),
)
# plot confusion matrices
if conf_matrix:
from conversation_test.confusionmatrix import ConfusionMatrix
conf_output_path = lambda s: os.path.join(
config.output_folder, f"{s}_multi_confmat_{timestr}.png")
# master
cfn = ConfusionMatrix(workspace_thresh=master_thresh)
cfn.create(results_master, fig_path=conf_output_path("master"))
# topics
for skill in skill_list:
cfn = ConfusionMatrix(workspace_thresh=Credentials.
calculate_workspace_thresh(skill))
cfn.create(results_dict[skill],
fig_path=conf_output_path(skill))
logger.info("Confusion matrix saved to results folder")
# calculate metrics
# master
met = Metrics(workspace_thresh=master_thresh)
metrics_master, _ = met.get_all_metrics(results_master,
detailed_results=True)
# topics
metrics_dict = dict()
res_with_conf_dict = dict()
for skill in skill_list:
met = Metrics(
workspace_thresh=Credentials.calculate_workspace_thresh(skill))
metrics_dict[skill], res_with_conf_dict[
skill] = met.get_all_metrics(results_dict[skill],
detailed_results=True)
# topics - create overall view as if it's a single skill
topics_res_with_conf = pd.concat(
[v for k, v in res_with_conf_dict.items()],
ignore_index=True,
sort=False)
results_master.loc[results_master["routing"] == "anything_else",
'confusion'] = 'FN'
topics_res_with_conf = topics_res_with_conf.append(
results_master,
ignore_index=True,
sort=False,
)
metrics_overall = met.calculate_metrics_per_intent(
topics_res_with_conf, detailed_results=True)
metrics_overall.loc[metrics_overall.index.isin(skill_list),
'threshold'] = master_thresh
metrics_overall = metrics_overall.rename(
index={s: s + ' - anything else'
for s in skill_list})
# export results
for skill in skill_list:
results_dict[skill].to_csv(
os.path.join(config.output_folder,
f"{skill}_multi_results_{timestr}.csv"),
index=None,
)
metrics_dict[skill].to_csv(
os.path.join(config.output_folder,
f"{skill}_multi_metrics_{timestr}.csv"))
results_master.to_csv(
os.path.join(config.output_folder,
f"master_multi_results_{timestr}.csv"),
index=None,
)
metrics_master.to_csv(
os.path.join(config.output_folder,
f"master_multi_metrics_{timestr}.csv"))
metrics_overall.to_csv(
os.path.join(config.output_folder,
f"overall_multi_metrics_{timestr}.csv"))
logger.info("Results and metrics saved to output folder")
if save_master_data:
# export master blindset with both intent and topic labels to CSV
master_blind_allcols.to_csv(
os.path.join(config.data_dir,
f"master_blindset_{timestr}.csv"),
index=None,
)
# export master training to CSV
master_train.to_csv(
os.path.join(config.data_dir,
f"master_training_{timestr}.csv"),
header=None,
index=None,
)
logger.info(
"Master blindset and training have also been saved to the data folder"
)
# delete master skill
logger.info("Deleting temporary master skill")
wa_utils.delete_workspace(bs.assistant, master_skill_id)
except Exception as e:
if master_skill_id is not None:
# make sure master deleted anyway
logger.info("Deleting temporary master skill before exit")
wa_utils.delete_workspace(bs.assistant, master_skill_id)
raise e
def __init__(self, params):
self.params = params
self.credentials = Credentials.Credentials(params["credentials"])
NBClassifier, bestCount_Vectorizer, best_tfidf, interestLabels = train(
trainingSet)
print()
print("Initiating Testing...")
print()
testClassifier(NBClassifier, testSet, bestCount_Vectorizer)
printMetrics(NBClassifier, best_tfidf, interestLabels, "NBClassifier")
print()
print("Starting Live tweets")
print("Press Control+C to exit...")
def on_status(self, status):
tweet = str(status.text).lower()
if any(i in tweet for i in targetWords):
preprocessedtweet = preprocess(tweet)
predictedlabel = predictInterest([preprocessedtweet], NBClassifier,
bestCount_Vectorizer)
print(tweet)
print(label[predictedlabel[0]])
def on_error(self, status_code):
if status_code == 420:
return False
auth = Credentials.authenticate()
twitterStream = Stream(auth, listener())
twitterStream.filter(locations=[-97.318268, 32.760717, -96.600723, 33.207095],
languages=["en"],
stall_warnings=True)
import spotipy.util as util
import spotipy
import time
import Credentials
scope = "user-read-currently-playing"
Credentials.SetCreditentials()
token = util.prompt_for_user_token(username='', scope=scope)
track = spotipy.Spotify(token).current_user_playing_track() #JSON to Dict
nameTrack = track['item']['name']
artistsTrack = track['item']['artists'][0]['name']
albumTrack = track['item']['album']['name']
progressTrack = track['progress_ms'] / 1000
durationTrack = track['item']['duration_ms'] / 1000
statusTrack = track['is_playing']
print(f"Nome: {nameTrack}")
print(f"Artista: {artistsTrack}")
print(f"Album: {albumTrack}")
print(f"Porcentagem já ouvida: {int((progressTrack/durationTrack)*100)}%")
def run_kfold(topic, no_folds, results_type, conf_matrix):
"""
Runs kfold test using credentials in ../Credentials.py
"""
# get credentials, import + export folders
import Credentials
active_adoption = Credentials.active_adoption
instance_creds = Credentials.ctx[active_adoption]
workspace_id = Credentials.workspace_id[active_adoption][topic]
workspace_thresh = Credentials.calculate_workspace_thresh(topic)
conversation_version = Credentials.conversation_version
# import + export folders
import config
import time
data_folder = config.data_dir
export_folder = config.output_folder
timestr = time.strftime("%Y%m%d-%H%M")
output_loc_results = os.path.join(
export_folder, "{}_kfold_results_raw_{}.csv".format(topic, timestr))
output_loc_metrics = os.path.join(
export_folder, "{}_kfold_results_metrics_{}.csv".format(topic, timestr))
output_loc_confmat = os.path.join(
export_folder, "{}_kfold_confmat_{}.png".format(topic, timestr))
# authenticate
if 'apikey' in instance_creds:
logger.debug("Authenticating (apikey)")
kf = kfoldtest(n_folds=no_folds, apikey=instance_creds['apikey'],
url=instance_creds['url'], threshold=workspace_thresh, version=conversation_version)
elif 'password' in instance_creds:
logger.debug("Authenticating (username/password)")
kf = kfoldtest(n_folds=no_folds, username=instance_creds['username'], password=instance_creds['password'], url=instance_creds['url'], threshold=workspace_thresh,
version=conversation_version)
# get train df from watson + check there are sufficient workspaces to run the test
train_df = kf.intent_df_from_watson(workspace_id)
kf.check_sufficient_workspaces()
# create folds in WA if above is true
folds = kf.create_folds(method='kfold')
kf.create_kfold_WA(folds)
available_flag = False
while available_flag == False:
logger.info("Checking workspaces..")
available_flag = kf.check_workspaces_status()
time.sleep(20)
# run kfold test
try:
results = kf.run_kfold_test(folds)
if (results_type == 'raw') or (results_type == 'all'):
results.to_csv(output_loc_results)
classification_report = kf.create_classification_report(results)
if (results_type == 'metrics') or (results_type == 'all'):
metrics = Metrics(workspace_thresh)
metric_df = metrics.get_all_metrics_CV(
results, fold_col='fold', detailed_results=False)
metric_df.to_csv(output_loc_metrics)
# TODO: confusion matrix
if conf_matrix:
from confusionmatrix import ConfusionMatrix
cfn = ConfusionMatrix(workspace_thresh=workspace_thresh)
cfn.create(results, fig_path=output_loc_confmat)
logger.info("Confusion matrix saved to {}".format(
output_loc_confmat))
finally:
# regardless of what happens above, delete the temporary workspaces before exiting
kf.delete_kfold_workspaces()
import Subnet
import NIC
import VirtualMachine
# Required Variables
GROUP_NAME = 'Python-Sachin'
LOCATION = 'southeastasia'
AVLSET_NAME = 'DemoAVSet'
PIP_NAME = 'DemoPIP'
VNET_NAME = 'DemoVNET'
SUBNET_NAME = 'DemoSubnet'
NIC_NAME = 'DemoNIC'
VM_NAME = 'DemoVM'
if __name__ == "__main__":
credentials = Credentials.get_credentials()
rg_client = ResourceManagementClient(credentials,
Credentials.SUBSCRIPTION_ID)
network_client = NetworkManagementClient(credentials,
Credentials.SUBSCRIPTION_ID)
compute_client = ComputeManagementClient(credentials,
Credentials.SUBSCRIPTION_ID)
print(ResourceGroup.create_resource_group(rg_client, GROUP_NAME, LOCATION))
print(
AvailabilitySet.create_availability_set(compute_client, GROUP_NAME,
LOCATION, AVLSET_NAME))
print(
PIP.create_public_ip_address(network_client, GROUP_NAME, LOCATION,
PIP_NAME))
print(
VirtualNetwork.create_virtual_network(network_client, GROUP_NAME,
noResults = 10;
return service.events().list(calendarId = calId,
timeMin = timeNow,
maxResults = noResults,
singleEvents = True,
q = queryText,
orderBy = 'startTime').execute()
def fetch_events():
calIds = calendar.getList('seminars');
events = [];
for item in calIds:
print "For calendarId: ", item;
q = generate_query(calId = item, queryText='Test');
events.extend(q.get('items', []));
if not events:
print 'No upcoming events found.';
for event in events:
start = event['start'].get('dateTime', event['start'].get('date'));
print start, event['summary'];
calendar = Calendar.Calendar();
credentials = Credentials.get_credentials();
service = build('calendar', 'v3', http=credentials.authorize(Http()))
print 'Getting the upcoming 10 events'
fetch_events()
def startfederation(self):
# logging.info('Starting')
if self.validateFields() == 1:
self.pb_start.setText('Working')
logging.info('Validating Fields')
#logging
#textBoxUpdater = updatetextbox.UpdatetextBox(self.te_log)
server1creds = ''
server2creds = ''
if self.cb_cup.isChecked():
logging.debug('Found server 1 credentials')
server1creds = Credentials.Credentials(self.le_appid1.text(),
self.le_apppw1.text(),
self.le_platid1.text(),
self.le_platpw1.text())
plat_tuple1 = server1creds._platid, server1creds._platpw
if self.cb_copy.isChecked():
logging.debug('Found server 2 credentials')
server2creds = server1creds
else:
if self.cb_cup.isChecked():
logging.debug('Copying Server 2 credentials from server 1')
server2creds = Credentials.Credentials(
self.le_appid2.text(), self.le_apppw2.text(),
self.le_platid2.text(), self.le_platpw2.text())
plat_tuple2 = server2creds._platid, server2creds._platpw
#self.log('server1creds')
#self.log(server1creds._appid)
#self.log(str(server1creds._apppw))
# self.log('startfederation')
hn1 = self.le_server1_hn.text()
ip1 = self.le_server1_ip.text()
dn1 = self.le_server1_dn.text()
hn2 = self.le_server2_hn.text()
ip2 = self.le_server2_ip.text()
dn2 = self.le_server2_dn.text()
dnsip = self.le_dns.text()
dbsecret = self.le_dialback.text(
) #needed since dbsecret is optional
if not dbsecret:
dbsecret = '1234'
logging.info("Using default dial back secret")
self.advancedTab = advancedTab.AdvancedTab(
dbsecret, self.cb_certs.isChecked(), self.cb_sasl1.isChecked(),
self.cb_sasl2.isChecked())
tlsoption = self.cb_tls.currentIndex()
worker1 = FedController.WorkerThread(ip1, tlsoption, 'r', hn1, dn1,
dnsip, server1creds,
self.advancedTab)
worker2 = FedController.WorkerThread(ip2, tlsoption, 'r', hn2, dn2,
dnsip, server2creds,
self.advancedTab)
if self.cb_tls.currentIndex() == 1 or self.cb_tls.currentIndex(
) == 2:
logging.info('inside if block tls enabled')
worker1.downloadCerts()
worker2.downloadCerts()
dnldir1 = worker1.downloaddir
dnldir2 = worker2.downloaddir
logging.info("Server 1 certs downloaded to " + str(dnldir1))
logging.info('Server 2 certs downloaded to ' + str(dnldir2))
uploader1 = uploadCerts.UploadCerts(ip1, 'xmpp', plat_tuple1,
dnldir2)
uploader2 = uploadCerts.UploadCerts(ip2, 'xmpp', plat_tuple2,
dnldir1)
else:
pass
class LazyLinkedIn(object):
driver = webdriver.Chrome(executable_path="C:\\Users\\Stratos\\Desktop\\LazyLinkedIn\\venv\\chromedriver.exe")
driver.implicitly_wait(4)
driver.maximize_window()
user = Credentials.User();
def login(self):
self.driver.get("https://www.linkedin.com")
usernameField = self.driver.find_element(By.XPATH, '//*[@id = "login-email"]')
passwordField = self.driver.find_element(By.XPATH, '//*[@id = "login-password"]')
usernameField.send_keys(self.user.username)
passwordField.send_keys(self.user.password)
passwordField.send_keys(Keys.RETURN)
return self
def jobs(self):
jobsButton = self.driver.find_element_by_id("jobs-tab-icon")
jobsButton.click()
jobName=self.driver.find_element(By.XPATH,"//input[contains(@id,'jobs-search-box-keyword-id')]")
jobLocation=self.driver.find_element(By.XPATH,"//input[contains(@id,'jobs-search-box-location')]")
time.sleep(1.2)
jobName.send_keys(self.user.job) #TODO FIND SOMETHING BETTER CAUSE THIS SUX
jobLocation.send_keys(self.user.location)
time.sleep(2)
jobLocation.send_keys(Keys.RETURN)
return self
def filters(self):
self.driver.find_element(By.XPATH,"//h3[contains(.,'LinkedIn Features')]").click()
self.driver.find_element(By.XPATH,"//label[contains(.,'"+self.user.linkedInFeature+"')]").click()
self.driver.find_element(By.XPATH,"//*[@id='linkedin-features-facet-values']//button[contains(.,'Apply')]").click()
self.driver.find_element(By.XPATH, "//h3[contains(.,'Experience')]").click()
self.driver.find_element(By.XPATH, "//label[contains(.,'" + self.user.experience+"')]").click()
self.driver.find_element(By.XPATH,"//*[@id='experience-level-facet-values']//button[contains(.,'Apply')]").click()
return self
def getJobList(self):
totalJobs=self.driver.find_element(By.XPATH,"//div[contains(.,'results') and contains(@class,'t-12')]").get_attribute("innerText")
return [totalJobs, self.driver.find_elements(By.XPATH,"//ul[contains(@class,'jobs-search-results__list')]/li")]
def parseThroughList(self,current=1):
self.currentPage=current
i = 0
#currentPage=1
time.sleep(2)
totalJobs= self.getJobList()[0]
list = self.getJobList()[1]
for x in list:
i = i + 1
print("vlepw doulia noumero:",i,"selida:",self.currentPage)
if(i==25):
self.currentPage+=1
print("paw selida:", self.currentPage)
self.driver.find_element(By.XPATH,"//button[contains(@aria-label,'Page "+str(self.currentPage)+"')]").click()
self.parseThroughList(self.currentPage)
try:
x.click()
except:
pass
try:
self.driver.find_element(By.XPATH,"//button[@class='jobs-apply-button--top-card artdeco-button--3 artdeco-button--primary jobs-apply-button artdeco-button ember-view']").click()
time.sleep(1)
except:
continue
try:
self.currentTabApplication()
except:
self.newTabApplication()
def currentTabApplication(self):
self.driver.find_element(By.XPATH,"//button[@class='jobs-apply-form__submit-button button-primary-large ']").click()
time.sleep(2)
self.driver.find_element(By.XPATH, "//button[@class='artdeco-dismiss']").click()
def newTabApplication(self):
self.driver.switch_to_window(self.driver.window_handles[1])
time.sleep(2)
self.driver.find_element(By.XPATH, "//button[contains(.,'Submit')]").click()
time.sleep(2)
self.driver.close()
time.sleep(2)
self.driver.switch_to_window(self.driver.window_handles[0])
time.sleep(3)
self.parseThroughList(self.currentPage)
import Credentials
from twilio import twiml
from twilio.rest import Client
from twilio.twiml.messaging_response import MessagingResponse
from flask import Flask, request, redirect
import openpyxl
from openpyxl import Workbook
account_sid = Credentials.get_sid()
auth_token = Credentials.get_auth()
path = Credentials.path
app = Flask(__name__)
def update_xl(message_body):
wb = openpyxl.load_workbook(path)
sheet = wb.active
lastRow = sheet.max_row
sheet.cell(column=1, row=lastRow + 1, value="{0}".format(message_body))
wb.save(filename=path)
@app.route("/sms", methods=['GET', 'POST'])
def sms_reply():
#Retrieve actual message
message_body = request.form['Body']
# -*- coding: utf-8 -*-
"""
Éditeur de Spyder
Ceci est un script temporaire.
"""
import time
import hashlib
from Credentials import *
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
cred = Credentials()
user_login = cred.get_login()
user_password = cred.get_password()
print(user_login)
browser = webdriver.Chrome(
executable_path=
"//10.12.100.48/HomeEtu/etudiants/vbrother/Desktop/BOTS/chromedriver_win32/chromedriver"
)
"""browser.get("https://cas.upf.pf/login?service=https%3A%2F%2Fent.upf.pf%2Findex.php%3Fauth")
username = browser.find_element_by_id("username").send_keys(user_login)
password = browser.find_element_by_id("password").send_keys(user_password + Keys.ENTER)
"""
browser.execute_script('''window.open("http://google.com","_blank");''')
browser.switch_to.window(browser.window_handles[1])
#
def run_blindset(topic, results_type, conf_matrix, blindset_name):
"""
Runs blindset test using credentials in ../Credentials.py
"""
# get credentials, import + export folders
import Credentials
active_adoption = Credentials.active_adoption
instance_creds = Credentials.ctx[active_adoption]
print(instance_creds)
print('print works')
workspace_id = Credentials.workspace_id[active_adoption][topic]
workspace_thresh = Credentials.calculate_workspace_thresh(topic)
conversation_version = Credentials.conversation_version
# import + export folders
import config
import time
data_folder = config.data_dir
export_folder = config.output_folder
timestr = time.strftime("%Y%m%d-%H%M")
blindset_name = blindset_name or topic + "_blindset.csv"
output_loc_results = os.path.join(
export_folder, "{}_results_raw_{}.csv".format(topic, timestr))
output_loc_metrics = os.path.join(
export_folder, "{}_results_metrics_{}.csv".format(topic, timestr))
output_loc_confmat = os.path.join(
export_folder, "{}_confmat_{}.png".format(topic, timestr))
# authenticate
if 'apikey' in instance_creds:
logger.debug("Authenticating (apikey)")
bs = blindset(apikey=instance_creds['apikey'],
url=instance_creds['url'],
threshold=workspace_thresh,
version=conversation_version)
elif 'password' in instance_creds:
logger.debug("Authenticating (username/password)")
bs = blindset(username=instance_creds['username'],
password=instance_creds['password'],
url=instance_creds['url'],
threshold=workspace_thresh,
version=conversation_version)
# run test
blindset_df = bs.import_blindset(os.path.join(data_folder, blindset_name))
# TODO: check blindset df
results = bs.run_blind_test(blindset_df, workspace_id)
# exports + metrics
if (results_type == 'raw') or (results_type == 'all'):
cols_export = [
col for col in results.columns.values if col != 'intent_correct'
]
results[cols_export].to_csv(output_loc_results, encoding='utf-8')
logger.info("Raw results exported to {}".format(output_loc_results))
if (results_type == 'metrics') or (results_type == 'all'):
met = Metrics(workspace_thresh)
metric_df, _ = met.get_all_metrics(results, detailed_results=True)
metric_df.to_csv(output_loc_metrics, encoding='utf-8')
logger.info(
"Metrics per intent exported to {}".format(output_loc_metrics))
# confusion matrix
if conf_matrix:
from confusionmatrix import ConfusionMatrix
cfn = ConfusionMatrix(workspace_thresh=workspace_thresh)
cfn.create(results, fig_path=output_loc_confmat)
#bs.plot_confusion_matrix(results, output_loc_confmat)
logger.info("Confusion matrix saved to {}".format(output_loc_confmat))
# print high-level metrics
overall_metrics = bs.calculate_overall_metrics(results,
av_method="weighted")
logger.info("Overall metrics for the workspace (weighted):")
logger.info(overall_metrics)