def post_basic():
if request.method == 'GET':
if 'query' in request.args:
search = request.args['query']
p = Parser(dir_search.basic(search))
p.parse()
return jsonify(p.results)
return "Error: No search query provided. Please provide one."
elif request.method == 'POST':
search = request.form['search']
p = Parser(dir_search.basic(search))
p.parse()
print(p.results)
return jsonify(p.results)
def message_receiver(message):
chat_id = message.chat.id
try:
url, time_from, time_to = Parser(message.text).all()
try:
stream_url = youtube_lookup(url)
except Exception:
raise exceptions.InputValidationException(
"There was something wrong with the link you sent.")
redis_queue.enqueue(video.download, chat_id, stream_url, time_from,
time_to)
_len = len(redis_queue.jobs)
status_text = \
f"Your video is currently in position #{_len} in queue." \
if _len else "Your video will start processing immediately."
bot.send_message(chat_id,
f"Thank you for your request! {status_text}")
except (
exceptions.InputValidationException,
exceptions.ForbiddenUserOperation,
) as e:
bot.send_message(chat_id, e)
except Exception as e:
bot.send_message(chat_id, 'Oops! Something went wrong.')
raise e
def post_advanced():
first = None
last = None
id = None
email = None
if 'first' in request.form:
first = request.form['first']
if 'last' in request.form:
last = request.form['last']
if 'id' in request.form:
id = request.form['id']
if 'email' in request.form:
email = request.form['email']
if not any([first, last, id, email]):
return "Error: No search query provided. Please provide one."
p = Parser(dir_search.advanced(first, last, id, email))
p.parse()
return jsonify(p.results)
orderManager = OrderManager()
order_idx = 4 + nb_warehouse*2
nb_orders = int(parser.get_line(order_idx)[0])
for i in range(nb_orders):
coords = parser.get_line(order_idx + 1 + i*3)
x = coords[1]
y = coords[0]
products_needed = parser.get_line(order_idx + 3 + i*3)
#print("x {0} / y {1} / pro_len {2}".format(x, y, len(products_needed)))
orderManager.add_order(i, x, y, products_needed)
return warehouseManager, orderManager, droneManager
if __name__ == "__main__":
file = sys.argv[1] if len(sys.argv) > 1 else 'busy_day'
if not file.endswith('.in'):
file_name = file + '.in'
else:
file_name = file
input_fn = 'input2016-{0}'.format(file_name)
input = os.path.join(INPUT_FILE_DIR, input_fn)
p = Parser(input)
p.parse()
warehouseManager, orderManager, droneManager = create_model(p)
simu(droneManager, orderManager, warehouseManager)
output_file = 'output2016-{0}.out'.format(file)
nb_lines = droneManager.write_output(output_file)
print("{0} lines has been printed to {1}".format(nb_lines, output_file))
def get_basic(search):
p = Parser(dir_search.basic(search))
p.parse()
return jsonify(p.results)
def __init__(self, file_name):
self.parser = Parser(file_name)
self.nb_lines = 0
self.nb_columns = 0
self.matrix = []
from base import AbstractExpression, Globals, Var
from input_parser import Parser
print("Available functions: ", end='')
print(*Globals.unary_operators, sep=', ', end='\n\n')
print("Use x, y, or z as variables.", end='\n\n')
input_string = input("Differentiate: ")
var = Var(input("with respect to: ").strip())
expression: AbstractExpression = Parser(input_string).parse()
print("Input parsed as: ", expression)
print("Result: ", expression.dx(var).simplify())
def test_output_values(self):
expected_results = [
('video_url', (
'video_url',
'00:00:00',
'00:01:00',
)),
('video_url&t=50', (
'video_url&t=50',
'00:00:50',
'00:01:50',
)),
('video_url&t=60', (
'video_url&t=60',
'00:01:00',
'00:02:00',
)),
('video_url&t=66', (
'video_url&t=66',
'00:01:06',
'00:02:06',
)),
('video_url&t=66 2:00', (
'video_url&t=66',
'00:01:06',
'00:02:00',
)),
('video_url&t=50&someotherjunk', (
'video_url&t=50&someotherjunk',
'00:00:50',
'00:01:50',
)),
('video_url 20s', (
'video_url',
'00:00:00',
'00:00:20',
)),
('video_url 15 25', (
'video_url',
'00:00:15',
'00:00:25',
)),
('video_url 00:15 25s', (
'video_url',
'00:00:15',
'00:00:40',
)),
('video_url 25s', ('video_url', '00:00:00', '00:00:25')),
('video_url 0:15', (
'video_url',
'00:00:15',
'00:01:15',
)),
('video_url 00:0:15', (
'video_url',
'00:00:15',
'00:01:15',
)),
('video_url 01:00:15 59s', (
'video_url',
'01:00:15',
'01:01:14',
)),
]
for parser_input, expected_outputs in expected_results:
results = Parser(parser_input).all()
for expected, actual in zip(expected_outputs, results):
self.assertEqual(expected, actual)
from event_finder import EventFinder
from graph_generator import GraphGenerator
from graph_traverser import GraphTraverser
from input_parser import Parser
from possibilities import Possibilities
from state_node import StateNode
parser = Parser()
startNodeSet = parser.parseStartNodes()
adjList = parser.parseReachability()
vulnDict, portDict = parser.parseVulnerabilities()
eventMapping = parser.parseEventMapping()
eventSet = EventFinder()
# Generate attack graph
graphGenerator = GraphGenerator(startNodeSet, adjList, vulnDict, portDict)
DG = graphGenerator.generate_graph()
timestamp, src, dst, port, description, accessLevel = parser.parseNotableEvent(
)
graphTraverser = GraphTraverser(DG, eventSet, eventMapping, portDict.keys())
eventSequence = graphTraverser.start_traversal(timestamp, src, dst, port,
description, accessLevel)
# Print possibilities
crownJewelSet = parser.parseCrownJewels()
possibilitiesGenerator = Possibilities()
notableEventStateNode = StateNode(dst, accessLevel)
possibilitiesGenerator.printPossiblePaths(DG, notableEventStateNode,
crownJewelSet)
