def test_all_text(self):
query = self.queries[0]
first_answer = howdoi.howdoi(query)
second_answer = howdoi.howdoi(query + ' -a')
self.assertNotEqual(first_answer, second_answer)
self.assertNotEqual(
re.match('.*Answer from http.?://.*', second_answer, re.DOTALL),
None)
def test_json_output(self):
query = self.queries[0]
txt_answer = howdoi.howdoi(query)
json_answer = howdoi.howdoi(query + ' -j')
link_answer = howdoi.howdoi(query + ' -l')
json_answer = json.loads(json_answer)[0]
self.assertEqual(json_answer["answer"], txt_answer)
self.assertEqual(json_answer["link"], link_answer)
self.assertEqual(json_answer["position"], 1)
def test_answers(self):
for query in self.queries:
self.assertValidResponse(howdoi.howdoi(query))
for query in self.bad_queries:
self.assertValidResponse(howdoi.howdoi(query))
os.environ['HOWDOI_URL'] = 'pt.stackoverflow.com'
for query in self.pt_queries:
self.assertValidResponse(howdoi.howdoi(query))
def test_colorize(self):
query = self.queries[0]
normal = howdoi.howdoi(query)
colorized = howdoi.howdoi('-c ' + query)
# There is currently an issue with Github actions and colorization
# so do not run checks if we are running in Github
if "GITHUB_ACTION" not in os.environ:
self.assertTrue(normal.find('[38;') == -1)
self.assertTrue(colorized.find('[38;') != -1)
def test_answers_bing(self):
os.environ['HOWDOI_SEARCH_ENGINE'] = 'bing'
for query in self.queries:
self.assertValidResponse(howdoi.howdoi(query))
for query in self.bad_queries:
self.assertValidResponse(howdoi.howdoi(query))
os.environ['HOWDOI_URL'] = 'pt.stackoverflow.com'
for query in self.pt_queries:
self.assertValidResponse(howdoi.howdoi(query))
os.environ['HOWDOI_SEARCH_ENGINE'] = ''
def howdo(who, what, where):
# Get the response from howdoi
try:
howresp = howdoi.howdoi({
'all': False,
'clear_cache': False,
'color': False,
'pos': 1,
'link': False,
'query': what.split(),
'num_answers': 1,})
# And a link
howurl = howdoi.howdoi({
'all': False,
'clear_cache': False,
'color': False,
'pos': 1,
'link': True,
'query': what.split(),
'num_answers': 1,})
except:
# Been having it fail on certain queries.
# "foam babby" is one.
# Also, 70 just because it makes me happy, alright?
# http://www.freebsd.org/cgi/man.cgi?query=sysexits
return 70
# If it's one line, send it to IRC
if howresp.count('\n') <= 1:
msg = who + ": " + howresp
# Otherwise, pae.st it.
else:
if howurl:
paest = howresp + "\n\nFor more info, check: " + howurl
data = urllib.urlencode({'d': paest})
paestresp = urllib2.urlopen(
urllib2.Request("http://a.pae.st", data)
).read()
s = re.compile("(http.*)(?:#WEB-PUBLIC)").search(paestresp)
msg = who + ": Try " + s.groups()[0] + "."
else:
msg = who + ": " + howresp
say(where, msg)
def howdoitommy(query):
n = 1
while True:
if n > 10:
return "sorry, I cannot answer that"
args = {
"query": query, #.split(" "),
"num_answers": 1,
"pos": n,
"all": False,
"color": False,
"explain": False,
"clear_cache": False,
"json_output": False,
"version": False,
"search_engine": "google",
"save": False,
"view": False,
"remove": False,
"empty": False,
"sanity_check": False,
"link": False
}
answer = howdoi(args)
if len(answer) < 50 or len(answer) > 600:
n += 1
continue
else:
return answer
def call_howdoi(self, query):
""" Crete parser. Parser musi ustawiac sparsowane argumenty jako atrybuty. Dlatego pojawia sie vars.
vars zwraca slownik gdzie kluczem jest atrybutu. Vars
"""
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
return howdoi.howdoi(args)
def test_blockerror(self, mock_get_links):
mock_get_links.side_effect = requests.HTTPError
query = self.queries[0]
response = howdoi.howdoi(query)
self.assertEqual(
response,
"ERROR: \x1b[91mUnable to get a response from any search engine\n\x1b[0m"
)
async def __(event):
query = event.pattern_match.group(1)
if query == None:
await event.edit("`Give Some Query First`")
return
output = howdoi.howdoi(query)
lel = f"<b><u>Here is Your Answer</b></u> \n<code>{output}</code>"
await event.edit(lel, parse_mode="HTML")
def howdoi(self):
if not self.values: return 'Howdoi what now?'
try:
parser = hownow.get_parser()
args = vars(parser.parse_args(self.values))
return hownow.howdoi(args)
except:
return 'Dunno bro'
async def howdoi_cmd(event):
if not event.args:
await event.edit(f"`Syntax: {ldr.settings.get_config('cmd_prefix') or '.'}hdi <question>`")
return
response = howdoi.howdoi(vars(howdoi.get_parser().parse_args(event.args.split(' '))))
response = re.sub(r'\n\n+', '\n\n', response).strip()
await event.edit(f"**Query:**\n{event.args}\n**Answer:**\n{response}")
def howdoi(self):
if not self.values: return 'Howdoi what now?'
try:
parser = hownow.get_parser()
args = vars(parser.parse_args(self.values))
return hownow.howdoi(args)
except:
return 'Dunno bro'
def _search(query: str, replies: Replies) -> None:
try:
resp = json.loads(howdoi(f"{query} -j"))[0]
if resp["answer"]:
replies.add(text=f"{resp['answer']}\n\n↗️ {resp['link']}")
else:
replies.add(text="❌ Nothing found.")
except (Exception, SystemExit): # noqa
replies.add(text="❌ Something went wrong.")
def get_answers(question: str, pos=1):
try:
raw_answer = howdoi.howdoi(f'{question} -j -p {pos}')
answer = jd.decode(raw_answer)[0]
except Exception as err:
return {'warning': 'Something went wrong.'}
else:
return answer
def search(self, word):
parser = howdoi.get_parser()
args = vars(parser.parse_args(word.split(' ')))
output = howdoi.howdoi(args)
return output if output.strip(
) != "" else "Did not find anything containing that"
async def howdoi(
self, ctx,
question): #sanitize the **** out of the user input (question)
# Get howdoi answer
query = question
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
output = howdoi.howdoi(args)
await ctx.send("```" + "\n" + output + "\n" + "```")
# Get stackoverflow Link to that answer
linkCommand = '-l'
query = linkCommand + ' ' + question
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
output = howdoi.howdoi(args)
await ctx.send("\n" + output + "\n")
return
def test_help_queries(self):
help_queries = self.help_queries
for query in help_queries:
output = howdoi.howdoi(query)
self.assertTrue(output)
self.assertIn('few popular howdoi commands', output)
self.assertIn('retrieve n number of answers', output)
self.assertIn(
'Specify the search engine you want to use e.g google,bing',
output)
def code():
answer.delete(1.0, END)
try:
entry_value = search_entry.get()
parser = howdoi.get_parser()
args = vars(parser.parse_args(entry_value.split(' ')))
output = howdoi.howdoi(args)
answer.insert(INSERT, output)
except:
answer.insert(INSERT, "Internet Connection Error!!!")
async def on_howdoi(ctx, *, query):
if ctx.channel.id in allowed_channels:
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(" ")))
output = howdoi.howdoi(args)
if len(output) > 2000:
output = output[0:1997] + "..."
embed = Embed(title="Query: " + query, description=output, color=0xff0000)
await ctx.reply(content="", embed=embed, mention_author=True)
else:
await ctx.reply(content=f"**Please use this in a development channel only!**", mention_author=True)
async def howdoi(self, ctx, *question):
"""Ask a coding question"""
self.query = " ".join(question)
self.args["query"] = self.query
out = howdoi.howdoi(self.args.copy()) # .encode('utf-8', 'ignore')
if self.args['link']:
await self.bot.say(out)
else:
await self.bot.say(box(out, "python"))
async def howdoi(self, ctx, *, query=None):
if query is not None:
parser = howdoi.get_parser()
arguments = vars(parser.parse_args(query.split(' ')))
embed = discord.Embed(title=f'how to {query}',
description=howdoi.howdoi(arguments))
async with ctx.typing():
await asyncio.sleep(2)
await ctx.channel.send(embed=embed)
else:
await ctx.send(f'What did you wanted to ask? {ctx.author.mention}')
def get_answer(self, command, query):
question = query[len(command):].strip()
result = howdoi(
dict(query=question,
num_answers=1,
pos=1,
all=command[-1] == '!',
color=False))
_answer = self.line_wrap(result, HowdoiHandler.MAX_LINE_LENGTH)
answer = "Answer to '%s':\n```\n%s\n```" % (question, _answer)
return answer
def howdoi_view(request):
if request.method == 'POST':
query = request.POST['query']
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
print(args)
print(type(args))
output = howdoi.howdoi(args)
context = {"output": output}
return render(request, 'howdoi_view.html', context)
return render(request, 'howdoi_view.html')
def get_answer(self, command, query):
question = query[len(command):].strip()
result = howdoi(dict(
query=question,
num_answers=1,
pos=1,
all=command[-1] == '!',
color=False
))
_answer = self.line_wrap(result, HowdoiHandler.MAX_LINE_LENGTH)
answer = "Answer to '%s':\n```\n%s\n```" % (question, _answer)
return answer
def howdoitommy(query):
n = 1
while True:
if n > 10:
return 'sorry, I cannot answer that'
args = {
'query': query.split(' '),
'num_answers': 1,
'pos': n,
'all': False,
'color': False,
}
answer = howdoi(args)
if len(answer) < 30 or len(answer) > 700:
n += 1
continue
else:
return answer
def h_handler():
"""
Example:
/howdoi open file python
"""
text = query
# adding default params
args = {
'query': text.split(),
'pos': 1,
'all': False,
'link': False,
'clear_cache': False,
'version': False,
'num_answers': 1,
'color': False,
}
output = howdoi.howdoi(args)
return template(output)
def telegram_webhook():
update = request.get_json()
app.logger.info(update)
msg = Query()
if "message" in update and timedelta(minutes=5) > (datetime.now() - datetime.fromtimestamp(update['message']['date'])):
db.insert(update['message'])
text = update["message"]["text"]
args = {
'query': text.split(' ')
}
args.update(howdoi_args)
text = howdoi(args)
chat_id = update["message"]["chat"]["id"]
try:
bot.sendMessage(chat_id, "```\n{}```".format(text), parse_mode='Markdown')
except telepot.exception.BotWasBlockedError as e:
app.logger.error(str(e))
return "OK"
def howdoi_handler():
"""
Example:
/howdoi open file python
"""
postdata = request.body.read()
text = postdata
# adding default params
args = {
'query': text.split(),
'pos': 1,
'all': False,
'link': False,
'clear_cache': False,
'version': False,
'num_answers': 1,
'color': False,
}
output = howdoi.howdoi(args)
return output
def howdoiWrapper(strArg):
"""howdoi is meant to be called from the command line - this wrapper lets it be called programatically
Arguments:
strArg {str} -- search term
"""
if strArg.lower() == 'use arepl' or strArg.lower() == 'arepl':
returnVal = 'using AREPL is simple - just start coding and arepl will show you the final state of your variables. For more help see https://github.com/Almenon/AREPL-vscode/wiki'
else:
try:
parser = howdoi.get_parser()
except NameError as e:
# alter error to be more readable by user
e.args = (['howdoi is not installed'])
raise
args = vars(parser.parse_args(strArg.split(' ')))
returnVal = howdoi.howdoi(args)
print(returnVal)
return returnVal # not actually necessary but nice for unit testing
def howdoi_handler():
"""
Example:
/howdoi open file python
"""
text = request.forms.text
if not text:
return 'Please type a ?text= param'
# adding default params
args = {
'query': text.split(),
'pos': 1,
'all': False,
'link': False,
'clear_cache': False,
'version': False,
'num_answers': 1,
'color': False,
}
output = howdoi.howdoi(args)
return output
def call_howdoi(self, query):
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
return howdoi.howdoi(args)
def call_howdoi(self, query):
return howdoi.howdoi(query)
def call_howdoi(self, query):
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
return howdoi.howdoi(args)
def _call_howdoi(query):
parser = hdi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
return hdi.howdoi(args)
