def main():
args = parse_args()
logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
db_manager = init_db(args.db_name, args.db_user, args.db_pass,
args.db_host, args.db_port)
if args.tickers_file:
parse(args.tickers_file, args.threads_count)
handlers = (
('GET', '', tickers_handler),
('GET', '/api', api_tickers_handler),
('GET', '/{ticker:\w+}', ticker_handler),
('GET', '/api/{ticker:\w+}', api_ticker_handler),
('GET', '/{ticker}/insider', insiders_handler),
('GET', '/api/{ticker}/insider', api_insiders_handler),
('GET', '/{ticker}/insider/{name}', insider_handler),
('GET', '/api/{ticker}/insider/{name}', api_insider_handler),
('GET', '/{ticker}/analytics', analytics_handler),
('GET', '/api/{ticker}/analytics', api_analytics_handler),
('GET', '/{ticker}/delta', delta_handler),
('GET', '/api/{ticker}/delta', api_delta_handler),
)
app = Application(middlewares=[error_middleware])
app['db_manager'] = db_manager
for handler in handlers:
app.router.add_route(*handler)
aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('app', 'templates'))
run_app(app, host=args.host, port=args.port)
def run_parser(self):
printer.Output = printer.Printer(self.source_file_path)
parser.parse(self.source_code, debug=False)
printer.Output.print()
printer.Output.file = None
print("\n\nRunning test with source code: \n")
printer.Output._print(sys.stdout)
AST.clear()
MAIN_INSTRUCTION_TAPE.clear()
def test_profile_parse(self):
profile = cProfile.Profile()
parser = app.parser.Parser()
path = u'app/actions.py'
data = io.open(path).read()
grammar = self.prefs.getGrammar(path)
profile.enable()
parser.parse(data, grammar, 0, sys.maxsize)
profile.disable()
output = io.StringIO.StringIO()
stats = pstats.Stats(
profile, stream=output).sort_stats(u'cumulative')
stats.print_stats()
print(output.getvalue())
def test_parse():
"""
Function must retrieve the questions inside sentences asked to the bot.
"""
assert parser.parse(OCR_QUESTION) == [
"est-ce que tu connais l'adresse d'openclassrooms ?"
]
assert parser.parse(MENTOR_1) == [
"comment s'est passé ta soirée avec grandma hier soir?",
"où se trouve le musée d'art et d'histoire de fribourg, s'il te plaît?",
]
assert parser.parse(MENTOR_2) == [
"bonsoir grandpy, j'espère que tu as passé une belle semaine. est-ce "
"que tu pourrais m'indiquer l'adresse de la tour eiffel? merci "
"d'avance et salutations à mamie."
]
def handle_response():
# See: https://www.twilio.com/docs/sms/tutorials/how-to-receive-and-reply-python
# Webhook for the user texting us / twilio hits this
print("Request values", request.values)
body = request.values.get('Body', None)
phone_number = request.values.get('From')
phone_number = normalize_number(phone_number)
resp = MessagingResponse()
if body.lower() == 'confirm':
print("Looking for user with phone number {}".format(phone_number))
user = DB.session.query(User).filter(
User.phone_number == phone_number,
User.confirmed == False).one_or_none()
print("query result: {}".format(user))
if user:
user.confirmed = True
DB.session.add(user)
DB.session.commit()
resp.message("Thank you! Your path to happiness begins NOW!")
return str(resp)
else:
return ''
else:
# check if user confirmed
# if so do the regular response flow: store in db, thank the user
user = DB.session.query(User).filter(
User.phone_number == phone_number,
User.confirmed == True).one_or_none()
print("found user: {}".format(user))
if user:
message = body.lower()
try:
score = parse(message)
print("Scoring message {} as happiness level {}".format(
message, score))
except Exception as e:
print("Error in parsing message: {}".format(e))
score = None
response = UserResponse(user_id=user.id,
raw=body.lower(),
happiness=score)
DB.session.add(response)
DB.session.commit()
response_text = respond_to(int(score))
resp.message(
"{}\nThanks for sharing. Your response has been recorded.".
format(response_text))
else:
resp.message("Please sign up and confirm first.")
return str(resp)
def __save_report(key, doc):
"""Saves report using data from specified document."""
date = __get_date_by_name(doc["event"])
rpt_id = "report/" + doc["location"] + "-" + str.join("-", map(lambda x: str(x), date))
rpt = db.get(rpt_id, {}) # get report or create new one
rpt["_id"] = key
rpt["location"] = doc["location"]
rpt["event"] = doc["event"]
rpt["date"] = date
rpt["data"] = parse(doc["report"])
db[rpt_id] = rpt
def main():
while True:
try:
print('>>> ', end='')
rpnFormula = input().strip()
tokensStream = lexer.tokenizeRpnFormula(rpnFormula)
syntaxTree = parser.parse(tokensStream)
infixFormula = render.renderInfix(syntaxTree)
print('Satisfiable' if mts.
checkFormulaSatisfiable(syntaxTree) else 'Unsatisfiable')
print()
except lexer.UnrecognizableSymbolError as symbol:
error(f'Unrecognizable symbol {symbol}')
except parser.NestedPredicateError as e:
nestedPredicateName, currentTokenType, currentTokenName = e.args[0]
error(
f'Predicate {nestedPredicateName} nested in {currentTokenType} {currentTokenName}'
)
except parser.ArgumentOfOperatorShouldBeALogicalFormulaError as operator:
error(f'Argument of {operator} operator must be a logical formula')
except parser.FirstArgumentOfQuantifierShouldBeAVariableError as quantifierType:
error(f'First argument of {quantifierType} must be a variable')
except parser.SecondArgumentOfQuantifierShouldBeALogicalFormulaError as quantifierType:
error(
f'Second argument of {quantifierType} must be a logical formula'
)
except parser.IncorrectArgumentsNumberError as tokenType:
error(f'Incorrect arguments number in {tokenType}')
except parser.EmptyFormula:
error(f'Empty formula')
except EOFError:
print()
break
except:
panic(
255,
f'Unknown error ocurred. Report the developer: {DEVELOPER_URL}'
)
def validate(html):
result = []
table = parse(html)
if table:
for ridx, row in enumerate(table):
columns_cnt = len(row)
if columns_cnt not in [5, 36]:
__error(result, "Row should contain 5 or 36 column", row=ridx, column=0)
if not row[0]:
__error(result, "Name is not provided", row=ridx, column=0)
for i in range(1, columns_cnt):
if not isinstance(row[i], int):
__error(result, "Not a numeric value {}".format(row[i]), row=ridx, column=i)
else:
__error(result, "Report should contain one table")
return {
"isValid": len(result) == 0,
"errors": result
}
def test_fail_without_url(self):
with self.assertRaises(SystemExit):
parse("--output /".split())
def test_password_is_read(self):
args = parse("-u www.example.com -o /tmp/1.txt -l foo -p bar".split())
self.assertEqual(args['password'], "bar")
def test_username_is_read(self):
args = parse("-u www.example.com -o /tmp/1.txt -l foo".split())
self.assertEqual(args['login'], "foo")
def check_url(self):
return parse(self.full_url)
def parse(inp: str) -> Sheet:
return parser.parse(inp)
import sys
from app.parser import parse
from app.downloader import Downloader
from app.extractor import extract
args = parse(sys.argv[1:])
dl = Downloader(output=args['output'],
login=args['login'],
password=args['password'])
result = dl.get(args['url'])
if result:
items = extract(result)
for url in items:
dl.save(url)
def test_fail_without_output(self):
with self.assertRaises(SystemExit):
parse("--url www.example.com".split())
def index():
parser.parse(site="tribun", url="https://www.tribunnews.com/rss")
parser.parse(site="antara", url="https://www.antaranews.com/indeks")
news = News.query.order_by(News.article_ts.desc()).all()
return render_template('index.html', news=news)
def test_parse_performance(self):
a = timeit('''parser = app.parser.Parser()
parser.parse(data, grammar, 0, sys.maxsize)''',
setup=performance1,
number=10)
def route():
return '<pre>' + parse(request.args.get('lines', '')) + '</pre>'
def search():
query_terms = parse(request.args.get('search'))
top_k_reviews = retrieve_top_k_reviews(query_terms)
return render_template('results.html',
reviews=top_k_reviews,
query_terms=query_terms)
