def __init__(self, filename, logger=None):
FileParser.__init__(self, filename) # Stations filename ("/apps/px/etc/stations.conf")
self.logger = logger # Logger Object
self.stations = {} # Indexed by header
self.printErrors = True #
self.type = 'INT' # Must be in ['CA', 'US', 'COLL', 'INT']
self.stationSearched = None # Station for which we want to find the more recent occurence
def display_deck_selector():
file = tk.filedialog.askopenfilename()
file_reader = FileParser(str(file))
cards = file_reader.create_deck()
deck = Deck(cards)
display_deck(deck, file_reader)
def __init__(self):
fileParser = FileParser()
self.__table = fileParser.parse("graph")
self.__maxSize = fileParser.getMax()
self.__price = []
self.__date = []
self.__range = 365
def extracte_token(dir):
for root, dirs, files in os.walk(dir):
for name in files:
if re.match(r'.*jack$', name):
file_src = os.path.join(root, name)
parser = FileParser(file_src)
parser.generate_token()
def __init__(self):
self.__parts = ["1", "2", "3"]
self.__optimizer = SqlOptimizer()
self.__rules = self.__optimizer.GetOptions()
self.__back = len(self.__rules) + 1
self.__fileParser = FileParser()
self.__fileParser.Parse("statistics.txt")
async def async_topPosts(self):
await asyncio.sleep(self.TOP_REFRESH_RATE)
while not self.gracefulExit:
startTime = time.time()
wasChanged = False
self.logger.info("Refreshing top 10 posts...")
topPosts = self.sr.top('day', limit=10)
for post in topPosts:
if not post.id in self.redditCache[3]:
wasChanged = True
self.redditCache[3].append(str(post.id))
postData = [
post.title, post.author.name, post.url, post.shortlink
]
if post.over_18:
postData.append('!')
if post.spoiler:
postData.append('?')
self.postQueue.put(postData)
l = len(self.redditCache[3])
if l >= 40:
self.redditCache[3] = self.redditCache[3][l - 30:]
if wasChanged:
FileParser.writeNestedList("redditcache.txt", self.redditCache,
'w')
endTime = time.time()
await asyncio.sleep(
self.checkTime(self.TOP_REFRESH_RATE, startTime - endTime,
"async_topPosts"))
def executeSimplePerceptron():
#fileParser = FileParser("./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_and_or.txt") #open from arguments
fileParser = FileParser("./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_ocr.txt") #open from arguments
#fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_test.txt') #open from arguments
#fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_test_with_testing_data.txt') #open from arguments
#fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_test_with_same_testing_data.txt') #open from arguments
#fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_martin.txt') #open from arguments
parameters = fileParser.parseInputFile()
#function = Exponential(0.5)
#function = Identity()
function = Sign()
VERBOSE = True
SHUFFLE_TRAINING_SET = True
neuralAlgorithm = SimplePerceptron(parameters, function, not SHUFFLE_TRAINING_SET, VERBOSE)
print 'ALGORITHM - Start'
neuralAlgorithm.train()
print 'ALGORITHM - Finish'
trainingInformation = neuralAlgorithm.getTrainingInformation()
errorFileName = './/..//graphics//error - ' + parameters.objective
validationFileName = './/..//graphics//validation - ' + parameters.objective
testingFileName = './/..//graphics//testing - ' + parameters.objective
SAVE_TO_FILE = True
SHOW = True
plotter = Plotter(errorFileName, validationFileName, testingFileName, not SAVE_TO_FILE)
plotter.plot(trainingInformation, SHOW)
def __init__(self, filename, pxLinkables=[], logger=None, version = 0):
FileParser.__init__(self, filename) # Routing filename ("/apps/px/etc/pxroute.conf")
self.logger = logger # Logger object
self.version = version # Routing file version (0 or 1)
self.version = 1 # FORCING VERSION 1
self.routingInfos = {} # Addressed by header name: self.routingInfos[header]['clients']
# self.routingInfos[header]['subclients']
# self.routingInfos[header]['priority']
self.keyMasks = [] # Key pattern list : mask, 'clients','priority',cmask,t/f
self.keyMaskMap = {} # Addressed by Key pattern: self.keyMaskMap[key] = True
self.subClients = {} # Addressed by client name
self.aliasedClients = {} # Addressed by alias
self.aftnMap = {} # Addressed by AFTN address. aftnMap['DEFAULT'] give the default
self.goodClients = {} # Sub group of clients that are in header2clients.conf and are px linkable.
self.badClients = {} # Sub group of clients that are in header2clients.conf and are not px linkable.
self.pxLinkables = pxLinkables # All clients to which px can link (independant of header2clients.conf)
self.originalClients = {} # Indexed by header, remove duplicate, no alias expansion, subclients as is.
# Only used to reconstruct the routing file
if self.logger:
self.logger.info("Routing table used: %s" % filename)
def __init__(self, filename, logger=None):
FileParser.__init__(self, filename) # Stations filename ("/apps/px/etc/stations.conf")
self.logger = logger # Logger Object
self.stations = {} # Indexed by header
self.printErrors = True #
self.type = "INT" # Must be in ['CA', 'US', 'COLL', 'INT']
self.stationSearched = None # Station for which we want to find the more recent occurence
def __init__(self):
self.dataAttr = [
"Gender", "Age", "Student?", "PreviouslyDeclined?", "HairLength",
"Employed?", "TypeOfColateral", "FirstLoan", "LifeInsurance"
]
self.dataClasif = "Risk"
self.posClassification = "high"
self.negClassification = "low"
self.matchAllChar = '?'
self.hypothesis = ConjHypothesis(self.dataAttr, self.matchAllChar)
self.printEvery = 30
# files
self.testFileName = sys.argv[1]
self.devFileName = "9Cat-Dev.labeled"
self.trainFileName = "9Cat-Train.labeled"
self.outFileName = "partA4.txt"
# parse data
self.trainingData = FileParser(self.trainFileName,
self.dataClasif).getOutputData()
self.developmentData = FileParser(self.devFileName,
self.dataClasif).getOutputData()
self.testData = FileParser(self.testFileName, self.dataClasif,
False).getOutputData()
# run program
self.printInitialization()
with open(self.outFileName, 'w') as f:
self.runTraining(f, self.trainingData)
self.runTrial(self.developmentData)
self.runClassification(self.testData)
def main(top_dir="", exclude_dirs=[]):
"""
Run main program
1) Use the FileScavenger.scavenge to get all dirs in top level
excluding the exclude dirs
2) Use FileParser.parseFileList to parse all the files in the project
and return a list of objects
3) Pass the object list to ObjectFormatter.resolveProjectHierarchy
to properly resolve the cpp objects and values
4) Sort the returned object list using ObjectFormatter.sortObjectHierarchy
5) Write the sorted object list to file
"""
fScav = FileScavenger()
file_list = fScav.scavenge(top_dir, exclude_dirs)
fParser = FileParser()
objList = fParser.parseFileList(file_list)
objForm = ObjectFormatter()
objList = objForm.resolveProjectHierarchy(objList)
objList = objForm.sortObjectHierarchy(objList, 2)
objForm.objListToFile(objList)
def extracte_vm(dir):
for root, dirs, files in os.walk(dir):
for name in files:
if re.match(r'.*xml$', name):
file_src = os.path.join(root, name)
print(file_src)
parser = FileParser(file_src)
parser.generate_vm()
def __init__(self, filename, logger=None):
FileParser.__init__(self, filename) # Stations filename ("/apps/px/etc/stations.conf")
self.logger = logger # Logger Object
self.headers = {} # Indexed by station
self.stations = {} # Indexed by header
self.stationsColl = {} # Indexed by header (only the ones that have to be collected)
self.printErrors = False # Print errors
self.logErrors = True # Log errors
def predict():
fileParser = FileParser()
table = fileParser.parse("predictor")
maxSize = fileParser.getMax()
#print(maxSize)
epsilon = .6 #percent error
dataContainer = []
for i in range(0, maxSize):
openValue = table.iloc[i, 0]
closeValue = table.iloc[i, 1]
percentDifference = (closeValue - openValue) / openValue * 100
dataContainer.append(
percentDifference
) #stores the percent difference between the closed and open value
if DEBUG:
print(table)
accumMatch = 0
accumIncrease = 0
#averages the current 3 percent differences
currentAvg = (dataContainer[maxSize - 1] + dataContainer[maxSize - 2] +
dataContainer[maxSize - 3]) / 3
if DEBUG:
print("\"\"\"DEBUG START\"\"\"")
print("LAST THREE DIFFERENCE:")
#print("1.", dataContainer[0])
print("1.", dataContainer[maxSize - 1])
print("2.", dataContainer[maxSize - 2])
print("3.", dataContainer[maxSize - 3])
print("CURRENT AVG:", currentAvg)
for i in range(2, maxSize - 1):
#gets the averages of all the past 3 percent differences and checks if the trend
#is similar to the current average with margin of error (epsilon)
pastAvg = (dataContainer[i] + dataContainer[i - 1] +
dataContainer[i - 2]) / 3
if currentAvg - epsilon < pastAvg and currentAvg + epsilon > pastAvg:
accumMatch += 1
#within those similar trends, check how much of those events actually increased afterwards
if dataContainer[i + 1] > 0:
accumIncrease += 1
#This means that there was no similar trends, then give a 50:50 prediction
if accumMatch == 0:
return (.5, .5)
probabilityIncrease = accumIncrease / accumMatch
probabilityDecrease = (accumMatch - accumIncrease) / accumMatch
if DEBUG:
print("ACCUM INCREASE:", accumIncrease)
print("ACCUM MATCH:", accumMatch)
print("PROBABILITY TO INCREASE:", probabilityIncrease)
print("PROBABILITY TO DECREASE:", probabilityDecrease)
print("\"\"\"DEBUG END\"\"\"")
return (probabilityIncrease, probabilityDecrease)
def __init__(self, filename, logger=None):
FileParser.__init__(
self, filename) # Stations filename ("/apps/px/etc/stations.conf")
self.logger = logger # Logger Object
self.headers = {} # Indexed by station
self.stations = {} # Indexed by header
self.stationsColl = {
} # Indexed by header (only the ones that have to be collected)
self.printErrors = False # Print errors
self.logErrors = True # Log errors
def run(self):
while (not self.quitSaveTheFile):
fileParser = FileParser(self._queue)
start_time = time.time()
print("the Execution Time11:%s seconds " %
(time.time() - start_time))
self.quitSaveTheFile = fileParser.FileParser()
print("the Execution Time22:%s seconds " %
(time.time() - start_time))
def parseDir(input):
if (os.path.isdir(input)):
return parseDir(input)
filename, fileExt = os.path.splitext(input)
init = InitParser()
parsedObject = init.initialize(fileExt)
parser = FileParser()
newSloc = SlocObject()
newSloc = parser.parse(parsedObject, input)
Tracker.computeAggregates(newSloc)
def run(self):
while True:
fileParser = FileParser()
start_time = time.time()
print("the Execution Time11:%s seconds " % (time.time() - start_time))
fileParser.FileParser()
print("the Execution Time22:%s seconds " % (time.time() - start_time))
def __init__(self):
self.file_parser = FileParser()
self.file_parser.parse_teams()
self.file_parser.parse_events()
self.file_parser.parse_coaches()
self.teams = self.file_parser.get_teams()
self.events = self.file_parser.get_events_as_map()
self.events_remaining = list(self.events.keys())
self.coaches = self.file_parser.get_coaches_as_map()
self.coaches_remaining = list(self.coaches.keys())
self.graph = self.file_parser.create_graph()
async def async_checkUsers(self):
await asyncio.sleep(self.SNOOPSNOO_REFRESH_RATE)
while not self.gracefulExit:
startTime = time.time()
wasChanged = False
self.logger.info("Time to refresh SnoopSnoo for " +
str(len(self.redditCache[1])) + " users...")
u = 0
while u < len(self.redditCache[1]):
usr = self.redditCache[1][u]
res, usrobj = await SheriAPI.async_getUserInfo(usr)
if res.find("ERROR") == 0 or res.find("EXCEPTION") == 0:
# See if the user exists, may be deleted or banned
ru = self.r.redditor(usr)
try:
if ru.id:
self.logger.warning("Error in SS refresh for '" +
usr + "': " + res)
u += 1
except:
self.logger.warning(
"User likely deleted or suspended - '" + usr +
"': " + res)
self.redditCache[1].pop(u)
self.redditCache[2].pop(u)
else:
if self.isQualifiedUser(usr, res):
wasChanged = True
self.logger.info("CONGRATULATIONS!! " + usr +
" is qualified to join!")
# Add user to queue so discord side can announce it
self.acceptQueue.put(usr)
self.acceptedUsers.append(usr.lower())
self.redditCache[1].pop(u)
self.redditCache[2].pop(u)
else:
self.redditCache[2][u] = str(
int(self.redditCache[2][u]) - 1)
if self.redditCache[2][u] == "0":
self.redditCache[1].pop(u)
self.redditCache[2].pop(u)
else:
u += 1
# Write the (hopefully changed) accepted users list
if wasChanged:
FileParser.writeList("acceptedusers.txt", self.acceptedUsers,
'w')
FileParser.writeNestedList("redditcache.txt", self.redditCache,
'w')
endTime = time.time()
await asyncio.sleep(
self.checkTime(self.SNOOPSNOO_REFRESH_RATE,
startTime - endTime, "async_checkUsers"))
async def on_message(message):
global lastMessageFrom, messageComboBreak
# ignore other bots I guess
if not message.author.bot:
# isinstance is poor form, but what're you going to do?
if isinstance(message.channel, discord.DMChannel):
if message.content[:6].lower() == "b.help":
await message.channel.send("No need for that! Just write me a message and I'll forward it to the mods, and then they can reply through me! If you wish to remain anonymous for your message, make sure it begins with the word \"anon\" (without quotes!)")
return
if message.content[:4].lower() == "anon":
# Keep users anonymous
logger.info("Received message from Anonymous User ; " + str(message.id))
# Can't do much here since the bot needs their discord ID to persist between restarts
# and any obfuscation could eventually be cracked
key = str(message.author.id) + "anon"
auth = "Anonymous User"
msg = message.content[4:]
else:
logger.info("Received message from " + str(message.author.id) + " ; " + str(message.id))
key = str(message.author.id)
auth = message.author.name+" ("+message.author.mention+")"
msg = message.content
if not (key in userMap[3]):
if key in userMap[2]:
idx = userMap[2].index(key)
else:
idx = len(userMap[2])
userMap[2].append(key)
FileParser.writeNestedList("usermap.txt", userMap, 'w')
# skip header if no other messages were posted to the channel since last message
# and the author of the previous message is the same
skipheader = (key == lastMessageFrom) and (messageComboBreak == False)
if skipheader:
mail = msg
else:
mail = "From: "+auth+"\n(reply with `b.reply "+str(idx)+" \"message here\"`, mute with `b.mute "+str(idx)+"`)\n\n"+msg
lastMessageFrom = key
# Get attachments, put in the URLs, don't save anything unknown to the bot
try:
for item in message.attachments:
mail += "\n" + item.url
except:
logger.warning("Could not get URL for all attachments")
mailchannel = bot.get_channel(findChannel(config['general']['dm_channel']))
messageComboBreak = False
await mailchannel.send(mail)
else:
await message.channel.send("You are currently muted, DM the mods directly to appeal your mute")
else:
mailchannel = bot.get_channel(findChannel(config['general']['dm_channel']))
if (message.channel.id == mailchannel.id) and (message.author.id != bot.user.id):
messageComboBreak = True
await bot.process_commands(message)
async def me(ctx, redditname: str=None):
"""Associate a reddit username to your discord name"""
if redditname is None:
await ctx.send("You need to specify a reddit username,\neg. `b.ping me SimStart`")
else:
logger.info("b.ping me called: "+str(ctx.author.id)+" ; "+redditname)
if not redditname.lower() in acceptedusers:
await ctx.send("Couldn't find '"+redditname+"' in accepted users, are you sure their name is spelled correctly?")
else:
userMap[0].append(redditname.lower())
userMap[1].append(str(ctx.author.id))
FileParser.writeNestedList("usermap.txt", userMap, 'w')
await ctx.send("Added "+fixUsername(redditname)+" to the ping list :thumbsup:")
async def user(ctx, member: discord.Member=None, redditname: str=None):
"""Associate a discord user to a reddit username (mods only)"""
if member is None or redditname is None:
await ctx.send("You need to specify both a Discord user and a reddit username,\neg. `b.ping user @SimStart SimStart`")
else:
logger.info("b.ping user called: "+str(member.id)+" ; "+redditname)
if not redditname.lower() in acceptedusers:
await ctx.send("Couldn't find '"+redditname+"' in accepted users, are you sure their name is spelled correctly?")
else:
userMap[0].append(redditname.lower())
userMap[1].append(str(member.id))
FileParser.writeNestedList("usermap.txt", userMap, 'w')
await ctx.send("Added "+fixUsername(redditname)+" to the ping list :thumbsup:")
def ShowFileContent(self):
file_name = self.OpenFileDialog()
logging.warning('FileName:{}'.format(file_name))
date, magnitude = FileParser.GetMagnitudeTime(
FileParser.Read4File(file_name[0]))
qListP = []
for i in range(len(date)):
qListP.append(QPointF(i, magnitude[i]))
series = QtCharts.QLineSeries()
series.append(qListP)
self.chartView.chart().removeAllSeries()
self.chartView.chart().addSeries(series)
self.chartView.chart().createDefaultAxes()
self.chartView.show()
async def remove(ctx, redditname: str=None):
"""Remove all associations used for a reddit user (mods only)"""
if redditname is None:
await ctx.send("You need to specify a reddit username,\neg. `b.ping remove SimStart`")
else:
logger.info("b.ping remove called: "+redditname)
num = 0
while redditname.lower() in userMap[0]:
idx = userMap[0].index(redditname.lower())
userMap[0].pop(idx)
userMap[1].pop(idx)
num += 1
FileParser.writeNestedList("usermap.txt", userMap, 'w')
await ctx.send("Removed "+str(num)+" instances of "+fixUsername(redditname)+" from the ping list :thumbsup:")
def __init__(self):
self.parser = FileParser()
self.persistent = {}
self.timer = Timer()
self.processes = {
"chapters_books": {
"process_data": "_process_data_chapters_books",
"persistent_file": os.path.join(self.path,
"chapters_books.pkl")
},
"chapters_all_scigraph_citations": {
"process_data":
"_process_data_chapters_all_scigraph_citations",
"persistent_file":
os.path.join(self.path, "chapters_all_scigraph_citations.pkl")
},
"chapters_confproc_scigraph_citations": {
"process_data":
"_process_data_chapters_confproc_scigraph_citations",
"persistent_file":
os.path.join(self.path,
"chapters_confproc_scigraph_citations.pkl")
},
"books_conferences": {
"process_data": "_process_data_books_conferences",
"persistent_file": os.path.join(self.path,
"books_conferences.pkl")
},
"author_id_chapters": {
"process_data":
"_process_data_author_id_chapters",
"persistent_file":
os.path.join(self.path, "author_id_chapters.pkl")
},
"author_name_chapters": {
"process_data":
"_process_data_author_name_chapters",
"persistent_file":
os.path.join(self.path, "author_name_chapters.pkl")
},
"confproc_scigraph_citations_chapters": {
"process_data":
"_process_data_confproc_scigraph_citations_chapters",
"persistent_file":
os.path.join(self.path,
"confproc_scigraph_citations_chapters.pkl")
}
}
class SpiderMain(object):
def __init__(self):
self.manager = UrlManager()
self.downloader = FileDownLoader()
self.parser = FileParser()
self.output = DataOutput()
def crawl(self, root_files):
for root_file in root_files:
new_urls = self.parser.parser(root_file)
self.manager.add_new_urls(new_urls)
while (self.manager.has_new_url()):
try:
new_url = self.manager.get_new_url()
data = self.downloader.download(new_url)
self.output.store_data(data, root_file, new_url)
print("已经抓取%s个链接" % self.manager.old_url_size())
interval = random.randint(1, 3)
time.sleep(interval)
print("sleep: %d" % interval)
except Exception as err:
self.output.mark_result(root_file, new_url, False)
print("crawl faild:" + str(err))
class ParityResolver:
with open('settings.json') as config:
configuration = json.load(config)
input_nodes_qty = 35
hidden_nodes_qty = configuration['multilayer_hidden_nodes_parity']
output_nodes_qty = 1
lr = configuration['multilayer_lr']
training_qty = configuration['multilayer_training_qty']
max_training_epochs = configuration['multilayer_max_training_epochs']
pb_entries = fp.mlp_entries_parser(7, 5)
pb_targets = [('0'), ('1'), ('0'), ('1'), ('0'), ('1'), ('0'), ('1'),
('0'), ('1')]
mp = MultilayerPerceptron(pb_entries, pb_targets, input_nodes_qty,
hidden_nodes_qty, output_nodes_qty,
training_qty, lr, max_training_epochs)
# for i in range(max_training_epochs):
# x = random.randint(0,training_qty)
# mp.train(np.matrix(pb_entries[x]).transpose(),np.matrix(pb_targets[x]).transpose())
mp.train()
# plot_entries = []
for pb_e in pb_entries:
# plot_entries.append(mp.feed_forward(np.matrix(pb_e).transpose()).item(0))
print(mp.feed_forward(np.matrix(pb_e).transpose()))
class PerceptronSimpleMain:
with open('settings.json') as config:
configuration = json.load(config)
learning_rate = float(configuration["learning_rate"])
operation = str(configuration["operation"]).upper()
steps = int(configuration["steps"])
isLinear = str(configuration["isLinear"]).upper() == "TRUE"
betha = float(configuration["betha"])
entries = [[-1, 1], [1, -1], [-1, -1], [1, 1]]
if operation and (operation == "XOR" or operation == "OR"
or operation == "AND"):
if operation == "XOR":
output = [1, 1, -1, -1]
elif operation == "OR":
output = [1, 1, -1, 1]
elif operation == "AND":
output = [-1, -1, -1, 1]
SimplePerceptron(learning_rate, entries, output, steps).perform()
else:
[data, test_data, min_value, max_value] = fp.data_parser()
spl = SimplePerceptronEJ2(learning_rate, data, test_data,
max_value, min_value, steps, betha,
isLinear)
spl.perform()
def functionality(my_option):
while True:
if my_option.lower() == 'file':
dir = input("Enter directory and name of your file.")
opt = input(
"Type 's' if you want only to save your file without displaying. "
"Type whatever if you just want to display the tree.")
p = FileParser(dir, opt)
my_option = ""
elif my_option.lower() == 'console':
o = input("Type 'p' for primitive console tree, type everything else for normal tree.")
newick = input("Please enter your input in newick format.")
p = Parser(newick, o)
my_option = ""
elif my_option.lower() == 'help':
print("- Type 'file' if you want to import tree in newick format from file. "
"Then, after pressing enter, you will have to provide the path. \n"
"- Type 'console' if you want to paste it to console.\n"
"- Type 'r' if you want to generate random tree.\n"
"- Press 'q' for exit.\n"
"For more information read README.md.")
my_option = ""
elif my_option.lower() == 'r':
opt = input(
"Type 's' if you want only to save your file without displaying. "
"Type whatever if you just want to display the tree.")
p = RandomTree(opt)
my_option = ""
elif my_option.lower() == 'q':
sys.exit()
else:
print("Need help? Type 'help'.")
my_option = input()
functionality(my_option)
def main():
command_line_arguments = sys.argv
if has_valid_command_line_arguments(command_line_arguments):
file_name = get_file_name(command_line_arguments)
file_path = get_file_path(FILE_PATH_CSV, file_name)
logging.info("Parsing file...")
file_parser = FileParser()
file_content = file_parser.parse(file_path)
sentiment_score_provider = SentimentScoreProvider()
translate_provider = TranslateProvider()
logging.info("Getting and appending translations and sentiment score")
number_of_requests = 0
number_of_rows = len(file_content)
for row in file_content:
if number_of_requests > 0 and number_of_requests % MAX_NUMBER_OF_REQUESTS == 0:
logging.info('Waiting %s seconds before sending more requests',
DELAY_SECONDS_BETWEEN_REQUEST_LIMIT)
time.sleep(DELAY_SECONDS_BETWEEN_REQUEST_LIMIT)
text_answer = row[COLUMN_TO_ANALYZE]
translated_text_answer = ""
sentiment_score = {'magnitude': "", 'score': ""}
if text_answer:
translated_text_answer = translate_provider.translate(
TRANSLATION_TARGET_LANGUAGE, text_answer)
sentiment_score = sentiment_score_provider.analyze(
translated_text_answer)
row['sentiment_magnitude'] = sentiment_score['magnitude']
row['sentiment_score'] = sentiment_score['score']
row['translated_' + COLUMN_TO_ANALYZE] = translated_text_answer
logging.info("Analyzing line %s/%s", str(number_of_requests),
str(number_of_rows))
number_of_requests += 1
logging.info("Writing new csv file to results folder %s...", file_name)
result_file_path = get_file_path(FILE_PATH_RESULTS, file_name)
file_parser.write(result_file_path, file_content)
logging.info("Done")
else:
sys.exit(1)
async def mute(ctx, *args):
"""Mute all modmail DMs from a user (mods only)"""
if len(args) < 1:
await ctx.send("You need to specify an ID!\neg. `b.mute 0`")
else:
logger.info("b.mute called by " + str(ctx.author.id) + " ; " + args[0])
try:
idx = int(args[0])
except:
await ctx.send(args[0] + " is not a valid index! try again")
return
if len(userMap[2]) <= idx:
await ctx.send(args[0] + " is not a valid index! try again")
else:
id = userMap[2][idx]
userMap[3].append(id)
FileParser.writeNestedList("usermap.txt", userMap, 'w')
await ctx.send("Ignoring DMs from User ID " + str(idx) + ":thumbsup:")
def run(self):
fileParser = FileParser()
start_time = time.time()
print("the Execution Time11:%s seconds " % (time.time() - start_time))
fileParser.FileParser()
print("the Execution Time22:%s seconds " % (time.time() - start_time))
"""
while True:
if not q.full():
item = random.randint(1,10)
q.put(item)
logging.debug('Putting ' + str(item)
+ ' : ' + str(q.qsize()) + ' items in queue')
time.sleep(random.random())
"""
return
def _getFilesToParse(self, root, headers, excludedSources=None):
"""
Given a root path (ex: PXPaths.DB + date + '/SA/') and a list of
headers (ex: ['SAAK31 KWBC', 'SAAK41 KNKA', 'SAUS20 KNKA', 'SAUS70 KWBC']),
find the list of files matching these criterias.
"""
filesToParse = []
if headers == ['']:
pass
else:
centers = FileParser.removeDuplicate([header.split()[1] for header in headers])
# Request SA PATQ
# => headers = ['SAAK31 KWBC', 'SAAK41 KNKA', 'SAUS20 KNKA', 'SAUS70 KWBC']
# => ttaaiis = {'KNKA': ['SAAK41', 'SAUS20'], 'KWBC': ['SAAK31', 'SAUS70']}
ttaaiis = {}
for header in headers:
ttaaiis.setdefault(header.split()[1], []).append(header.split()[0])
try:
if not excludedSources: excludedSources = []
sources = os.listdir(root)
for source in excludedSources:
if source in sources:
sources.remove(source)
except:
(type, value, tb) = sys.exc_info()
if self.printout:
print("Type: %s, Value: %s" % (type, value))
return filesToParse
#print("Headers: %s" % headers)
#print("ttaaiis: %s" % ttaaiis)
#print("centers: %s" % centers)
#print("sources: %s\n" % sources)
for source in sources:
for center in centers:
pathToCenter = root + source + '/' + center
try:
for file in os.listdir(pathToCenter):
for ttaaii in ttaaiis[center]:
if file[:len(ttaaii)] == ttaaii:
filesToParse.append(pathToCenter + '/' + file)
break
except:
(type, value, tb) = sys.exc_info()
if self.printout:
if self.debug: print("Type: %s, Value: %s" % (type, value))
continue
#print ("len(filesToParse) = %d\n" % len(filesToParse))
return filesToParse
#-*- coding: utf-8 -*-
import sys
sys.path.append("../")
from FileParser import FileParser
import threading
SUCCESS = 0
FAIL = 1
if __name__ == "__main__":
#from audio import Audio
#play = Audio()
_files = sys.argv[1:]
if not _files:
print "需要执行命令\"python %s 1.pcm\"" % __file__
sys.exit(1)
stream_test = FileParser()
for _file in _files:
if stream_test.read_file(_file) == SUCCESS:
print _file
t = threading.Thread(target=stream_test.run)
#t = threading.Thread(target=stream_test.run, kwargs={"fun":play.play_stream})
#t.setDaemon(True)
t.start()
t.join()
