def __init__(self, base_url, browser, requestData):
self.utilities = utilities.Utilities()
self.base_url = base_url
#self.browser = browser
if browser == 'crhome':
self.driver = webdriver.Chrome('C:\chromedriver\chromedriver.exe')
elif browser == 'firefox':
self.driver = webdriver.Firefox()
else:
self.driver = webdriver.Ie('C:\IEDriverServer\IEDriverServer.exe')
self.driver.maximize_window()
self.username = "******"
self.password = "******"
self.requestData = requestData
#time.sleep(5)
self.utilities = utilities.Utilities()
print(
"********************* Interventor ************************************"
)
def main():
utils = utilities.Utilities()
lexiconFile = sys.argv[1]
morphRulesFile = sys.argv[2]
lexiconReader = open(lexiconFile)
morphRulesReader = open(morphRulesFile)
lexiconText = ''
lexiconLines = lexiconReader.readlines()
for i in range(0, len(lexiconLines)):
lexiconText = lexiconText + lexiconLines[i]
morphRulesText = ''
morphRulesLines = morphRulesReader.readlines()
for i in range(0, len(morphRulesLines)):
morphRulesText = morphRulesText + morphRulesLines[i]
# print lexiconText
fsaObj = fsa.Fsa()
fsaObj.parse(morphRulesText)
lexiconVals = utils.readLexicon(lexiconText)
fsaObj.parseLexicon(lexiconVals)
outputVar = fsaObj.processCarmelFormatExpandedOutput().strip()
print outputVar
def test_q3Testing(self):
utils = utilities.Utilities()
testStr = """spoke irreg_past_verb_form
spoken irreg_past_verb_form
speak irreg_verb_stem
"""
lexiconVals = utils.readLexicon(testStr)
fsaStr = """q3
(q0 (q3 irreg_past_verb_form))
(q0 (q2 irreg_verb_stem))
(q2 (q3 *e*))"""
fsaObj = fsa.Fsa()
fsaObj.parse(fsaStr)
# fsaObj.transitionStates:
# from: q0 to: q3 value:reg_verb_stem
fsaObj.parseLexicon(lexiconVals)
carmelFsa = fsaObj.processCarmelFormatExpandedOutput()
# print carmelFsa
fsaObj1 = fsa.Fsa()
fsaObj1.parse(carmelFsa)
result = fsaObj1.returnMorphedOutput("s p o k e n")
# print result
self.assertTrue(result == 'spoken/irreg_past_verb_form')
def test_correctProbabilitiesWithLambdas1(self):
# arrange
utils = utilities.Utilities()
rawSent = "Pierre/NNP Vinken/NNP ,/, 61/CD years/NNS old/JJ something/NNP cool/NNP here/VB"
sentence = utils.createTrigramTuplesFromStr(rawSent)
hmm = hiddenMarkovTrigram.HiddenMarkovTrigram(unknownProbFile)
hmm.addParsedLine(sentence)
lambda1 = 0.05
lambda2 = 0.8
lambda3 = 0.15
# act
result = hmm.getSmoothedTrigramProbability("NNP", "NNP", ",", lambda1,
lambda2, lambda3)
# assert
# print hmm.printHmmFormat(lambda1, lambda2, lambda3)
trigramProb = hmm.getTrigramProb("NNP", "NNP", ",")
bigramProb = hmm.getBigramProb("NNP", ",")
unigramProb = hmm.getUnigramProb(",")
expectedResult = lambda3 * trigramProb + lambda2 * bigramProb + lambda1 * unigramProb
self.assertTrue(result == expectedResult,
str(result) + " " + str(expectedResult))
def main():
utils = utilities.Utilities()
hmm = hiddenMarkovFactory.HiddenMarkovFactory()
hmmInputFile = sys.argv[1]
input_t = open(hmmInputFile)
t = input_t.readline()
while t:
hmm.readInput(t)
t = input_t.readline()
strBuilder = ''
firstLine = hmm.reportLineNumberDifference().strip()
secondLine = hmm.reportInitialProbabilities().strip()
thirdLine = hmm.reportTransProbabilities().strip()
fourthLine = hmm.reportEmissProbabilities().strip()
if firstLine != '':
print firstLine
if secondLine != '':
print secondLine
if thirdLine != '':
print thirdLine
if fourthLine != '':
print fourthLine
def __init__(self): #dataset type self.dataset_type = None #input csv file self.csv_description_path = None self.csv_description = None #output directory self.output_dir = None #point features to extract self.target_points_feature = None #cell features to extract self.target_cells_feature = None #Extraction info self.extraction_info=None #tfrecord info self.tfrecord_info = None #for classification datasets self.min_num_shapes_per_class=5 #utility functions self.util=utilities.Utilities()
def test_createsBigramTuplesEmissionsFromStr(self):
testSent = "John/N likes/V Mary/N"
utils = utilities.Utilities()
result = utils.createBigramTuplesFromStr(testSent)
self.assertTrue(4, len(result))
self.assertTrue(result[0][0].pos == "BOS", result[0][0].pos)
self.assertTrue(result[0][1].pos == "N")
self.assertTrue(result[0][0].word == "<s>", result[0][0].pos)
self.assertTrue(result[0][1].word == "John")
self.assertTrue(result[1][0].pos == "N")
self.assertTrue(result[1][1].pos == "V")
self.assertTrue(result[1][0].word == "John", result[0][0].pos)
self.assertTrue(result[1][1].word == "likes")
self.assertTrue(result[2][0].pos == "V")
self.assertTrue(result[2][1].pos == "N")
self.assertTrue(result[2][0].word == "likes", result[0][0].pos)
self.assertTrue(result[2][1].word == "Mary")
self.assertTrue(result[3][0].pos == "N")
self.assertTrue(result[3][1].pos == "EOS", result[3][1].pos)
self.assertTrue(result[3][0].word == "Mary", result[0][0].pos)
self.assertTrue(result[3][1].word == "</s>")
def __init__(self, base_url, browser, requestData):
self.utilities = utilities.Utilities()
self.base_url = base_url
self.requestData = requestData
self.base_url = "http://soporteargos.sdsline.com"
if browser == 'crhome':
self.driver = webdriver.Chrome('C:\chromedriver\chromedriver.exe')
elif browser == 'firefox':
self.driver = webdriver.Firefox()
else:
self.driver = webdriver.Ie('C:\IEDriverServer\IEDriverServer.exe')
self.driver.maximize_window()
if requestData["isZonaFranca"]:
self.password = "******"
self.username = "******"
else:
self.username = "******"
self.password = "******"
# los traslados van para almagran
if self.requestData[
'requestType'] == "Entrada de Elementos Trasladados":
self.username = "******"
self.password = "******"
print(
"********************* Guarda ************************************"
)
def test_firstThreeSentences(self):
# arrange
utils = utilities.Utilities()
sentence1 = utils.createBigramTuplesFromStr(
"Pierre/NNP Vinken/NNP ,/, 61/CD years/NNS old/JJ ,/, will/MD join/VB the/DT board/NN as/IN a/DT nonexecutive/JJ director/NN Nov./NNP 29/CD ./."
)
sentence2 = utils.createBigramTuplesFromStr(
"Mr./NNP Vinken/NNP is/VBZ chairman/NN of/IN Elsevier/NNP N.V./NNP ,/, the/DT Dutch/NNP publishing/VBG group/NN ./."
)
sentence3 = utils.createBigramTuplesFromStr(
"Rudolph/NNP Agnew/NNP ,/, 55/CD years/NNS old/JJ and/CC former/JJ chairman/NN of/IN Consolidated/NNP Gold/NNP Fields/NNP PLC/NNP ,/, was/VBD named/VBN a/DT nonexecutive/JJ director/NN of/IN this/DT British/JJ industrial/JJ conglomerate/NN ./."
)
hmm = hiddenMarkovBigram.HiddenMarkovBigram()
# act
hmm.addParsedLine(sentence1)
hmm.addParsedLine(sentence2)
hmm.addParsedLine(sentence3)
# assert emissions
# print hmm.printHmmFormat()
nnpDict = hmm.getEmissions("NNP")
inDict = hmm.getEmissions("IN")
nnpTotal = hmm.getDictTotal(nnpDict)
inTotal = hmm.getDictTotal(inDict)
self.assertTrue(nnpTotal == 14, str(nnpTotal))
self.assertTrue(inTotal == 4, str(inTotal))
def __init__(self):
self.endState = ""
self.startState = ""
self.epsilonState = "*e*"
self.transitionStates = []
self.expandedTransitionStates = []
self.utilities = utilities.Utilities()
self.internalTransitionStateIndex = 1
def generate_label(self, label=None, abbreviation=None):
"""Assign a name to this island automatically"""
abbr = abbreviation or self.abbreviation or str(self.number)
# TODO: dots should be added in the last instant when outputting any text
u = utilities.Utilities()
if u.is_upsidedown_wrong(abbr):
abbr += "."
self.label = label or self.label or "Island {}".format(self.number)
self.abbreviation = abbr
def test_createsUnkDict(self):
# arrange
testStr = """
NNP 0.555
TR 0.222
"""
utils = utilities.Utilities()
# act
testDict = utils.createUnkProbDict(testStr)
# assert
self.assertTrue(testDict["NNP"] == 0.555)
self.assertTrue(testDict["TR"] == 0.222)
def assert_transfer_request(self):
driver = self.driver
self.utilities = utilities.Utilities()
# Busca los datos de la solicitud y hace las comparaciones correspondientes
responsabledd = driver.find_element_by_xpath(
'//dl[dt[contains(text(),"Responsable")]]/dd').get_attribute(
'innerHTML').strip()
assert self.requestData['responsable'] in responsabledd
print("Comparados datos de solicitud")
# Hace las comparaciones con los elementos resultantes y los elementos guardados al momento de crear la solicitud
self.assert_elements()
def __init__(self, base_url, browser):
self.utilities = utilities.Utilities()
self.base_url = base_url
#self.browser = browser
if browser == 'crhome':
self.driver = webdriver.Chrome('C:\chromedriver\chromedriver.exe')
elif browser == 'firefox':
self.driver = webdriver.Firefox()
else:
self.driver = webdriver.Ie('C:\IEDriverServer\IEDriverServer.exe')
self.driver.maximize_window()
self.username = "******"
self.password = "******"
self.plantName = "CANTERA EL TRIUNFO"
self.zonaFrancaPlant = "PLANTA CEMENTOS CARTAGENA ZFA"
self.interventorName = 'Andrés Mauricio Gómez'
self.herramientas = [
"Allanadoras",
"Cortadoras de Pavimento",
"Placas Compactadoras",
"Mezcladoras",
"Rotomartillo",
"Carretillas y Ruedas",
"Carga y Levante",
"Bombas Hidraulicas",
"Compactadoras Hidraulicas",
"Esmeriladores Hidraulicos",
"Fuentes de Poder Hidraulico",
"Malacates",
"Mototaladros",
"Sierras Hidraulicas",
"Vibroapisonadores",
"Amoladora",
]
self.requestData = {
'elements': [],
}
print(
"********************* Tercero ************************************"
)
def test_createsTrigramTuplesFromStr(self):
testSent = "John/N likes/V Mary/N"
utils = utilities.Utilities()
result = utils.createTrigramTuplesFromStr(testSent)
self.assertTrue(2, len(result))
self.assertTrue(result[0][0].pos == "BOS", result[0][0].pos)
self.assertTrue(result[0][1].pos == "N")
self.assertTrue(result[0][2].pos == "V")
self.assertTrue(result[1][0].pos == "N")
self.assertTrue(result[1][1].pos == "V")
self.assertTrue(result[1][2].pos == "N")
def __init__(self, fromState, toState, value, props):
self.fromState = fromState
self.toState = toState
self.value = value
self.props = props
util = utilities.Utilities()
if (len(props) > 1):
self.output = util.cleanseInput(props[0])
self.weight = util.cleanseInput(props[1])
elif (len(props) > 0):
self.output = util.cleanseInput(props[0])
self.weight = 1
else:
self.output = None
self.weight = None
def test_firstSentence(self):
# arrange
utils = utilities.Utilities()
sentence1 = utils.createBigramTuplesFromStr(
"Pierre/NNP Vinken/NNP ,/, 61/CD years/NNS old/JJ ,/, will/MD join/VB the/DT board/NN as/IN a/DT nonexecutive/JJ director/NN Nov./NNP 29/CD ./."
)
hmm = hiddenMarkovBigram.HiddenMarkovBigram()
# act
hmm.addParsedLine(sentence1)
# assert
nnpNovProb = hmm.getEmissionProbability("NNP", "Nov.")
self.assertTrue(nnpNovProb == float(1) / 3)
nnpCdProb = hmm.getTransitionProbability("NNP", "CD")
self.assertTrue(nnpCdProb == float(1) / 3)
def test_addParsedLineResult(self):
# arrange
testSent = "John/N likes/V Mary/N"
utils = utilities.Utilities()
result = utils.createBigramTuplesFromStr(testSent)
hmm = hiddenMarkovBigram.HiddenMarkovBigram()
# act
hmm.addParsedLine(result)
# assert
self.assertTrue(hmm.init_line_num() == 1)
self.assertTrue(hmm.emiss_line_num() == 3)
self.assertTrue(hmm.trans_line_num() == 3)
self.assertTrue(hmm.state_num() == 3, str(hmm.state_num()))
self.assertTrue(hmm.sym_num() == 3, str(hmm.sym_num()))
def test_trigramExistsWithCorrectProbabilities(self):
# arrange
utils = utilities.Utilities()
rawSent = "Pierre/NNP Vinken/NNP ,/, 61/CD years/NNS old/JJ"
sentence = utils.createTrigramTuplesFromStr(rawSent)
hmm = hiddenMarkovTrigram.HiddenMarkovTrigram({})
# act
hmm.addParsedLine(sentence)
# assert
self.assertTrue(hmm.getTrigramProb("NNP", "NNP", ",") == 1)
self.assertTrue(hmm.getTrigramProb("NNP", ",", "CD") == 1)
self.assertTrue(hmm.getTrigramProb(",", "CD", "NNS") == 1)
self.assertTrue(hmm.getTrigramProb("CD", "NNS", "JJ") == 1)
def comp_cagr_benchmark_list(stockCode, date_bought_list, price, vol_list,
price_benchmark_on_date_bought, filename):
"""
Given stock, return the CAGR till now
Input
stockCode : e.g. ES3.SI
dateBought : e.g. "2014-05-23"
price : price of the stock now
vol_list : volume bought
price_benchmark_on_date_bought : price of benchmark on date bought
filename : filename of csv file which contains stock prices
Output
cagr : compound annual growth rate
"""
cagr_list = []
market_value = [price * i for i in vol_list]
tot = sum(market_value)
print("stockCode = " + str(stockCode))
print("date_bought_list = " + str(date_bought_list))
print("price = " + str(price))
print("vol_list = " + str(vol_list))
for i in range(len(date_bought_list)):
diff = datetime.now() - datetime.strptime(date_bought_list[i],
'%Y-%m-%d')
years = diff.days / 365.0
stk = ut.Utilities(stockCode)
# e.g. [{'Volume': '117000', 'Symbol': 'ES3.SI', 'Adj_Close': '3.11', 'High': '3.32', 'Low': '3.31', 'Date': '2014-05-23', 'Close': '3.31', 'Open': '3.31'}]
try:
# stk_dict = stk.get_historical(date_bought_list[i], date_bought_list[i])
# print 'stk_dict = ' + str(stk_dict)
# starting_value = float(stk_dict[0]['Adj_Close'])
starting_value = price_benchmark_on_date_bought[i]
ending_value = float(stk.get_price_csv(filename))
cagr = market_value[i] / tot * (
(float(ending_value) / starting_value)**(1 / float(years)) -
1) * 100
cagr_list.append(cagr)
except:
cagr_list.append(float("inf"))
return sum(cagr_list)
def shell(self):
while True:
self.socket.send(">>")
input = self.socket.recv(2048).strip().split()
if (input == []):
continue
elif (input[0] == 'q'):
break
elif (input[0] == 'bin'):
self.socket.send("bin(\'" + input[1].strip() + "\') = " + str(
int(''.join(format(ord(x), 'b')
for x in input[1].strip()), 2)) + "\n")
elif (input[0] == 'pow'):
self.socket.send(str(int(input[1])**int(input[2])) + "\n")
elif (input[0] == 'inverse'):
u = utilities.Utilities()
self.socket.send(
str(u.inverse(int(input[1]), int(input[2]))) + "\n")
elif (input[0] == 'gcd'):
self.socket.send(str(gcd(int(input[1]), int(input[2]))) + "\n")
elif (input[0] == 'mul'):
self.socket.send(str(int(input[1]) * int(input[2])) + "\n")
def track(img, imgHSV, colorRange): """ Tracks the biggest blob of the given color and returns its bounding-box coordinates and dimensions. Args: img: The image to track blob in. imgHSV: The image converted to HSV color space. colorRange: List of lower and upper ranges of color to track. Yields: List: A list of coordinates and dimensions of the blob's bounding-box in pixels, in the format [x-coord, y-coord, width, height] """ # Object for Utilities class that has smoothening functions utils = utilities.Utilities() # Color Ranges lower = colorRange[LOWER] upper = colorRange[UPPER] # Create a Mask mask = cv2.inRange(imgHSV, lower, upper) resMasked = cv2.bitwise_and(img, img, mask=mask) # Convert to Grayscale resGray = cv2.cvtColor(resMasked, cv2.COLOR_BGR2GRAY) # and threshold ret, thresh = cv2.threshold(resGray, 0, 255, cv2.THRESH_BINARY) boundingPoints = [] contours, hierarchy = cv2.findContours(thresh, 1, 2) if(len(contours) > 0): largestContour = utils.getLargestContour(contours) x, y, w, h = cv2.boundingRect(largestContour) boundingPoints = [x, y, w, h] return boundingPoints
def test_printOutFeature(self):
# arrange
testSent = "John/N likes/V Mary/N"
utils = utilities.Utilities()
result = utils.createBigramTuplesFromStr(testSent)
hmm = hiddenMarkovBigram.HiddenMarkovBigram()
hmm.addParsedLine(result)
# act
printStr = hmm.printHmmFormat()
# assert
expectedResult = """state_num=3
sym_num=3
init_line_num=1
trans_line_num=3
emiss_line_num=3
\init
BOS\t1.0\t0.0
\\transition
V\tN\t1.0\t0.0
BOS\tN\t1.0\t0.0
N\tV\t0.5\t-0.301029995664
\emissions
V\tlikes\t1.0\t0.0
N\tJohn\t0.5\t-0.301029995664
N\tMary\t0.5\t-0.301029995664
"""
self.assertTrue(
str(len(printStr)) == str(len(expectedResult)),
str(len(printStr)) + "-" + str(len(expectedResult)))
def main():
utils = utilities.Utilities()
fsm = sys.argv[1]
word_list = sys.argv[2]
fsmReader = open(fsm)
fsmText = ''
fsmLines = fsmReader.readlines()
for i in range(0, len(fsmLines)):
fsmText = fsmText + fsmLines[i]
fsaObj = fsa.Fsa()
fsaObj.parse(fsmText.strip())
wordListReader = open(word_list)
wordListText = ''
wordListLines = wordListReader.readlines()
strBuilder = ''
for i in range(0, len(wordListLines)):
word = wordListLines[i].strip()
if (word == ''):
continue
spaceDelimitedWord = ''
for j in range(0, len(word)):
spaceDelimitedWord = spaceDelimitedWord + word[j] + " "
result = fsaObj.returnMorphedOutput(spaceDelimitedWord)
strBuilder = strBuilder + word + ' => ' + result + '\n'
print strBuilder.strip()
def test_unigramsExistWithCorrectProbabilities(self):
# arrange
utils = utilities.Utilities()
rawSent = "Pierre/NNP Vinken/NNP ,/, 61/CD years/NNS old/JJ"
sentence = utils.createTrigramTuplesFromStr(rawSent)
hmm = hiddenMarkovTrigram.HiddenMarkovTrigram({})
# act
hmm.addParsedLine(sentence)
# assert - make sure that items exist in the proper dictionaries
self.assertTrue(hmm.unigramTransitionDictionary["NNP"] == 2)
self.assertTrue(hmm.unigramTransitionDictionary[","] == 1)
self.assertTrue(hmm.unigramTransitionDictionary["CD"] == 1)
self.assertTrue(hmm.unigramTransitionDictionary["NNS"] == 1)
self.assertTrue(hmm.unigramTransitionDictionary["JJ"] == 1)
self.assertTrue(hmm.getUnigramProb("NNP") == 2 / float(7))
self.assertTrue(hmm.getUnigramProb(",") == 1 / float(7))
self.assertTrue(hmm.getUnigramProb("CD") == 1 / float(7))
self.assertTrue(hmm.getUnigramProb("NNS") == 1 / float(7))
self.assertTrue(hmm.getUnigramProb("JJ") == 1 / float(7))
def main():
utils = utilities.Utilities()
lambda1 = float(sys.argv[1])
lambda2 = float(sys.argv[2])
lambda3 = float(sys.argv[3])
unknownFileTxt = ''
unknownFile = sys.argv[4]
input_t = open(unknownFile)
t = input_t.readline()
while t:
unknownFileTxt = unknownFileTxt + t
t = input_t.readline()
unknownTagDict = utils.createUnkProbDict(unknownFileTxt)
hmm = hiddenMarkovTrigram.HiddenMarkovTrigram(unknownTagDict)
for line in sys.stdin:
tr = utils.createTrigramTuplesFromStr(line)
hmm.addParsedLine(tr)
print hmm.printHmmFormat(lambda1, lambda2, lambda3)
def __init__(self, base_url, browser, ingressRequestData):
self.utilities = utilities.Utilities()
self.base_url = base_url
#self.browser = browser
if browser == 'crhome':
self.driver = webdriver.Chrome('C:\chromedriver\chromedriver.exe')
elif browser == 'firefox':
self.driver = webdriver.Firefox()
else:
self.driver = webdriver.Ie('C:\IEDriverServer\IEDriverServer.exe')
self.driver.maximize_window()
self.username = "******"
self.password = "******"
self.interventorName = 'Andrés Mauricio Gómez'
self.requestId = ingressRequestData['requestId']
self.requestData = ingressRequestData
print(
"********************* Tercero ************************************"
)
import mathutils as M
import bpy
if __package__ is None or __package__ == '':
# uses current directory visibility
import stickers
import unfold
import utilities
else:
# uses current package visibility
from . import stickers
from . import unfold
from . import utilities
from itertools import chain, repeat, product, combinations
u = utilities.Utilities()
class Mesh:
"""Wrapper for Bpy Mesh"""
def __init__(self, bmesh, matrix, stobj):
self.data = bmesh
self.matrix = matrix.to_3x3()
self.looptex = bmesh.loops.layers.uv.new("Unfolded")
self.edges = {bmedge: stickers.Edge(bmedge) for bmedge in bmesh.edges}
self.islands = list()
self.pages = list()
self.s = stobj
for edge in self.edges.values():
edge.choose_main_faces()
if edge.main_faces:
edge.calculate_angle()
def plot(filename):
""" Read data from specified CSV file and plot a graph for it based on
specified flags.
Args:
filename: Name of CSV file to read from.
"""
try:
csvFile = open(filename, "rt")
reader = csv.reader(csvFile)
except:
print "*** File Not Found ***"
return -1
utils = utilities.Utilities()
timeList = [-1]
# Dictionary containing list of x and y coordinates for each color.
xDict = {}
yDict = {}
relDict = {}
# List of x and y coordinates for reference point
xRef = []
yRef = []
# Initialize the Dictionaries
for colorName in colorsToGraph:
xDict[colorName] = []
yDict[colorName] = []
xDict['reference'] = []
yDict['reference'] = []
rowNum = 0
for row in reader:
if rowNum != 0:
if timeList[-1] is not int(row[0]):
timeList.append(int(row[0]))
xDict[row[3]].append(int(row[1]))
yDict[row[3]].append(int(row[2]))
rowNum += 1
# Remove the "reference" Data
xRef = xDict.pop("reference", [])
yRef = yDict.pop("reference", [])
timeList = timeList[1:]
if PLOT_REL:
relDict = calculateRel(xDict, yDict, xRef, yRef)
# PLOT!
for colorKey in xDict:
try:
if PLOT_X:
if APPLY_SMOOTH:
xDict[colorKey] = utils.triangularSmooth(xDict[colorKey])
plt.plot(timeList, xDict[colorKey], (colorKey[0]+'-'))
if PLOT_Y:
if APPLY_SMOOTH:
yDict[colorKey] = utils.triangularSmooth(yDict[colorKey])
plt.plot(timeList, yDict[colorKey], (colorKey[0]+'+'))
if PLOT_REL:
if APPLY_SMOOTH:
relDict[colorKey]=utils.triangularSmooth(relDict[colorKey])
plt.plot(timeList, relDict[colorKey], (colorKey[0]+'.'))
except ValueError:
print "\n*** COLOR DOES NOT EXIST: " + colorKey + " ***\n"
except:
print "\n*** ERROR GRAPHING: " + colorKey + " ***\n"
plt.xlabel('Time/Frame')
plt.ylabel('Relative Dist.')
plt.show()
import datacontainer
import error
import utilities
# load config / google drive
dc = datacontainer.DataContainer()
keys = dc.keys
configs = dc.configs
stats = dc.stats
ds = dc.drive
# set up discord client
client = discord.Client()
# load utilities function
utils = utilities.Utilities(client, dc)
signal.signal(signal.SIGTERM, utils.sigterm_handler)
signal.signal(signal.SIGINT, utils.sigterm_handler)
# set global variables
isSleeping = False
rubyLock = True
# functions
async def addStamp(message, directory, filename, id=None):
config = configs['stamp']
print('Command: addStamp')
# if directory name same as command name, reject
if any(directory[0] in config['COMMANDS'] for config in configs.values()):
await client.send_message(
