',
187 | 'NameError: name \'xyz\' is not defined'
188 | ])
189 |
190 | # 2. When.
191 | error = get_error_from_traceback(mock_pipe)
192 |
193 | # 3. Then.
194 | assert error == 'NameError'
195 | assert mock_pipe.get_readline_call_count() == 2
196 |
197 |
198 | def test_handle_exception(capsys, monkeypatch):
199 | '''
200 | Ensures that posts are printed until the user inputs 'Y'
201 | to stop.
202 | '''
203 |
204 | # 1. Given.
205 | def mock_accepted_posts(*args):
206 | # pylint: disable=unused-argument
207 | '''
208 | Mocks the accepted_posts function which yields
209 | strings instead of actual post bs4 soup.
210 | '''
211 |
212 | i = 1
213 |
214 | while i:
215 | yield str(i)
216 |
217 | def mock_print_accepted_post(*args):
218 | # pylint: disable=unused-argument
219 | '''
220 | Mocks the print_accepted_post function.
221 | '''
222 |
223 | return
224 |
225 | def make_mock_handle_user_input():
226 | '''
227 | Creates the mock function to mock handle_user_input, and the
228 | input is different based on the call count.
229 | '''
230 |
231 | call_count = 0
232 |
233 | def mock_handle_user_input():
234 | '''
235 | Mocks the handle_user_input function.
236 | '''
237 |
238 | nonlocal call_count
239 | call_count += 1
240 |
241 | if call_count == 1:
242 | return False
243 |
244 | if call_count == 2:
245 | return 'Custom query'
246 |
247 | return True
248 |
249 | return mock_handle_user_input
250 |
251 | def mock_clear_terminal():
252 | '''
253 | Mocks the clear_terminal function.
254 | '''
255 |
256 | return
257 |
258 | def mock_print_listening_for_errors():
259 | '''
260 | Mocks the print_listening_for_errors function.
261 | '''
262 |
263 | print(u'\U0001F95E Listening for Python errors...')
264 |
265 | monkeypatch.setattr(
266 | 'autostack.error.accepted_posts',
267 | mock_accepted_posts
268 | )
269 |
270 | monkeypatch.setattr(
271 | 'autostack.error.print_accepted_post',
272 | mock_print_accepted_post
273 | )
274 |
275 | monkeypatch.setattr(
276 | 'autostack.error.handle_user_input',
277 | make_mock_handle_user_input()
278 | )
279 |
280 | monkeypatch.setattr(
281 | 'autostack.error.clear_terminal',
282 | mock_clear_terminal
283 | )
284 |
285 | monkeypatch.setattr(
286 | 'autostack.error.print_listening_for_errors',
287 | mock_print_listening_for_errors
288 | )
289 |
290 | # 2. When.
291 | handle_exception('Error')
292 |
293 | # 3. Then.
294 | captured = capsys.readouterr()
295 | assert captured.out == u'\U0001F95E Listening for Python errors...\n'
296 |
297 |
298 | def test_handle_user_input_y(monkeypatch):
299 | '''
300 | Ensures that when 'Y' is inputted, handle_user_input returns True.
301 | '''
302 |
303 | # 1. Given.
304 | def mock_input(*args):
305 | # pylint: disable=unused-argument
306 | '''
307 | Mocks user input to be 'Y'.
308 | '''
309 |
310 | return 'Y'
311 |
312 | monkeypatch.setattr('builtins.input', mock_input)
313 |
314 | # 2. When.
315 | user_input = handle_user_input()
316 |
317 | # 3. Then.
318 | assert user_input is True
319 |
320 |
321 | def test_handle_user_input_n(monkeypatch):
322 | '''
323 | Ensures that when 'n' is inputted, handle_user_input returns False.
324 | '''
325 |
326 | # 1. Given.
327 | def mock_input(*args):
328 | # pylint: disable=unused-argument
329 | '''
330 | Mocks user input to be 'n'.
331 | '''
332 |
333 | return 'n'
334 |
335 | monkeypatch.setattr('builtins.input', mock_input)
336 |
337 | # 2. When.
338 | user_input = handle_user_input()
339 |
340 | # 3. Then.
341 | assert not user_input
342 |
343 |
344 | def test_handle_user_input_custom_query(monkeypatch):
345 | '''
346 | Ensures that when input isn't Y/n, handle_user_input returns the input.
347 | '''
348 |
349 | # 1. Given.
350 | def make_mock_input():
351 | '''
352 | Creates the mock function to mock user input, and the
353 | input is different based on the call count.
354 | '''
355 |
356 | call_count = 0
357 |
358 | def mock_input(*args):
359 | # pylint: disable=unused-argument
360 | '''
361 | Mocks user input to be 'a' then 'Y'.
362 | '''
363 |
364 | nonlocal call_count
365 | if call_count == 0:
366 | call_count += 1
367 | return 'Custom query'
368 | return 'Y'
369 | return mock_input
370 |
371 | monkeypatch.setattr('builtins.input', make_mock_input())
372 |
373 | # 2. When.
374 | user_input = handle_user_input()
375 |
376 | # 3. Then.
377 | assert user_input == 'Custom query'
378 |
379 |
380 | def test_print_listening_for_errors(capsys):
381 | '''
382 | Ensures that print_listening_for_errors prints the proper output.
383 |
384 | "🥞 Listening for Python errors..."
385 | '''
386 |
387 | # 1. Given.
388 |
389 | # 2. When.
390 | print_listening_for_errors()
391 |
392 | # 3. Then.
393 | captured = capsys.readouterr()
394 | assert captured.out == u'\U0001F95E Listening for Python errors...\n'
395 |
396 |
397 | def test_clear_terminal(capsys):
398 | '''
399 | Ensures that clear_terminal clears the terminal.
400 | '''
401 |
402 | # 1. Given.
403 |
404 | # 2. When.
405 | clear_terminal()
406 |
407 | # 3. Then.
408 | captured = capsys.readouterr()
409 | assert captured.out == '\x1bc\n' # Same as u'\033c'
410 |
--------------------------------------------------------------------------------
/autostack/main.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers, Benjamin Sanders
3 | Emails: elijahsawyers@gmail.com, ben.sanders97@gmail.com
4 | Date: 03/17/2019
5 | Overview: Entry point of autostack.
6 | '''
7 |
8 | from autostack.cli import cli
9 |
10 |
11 | def main():
12 | '''
13 | Entry point of autostack.
14 | '''
15 |
16 | cli()
17 |
--------------------------------------------------------------------------------
/autostack/pipe/__init__.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers, Benjamin Sanders
3 | Emails: elijahsawyers@gmail.com, ben.sanders97@gmail.com
4 | Date: 10/09/2019
5 | Overview:
6 | '''
7 |
8 | import os
9 |
10 |
11 | def create_pipe(path):
12 | '''
13 | TODO: Write docstring.
14 |
15 | Parameter {string}: the full path to the fifo.
16 | Returns: The pipe in read mode.
17 | '''
18 |
19 | leaf_dir_path = '/'.join(path.split('/')[:-1])
20 |
21 | if not os.path.exists(leaf_dir_path):
22 | os.makedirs(leaf_dir_path)
23 |
24 | try:
25 | os.mkfifo(path)
26 | except (FileExistsError, OSError):
27 | pass
28 |
--------------------------------------------------------------------------------
/autostack/pipe/__tests__/test_pipe.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers, Benjamin Sanders
3 | Emails: elijahsawyers@gmail.com, ben.sanders97@gmail.com
4 | Date: 10/22/2019
5 | Overview: Tests for the pipe package.
6 | '''
7 |
8 | import shutil
9 | import os
10 |
11 | from autostack.pipe import create_pipe
12 |
13 |
14 | def test_create_pipe_dir_doesnt_exist():
15 | ''''
16 | Ensures that create_pipe creates the directories to the pipe
17 | recursively.
18 | '''
19 |
20 | # 1. Given.
21 | path = '/tmp/test/dir/pipe'
22 |
23 | # 2. When.
24 | create_pipe(path)
25 |
26 | # 3. Then.
27 | assert os.path.exists(path)
28 |
29 | shutil.rmtree('/tmp/test/')
30 |
31 |
32 | def test_create_pipe_file_doesnt_exist():
33 | ''''
34 | Ensures that create_pipe creates a pipe, if it doesn't exist.
35 | '''
36 |
37 | # 1. Given.
38 | path = '/tmp/pipe'
39 |
40 | # 2. When.
41 | create_pipe(path)
42 |
43 | # 3. Then.
44 | assert os.path.exists(path)
45 |
46 | os.remove(path)
47 |
48 |
49 | def test_create_pipe_file_already_exists():
50 | ''''
51 | Ensures that if a file already exists at the specifies path,
52 | it will not be overwritten.
53 | '''
54 |
55 | # 1. Given.
56 | path = '/tmp/pipe'
57 |
58 | # 2. When.
59 | os.mkfifo(path)
60 | mtime = os.path.getmtime(path)
61 | create_pipe(path)
62 |
63 | # 3. Then.
64 | assert os.path.getmtime(path) == mtime
65 |
--------------------------------------------------------------------------------
/autostack/so_web_scraper/__init__.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers, Benjamin Sanders
3 | Emails: elijahsawyers@gmail.com, ben.sanders97@gmail.com
4 | Date: 03/17/2019
5 | Overview: Contains the StackOverflowScraper class which is used to
6 | scrape Stack Overflow for posts with accepted answers for a given query.
7 | '''
8 |
9 | from __future__ import absolute_import, division, print_function
10 | from bs4 import BeautifulSoup
11 | import pygments
12 | from pygments.lexers import PythonLexer # pylint: disable=no-name-in-module
13 | import requests
14 | from termcolor import colored
15 |
16 | BASE_URL = 'https://stackoverflow.com'
17 |
18 |
19 | def accepted_posts(query):
20 | '''
21 | A generator that queries Stack Overflow and yields posts with
22 | accepted answers.
23 |
24 | Parameter {str} query: the string to query Stack Overflow with.
25 | Yields {bs4.BeautifulSoup}: accepted posts html documents.
26 | '''
27 |
28 | for result_set in get_post_summaries(query):
29 | for post_summary in result_set:
30 | post = post_soup(post_summary)
31 |
32 | if post:
33 | yield post
34 |
35 |
36 | def get_post_summaries(query):
37 | '''
38 | A generator that queries Stack Overflow and yields a ResultSet
39 | of post summaries.
40 |
41 | Parameter {str} query: the string to query Stack Overflow with.
42 | Yields {bs4.element.ResultSet}: ResultSet of post summaries.
43 | '''
44 |
45 | page = 1
46 |
47 | while True:
48 | query_url = build_query_url(query, page)
49 | query_soup = query_stack_overflow(query_url)
50 |
51 | if not query_soup:
52 | break
53 |
54 | post_summaries = query_soup.find_all(
55 | attrs={
56 | 'class': 'question-summary'
57 | }
58 | )
59 |
60 | if not post_summaries:
61 | break
62 |
63 | yield post_summaries
64 |
65 | page += 1
66 |
67 |
68 | def build_query_url(query, page):
69 | '''
70 | Builds a URL to query Stack Overflow with.
71 |
72 | e.g. query == 'Test Query' and page == 1 then the url will be:
73 | https://stackoverflow.com/search?page=1&tab=Relevance&q=%5Bpython%5D+Test+Query
74 |
75 | Parameter {str} query: the string to query Stack Overflow with.
76 | Parameter {int} page: the page to select in the query.
77 | '''
78 |
79 | query_url = '{}/search?page={}&tab=Relevance&q=%5Bpython%5D'.format(
80 | BASE_URL,
81 | page
82 | )
83 |
84 | for query_string in query.split(' '):
85 | query_url = '{}+{}'.format(query_url, query_string)
86 |
87 | return query_url
88 |
89 |
90 | def query_stack_overflow(url):
91 | '''
92 | Given a url, this function returns the BeautifulSoup of the
93 | request.
94 |
95 | Parameter {str} url: the url to request.
96 | Returns {bs4.BeautifulSoup}: the BeautifulSoup of the request.
97 | '''
98 |
99 | try:
100 | response = requests.get(url)
101 | response.raise_for_status()
102 | except requests.exceptions.HTTPError:
103 | return None
104 |
105 | return BeautifulSoup(response.text, 'lxml')
106 |
107 |
108 | def post_soup(post_summary):
109 | '''
110 | Given a post summary, query Stack Overflow, and return the
111 | BeautifulSoup of the post, if it has an accepted answer.
112 |
113 | Parameter {bs4.Tag} post_summary: the bs4.Tag post summary.
114 | Parameter {bs4.BeautifulSoup}: the BeautifulSoup of the post,
115 | if it has an accepted answer; otherwise, None.
116 | '''
117 |
118 | if has_accepted_answer(post_summary):
119 | post_url = get_post_url(post_summary)
120 |
121 | try:
122 | response = requests.get(BASE_URL + post_url)
123 | response.raise_for_status()
124 | except requests.exceptions.HTTPError:
125 | return None
126 |
127 | return BeautifulSoup(response.text, 'lxml')
128 |
129 | return None
130 |
131 |
132 | def has_accepted_answer(post_summary):
133 | '''
134 | Given a post summary, this function determines whether or not
135 | the post has an accepted answer.
136 |
137 | Parameter {bs4.Tag} post_summary: the post summary.
138 | Returns {Boolean}: True if the post has an accepted answer;
139 | otherwise, False.
140 | '''
141 |
142 | accepted_answer = post_summary.find(
143 | attrs={
144 | 'class': 'answered-accepted'
145 | }
146 | )
147 |
148 | if not accepted_answer:
149 | return False
150 |
151 | return True
152 |
153 |
154 | def get_post_url(post_summary):
155 | '''
156 | Given a post summary, this function returns the post's url.
157 |
158 | Parameter {bs4.Tag} post_summary: the post summary.
159 | Returns {str:None}: post url, or None, if the post url couldn't
160 | be found.
161 | '''
162 |
163 | try:
164 | return post_summary.find(
165 | attrs={
166 | 'class': 'question-hyperlink'
167 | },
168 | href=True
169 | )['href']
170 | except KeyError:
171 | return None
172 |
173 |
174 | def print_accepted_post(post):
175 | '''
176 | Prints a Stack Overflow post with an accepted answer.
177 |
178 | Parameter {bs4.BeautifulSoup} post: The 'soup' of the post
179 | to print.
180 | '''
181 |
182 | question = get_post_text(post, 'question')
183 | accepted_answer = get_post_text(post, 'accepted-answer')
184 |
185 | if question is None or accepted_answer is None:
186 | return
187 |
188 | print(colored('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~', 'red'))
189 | print(colored('Question:', 'red'))
190 |
191 | # Print the question.
192 | print_post_text(question)
193 |
194 | print(colored('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~', 'red'))
195 | print(colored('Answer:', 'red'))
196 |
197 | # Print the answer.
198 | print_post_text(accepted_answer)
199 |
200 | print(colored('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~', 'red'))
201 |
202 |
203 | def get_post_text(post, html_class):
204 | '''
205 | Given a post, and a html class, this function returns a
206 | bs4.Tag with the post-text.
207 | Typically, you'd only pass 'question' or 'accepted-answer' as
208 | the html class.
209 |
210 | Parameter {bs4.BeautifulSoup} post: the post to get post-text from.
211 | Parameter {str} html_class: the html class of the elementto get
212 | post-text from.
213 | Returns {bs4.Tag}: the post-text.
214 | '''
215 |
216 | try:
217 | return post.find(
218 | attrs={
219 | 'class',
220 | html_class
221 | }
222 | ).find(
223 | attrs={
224 | 'class',
225 | 'post-text'
226 | }
227 | )
228 | except AttributeError:
229 | return None
230 |
231 |
232 | def print_post_text(post_text):
233 | '''
234 | Prints post-text from Stack Overflow.
235 |
236 | On Stack Overflow, a div with a class of 'post-text'
237 | indicates that the div is either a question or an answer.
238 |
239 | Different elements of the post-text are printed in different
240 | colors.
241 |
242 | Headers: White.
243 | Text: White.
244 | Quotes: Yellow.
245 | Lists: Syntax Highlighted in print_ul.
246 | Code: Syntax Highlighted in print_code_block.
247 |
248 | Parameter {bs4.Tag} post_text: HTML 'div' element from a Stack Overflow
249 | post with class of 'post-text.'
250 | '''
251 |
252 | element_colors = {
253 | 'h1': 'white',
254 | 'h2': 'white',
255 | 'h3': 'white',
256 | 'p': 'white',
257 | 'blockquote': 'yellow',
258 | }
259 |
260 | for element in post_text:
261 | if element.name in element_colors.keys():
262 | print(
263 | colored(element.text, element_colors[element.name])
264 | )
265 | elif element.name == 'ul': # Lists.
266 | print_ul(element)
267 | elif element.name == 'pre': # Code.
268 | print_code_block(element.find('code'))
269 |
270 |
271 | def print_ul(ul_element):
272 | '''
273 | Prints an unordered list.
274 |
275 | Parameter {bs4.Tag} ul_element: the unordered list to print.
276 | '''
277 |
278 | for item in ul_element.find_all('li'):
279 | print(
280 | colored(' - ' + item.text, 'green', attrs=['bold'])
281 | )
282 |
283 |
284 | def print_code_block(code_block):
285 | '''
286 | Prints a code block from Stack Overflow with syntax highlighting.
287 |
288 | On Stack Overflow, the code in a HTML 'code' element contains
289 | a 'span' element for each token. Because of this, it's necessary
290 | to grab each of the 'code' element's 'span' elements' values to get
291 | the actual code.
292 |
293 | Parameter {bs4.Tag} code_block: 'soup' of a HTML
294 | 'code' element from a Stack Overflow post.
295 | '''
296 |
297 | token_colors = {
298 | 'Token.Keyword': 'blue',
299 | 'Token.Name.Builtin.Pseudo': 'blue',
300 | 'Token.Literal.Number.Integer': 'green',
301 | 'Token.Literal.Number.Float': 'green',
302 | 'Token.Comment.Single': 'green',
303 | 'Token.Comment.Hashbang': 'green',
304 | 'Token.Literal.String.Single': 'yellow',
305 | 'Token.Literal.String.Double': 'yellow',
306 | 'Token.Literal.String.Doc': 'yellow'
307 | }
308 |
309 | print('')
310 |
311 | # Store the code's text.
312 | code = get_src_code(code_block)
313 |
314 | # Loop over code, and highlight.
315 | for token, content in pygments.lex(code, PythonLexer()):
316 | try:
317 | print(
318 | colored(content, token_colors[str(token)]),
319 | end=''
320 | )
321 | except KeyError:
322 | print(
323 | content,
324 | end=''
325 | )
326 |
327 | print('')
328 |
329 |
330 | def get_src_code(code_block):
331 | '''
332 | Loops over a code block and grabs the 'source code'
333 | (i.e. text).
334 |
335 | Parameter {bs4.Tag} code_block: the source code (or text).
336 | Returns {str}: the source code (or text).
337 | '''
338 |
339 | code = ''
340 |
341 | # Loop through code spans.
342 | for token in code_block:
343 | try: # bs4.NavigableString
344 | code += token
345 | except TypeError: # bs4.Tag
346 | code += get_src_code(token.contents)
347 |
348 | return code
349 |
--------------------------------------------------------------------------------
/autostack/so_web_scraper/__tests__/data/post_text.html:
--------------------------------------------------------------------------------
1 |
2 |
Test 1
3 |
Test 2
4 |
Test 3
5 |
Test 4
6 |
Test 5
7 |
10 |
Test 7
11 |
2 | l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
3 | reduce(lambda x, y: x.extend(y), l)
4 |
--------------------------------------------------------------------------------
/autostack/so_web_scraper/__tests__/data/post_text_ul_empty.html:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/autostack/so_web_scraper/__tests__/data/post_text_ul_populated.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | - Test 1
4 | - Test 2
5 | - Test 3
6 |
7 |
7 |
8 |
9 | 
31 |
32 |
33 | 
35 |
36 |
37 | 
39 |
40 |
41 | 
115 | 
131 |
132 |
133 | ## Authors
134 | * [Elijah Sawyers](https://github.com/elijahsawyers)
135 | * [Benjamin Sanders](https://github.com/BenOSanders)
136 | * [Caleb Werth](https://github.com/cwerth1)
137 |
--------------------------------------------------------------------------------
/autostack/__init__.py:
--------------------------------------------------------------------------------
1 | # pylint: disable=invalid-name, line-too-long, anomalous-backslash-in-string
2 | '''
3 | Authors: Elijah Sawyers, Benjamin Sanders
4 | Emails: elijahsawyers@gmail.com, ben.sanders97@gmail.com
5 | Date: 03/17/2019
6 | Overview: The autostack package includes a cli and packages for error
7 | parsing, querying Stack Exchange, etc.
8 | '''
9 |
10 | name = 'autostack'
11 |
12 |
13 | def print_logo():
14 | '''
15 | Prints the autostack logo, in color.
16 | '''
17 |
18 | print(u' \u001b[38;5;179m_____________ ') # nopep8
19 | print(u' \u001b[38;5;179m/ \u001b[38;5;226m___ \u001b[38;5;179m\ \u001b[0m') # nopep8
20 | print(u' \u001b[38;5;179m|| \u001b[38;5;226m\__\\\u001b[0m \u001b[38;5;179m||\u001b[38;5;208m _ _ _ ') # nopep8
21 | print(u' \u001b[38;5;179m|| \u001b[38;5;94m_\u001b[38;5;179m ||\u001b[38;5;208m | | | | | | ') # nopep8
22 | print(u' \u001b[38;5;179m|\ \u001b[38;5;94m/ \\\u001b[38;5;179m /|\u001b[38;5;208m __ _ _ _| |_ ___ ___| |_ __ _ ___| | __') # nopep8
23 | print(u' \u001b[38;5;179m\ \___\u001b[38;5;94m/ ^ \\\u001b[38;5;179m___/ /\u001b[38;5;208m / _` | | | | __/ _ \/ __| __/ _` |/ __| |/ /') # nopep8
24 | print(u' \u001b[38;5;179m\\\\____\u001b[38;5;94m/_^_\\\u001b[38;5;179m____//\u001b[38;5;94m_\u001b[38;5;208m | (_| | |_| | || (_) \__ \ || (_| | (__| < ') # nopep8
25 | print(u' \u001b[38;5;94m__\u001b[38;5;179m\\\\____\u001b[38;5;94m/_^_\\\u001b[38;5;179m____// \u001b[38;5;94m\\\u001b[38;5;208m \__,_|\__,_|\__\___/|___/\__\__,_|\___|_|\_\\') # nopep8
26 | print(u' \u001b[38;5;94m/ \u001b[38;5;179m\____\u001b[38;5;94m/_^_\\\u001b[38;5;179m____/ \u001b[38;5;224m\ \u001b[38;5;94m\\\u001b[0m \033[1mAUTOMATING THE INEVITABLE...') # nopep8
27 | print(u' \u001b[38;5;94m/\u001b[38;5;224m/\u001b[38;5;94m \u001b[38;5;224m, \u001b[38;5;94m/ ') # nopep8
28 | print(u' \u001b[38;5;94m\\\u001b[38;5;224m\\\u001b[38;5;94m___________ \u001b[38;5;224m____ \u001b[38;5;94m/ ') # nopep8
29 | print(u' \u001b[38;5;94m\_______/\u001b[0m \n') # nopep8
30 |
--------------------------------------------------------------------------------
/autostack/cli/__init__.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | import click
9 |
10 | from autostack.cli.capture import capture
11 | # from autostack.cli.config import config
12 | from autostack.cli.display import display
13 | # from autostack.cli.error import error
14 | # from autostack.cli.init import init
15 |
16 |
17 | @click.group()
18 | def cli():
19 | # pylint: disable=missing-function-docstring
20 | pass
21 |
22 |
23 | cli.add_command(capture)
24 | # cli.add_command(config)
25 | cli.add_command(display)
26 | # cli.add_command(error)
27 | # cli.add_command(init)
28 |
--------------------------------------------------------------------------------
/autostack/cli/capture.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | import subprocess
9 | import sys
10 |
11 | import click
12 |
13 | from autostack.cli.constants import (
14 | PIPE_PATH
15 | )
16 | from autostack.pipe import (
17 | create_pipe
18 | )
19 |
20 |
21 | @click.command()
22 | def capture():
23 | '''
24 | Capture all error messages outputed in the terminal for configured
25 | languages.
26 | '''
27 |
28 | create_pipe(PIPE_PATH)
29 |
30 | if sys.platform.startswith('darwin'): # Mac
31 | subprocess.run(['script', '-q', '-F', '/tmp/monitorPipe'], check=True)
32 | else:
33 | subprocess.run(['script', '-q', '-f', '/tmp/monitorPipe'], check=True)
34 |
--------------------------------------------------------------------------------
/autostack/cli/config.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | import click
9 |
10 |
11 | @click.command()
12 | @click.option(
13 | '--key',
14 | required=True,
15 | help='The configuration option to change.'
16 | )
17 | def config():
18 | '''
19 | Set global autostack configuration options.
20 | '''
21 |
22 | return
23 |
--------------------------------------------------------------------------------
/autostack/cli/constants.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | PIPE_PATH = '/tmp/monitorPipe'
9 |
--------------------------------------------------------------------------------
/autostack/cli/display.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 | import os
8 |
9 | import click
10 |
11 | from autostack.cli.constants import (
12 | PIPE_PATH
13 | )
14 | from autostack.error import (
15 | listen_for_errors
16 | )
17 |
18 |
19 | @click.command()
20 | def display():
21 | '''
22 | Display posts for all error messages captured with the 'capture' command.
23 | '''
24 |
25 | if not os.path.exists(PIPE_PATH):
26 | print('Execute "autostack capture" in another terminal window first.')
27 | return
28 |
29 | with open(PIPE_PATH) as pipe:
30 | listen_for_errors(pipe)
31 |
--------------------------------------------------------------------------------
/autostack/cli/error.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | import click
9 |
10 |
11 | @click.command()
12 | @click.argument('message')
13 | def error():
14 | '''
15 | Query for a given error message, and dislay posts for that query.
16 | '''
17 |
18 | return
19 |
--------------------------------------------------------------------------------
/autostack/cli/init.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers
3 | Emails: elijahsawyers@gmail.com
4 | Date: 12/05/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | import json
9 |
10 | import click
11 | import regex
12 | from PyInquirer import (
13 | prompt,
14 | Validator,
15 | ValidationError
16 | )
17 |
18 | from autostack import (
19 | print_logo
20 | )
21 |
22 |
23 | @click.command()
24 | def init():
25 | '''
26 | Initialize a project with a .autostack.json configuration file.
27 | '''
28 |
29 | class MaxCommentsValidator(Validator):
30 | # pylint: disable=too-few-public-methods
31 | '''
32 | Validator for the max_comments prompt.
33 | '''
34 |
35 | def validate(self, document):
36 | '''
37 | Ensures that the max_comments input contains a positive integer.
38 | '''
39 |
40 | valid = regex.match(r'^\d+$', document.text)
41 | if not valid:
42 | raise ValidationError(
43 | message='Please enter a valid integer',
44 | cursor_position=len(document.text))
45 |
46 | questions = [
47 | {
48 | 'type': 'checkbox',
49 | 'name': 'languages',
50 | 'message':
51 | 'What languages do you want autostack \
52 | to capture errors for?',
53 | 'choices': [
54 | {
55 | 'name': 'Python',
56 | 'checked': True,
57 | },
58 | ]
59 | },
60 | {
61 | 'type': 'checkbox',
62 | 'name': 'communities',
63 | 'message':
64 | 'Which Stack Exchange communities do you want to \
65 | query?',
66 | 'choices': [
67 | {
68 | 'name': 'Stack Overflow',
69 | 'checked': True,
70 | },
71 | ]
72 | },
73 | {
74 | 'type': 'list',
75 | 'name': 'order_by',
76 | 'message': 'How do you want to order posts?',
77 | 'choices': [
78 | 'Relevance',
79 | 'Newest',
80 | 'Active',
81 | 'Votes',
82 | ]
83 | },
84 | {
85 | 'type': 'confirm',
86 | 'name': 'verified_only',
87 | 'message':
88 | 'Do you want to only display posts with verified \
89 | answers?',
90 | },
91 | {
92 | 'type': 'confirm',
93 | 'name': 'display_comments',
94 | 'message':
95 | 'Do you want to display comments with questions and \
96 | answers?',
97 | },
98 | ]
99 |
100 | max_comments_questions = [
101 | {
102 | 'type': 'input',
103 | 'name': 'max_comments',
104 | 'message':
105 | 'What\'s the max number of comments to display per \
106 | question or answer?',
107 | 'validate': MaxCommentsValidator,
108 | }
109 | ]
110 |
111 | print_logo()
112 | answers = prompt(questions)
113 | if answers['display_comments']:
114 | answers['max_comments'] = prompt(
115 | max_comments_questions
116 | )['max_comments']
117 |
118 | with open('./.autostack.json', 'w') as autostack_json:
119 | json.dump(answers, autostack_json, indent=4)
120 |
--------------------------------------------------------------------------------
/autostack/error/__init__.py:
--------------------------------------------------------------------------------
1 | '''
2 | Authors: Elijah Sawyers, Benjamin Sanders
3 | Emails: elijahsawyers@gmail.com, ben.sanders97@gmail.com
4 | Date: 10/09/2019
5 | Overview: TODO: Write overview.
6 | '''
7 |
8 | from __future__ import absolute_import, division, print_function
9 |
10 | from autostack import print_logo
11 | from autostack.so_web_scraper import (
12 | accepted_posts,
13 | print_accepted_post
14 | )
15 |
16 | SYNTAX_ERRORS = [
17 | 'SyntaxError',
18 | 'IndentationError',
19 | 'TabError',
20 | ]
21 |
22 |
23 | def listen_for_errors(pipe):
24 | '''
25 | Reads output from a pipe until EOF, indicated by empty string. The
26 | output is parsed for errors.
27 |
28 | Parameter {File}: the pipe to read output from.
29 | '''
30 |
31 | print_logo()
32 | print_listening_for_errors()
33 |
34 | while True:
35 | output = pipe.readline()
36 |
37 | # Pipe closed.
38 | if output == '':
39 | break
40 |
41 | parse_output_for_error(output, pipe)
42 |
43 |
44 | def parse_output_for_error(output, pipe):
45 | '''
46 | Parses a line of output, and determines whether or not it is
47 | an error message. There are two types of errors, syntax errors
48 | and runtime errors. Syntax errors do not have a traceback but
49 | runtime errors do.
50 |
51 | e.g. without traceback:
52 | IndentationError: unexpected indent
53 | e.g. with traceback:
54 | Traceback (most recent call last):
55 | File "