pylint-output.txt

************* Module apigetpost
apigetpost.py:1: [C0111(missing-docstring), ] Missing module docstring
apigetpost.py:9: [C0111(missing-docstring), PostData] Missing class docstring
apigetpost.py:9: [R0902(too-many-instance-attributes), PostData] Too many instance attributes (15/7)
apigetpost.py:28: [C0111(missing-docstring), PostData.as_dict] Missing method docstring
apigetpost.py:53: [C0111(missing-docstring), api_get_post] Missing function docstring
apigetpost.py:80: [C1801(len-as-condition), api_get_post] Do not use `len(SEQUENCE)` to determine if a sequence is empty
apigetpost.py:5: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import requests"
apigetpost.py:6: [C0411(wrong-import-order), ] standard import "import html" should be placed before "import requests"
************* Module blacklists
blacklists.py:1: [C0111(missing-docstring), ] Missing module docstring
blacklists.py:9: [C0111(missing-docstring), load_blacklists] Missing function docstring
blacklists.py:18: [C0111(missing-docstring), BlacklistParser] Missing class docstring
blacklists.py:22: [C0111(missing-docstring), BlacklistParser.parse] Missing method docstring
blacklists.py:22: [R0201(no-self-use), BlacklistParser.parse] Method could be a function
blacklists.py:25: [C0111(missing-docstring), BlacklistParser.add] Missing method docstring
blacklists.py:28: [C0111(missing-docstring), BlacklistParser.remove] Missing method docstring
blacklists.py:31: [C0111(missing-docstring), BlacklistParser.exists] Missing method docstring
blacklists.py:35: [C0111(missing-docstring), BasicListParser] Missing class docstring
blacklists.py:55: [C0111(missing-docstring), BasicListParser.each] Missing method docstring
blacklists.py:78: [C0111(missing-docstring), TSVDictParser] Missing class docstring
blacklists.py:116: [C0111(missing-docstring), TSVDictParser.each] Missing method docstring
blacklists.py:147: [C0111(missing-docstring), Blacklist] Missing class docstring
blacklists.py:155: [W0622(redefined-builtin), Blacklist.__init__] Redefining built-in 'type'
blacklists.py:159: [C0111(missing-docstring), Blacklist.parse] Missing method docstring
blacklists.py:162: [C0111(missing-docstring), Blacklist.add] Missing method docstring
blacklists.py:165: [C0111(missing-docstring), Blacklist.remove] Missing method docstring
blacklists.py:168: [C0111(missing-docstring), Blacklist.each] Missing method docstring
blacklists.py:171: [C0111(missing-docstring), Blacklist.exists] Missing method docstring
************* Module bodyfetcher
bodyfetcher.py:151: [W0511(fixme), ] XXX: Any other possible exception?
bodyfetcher.py:271: [C0330(bad-continuation), ] Wrong continued indentation (remove 9 spaces).
                                         .format(quota=response["quota_remaining"]))
                                |        ^
bodyfetcher.py:1: [C0111(missing-docstring), ] Missing module docstring
bodyfetcher.py:20: [C0111(missing-docstring), BodyFetcher] Missing class docstring
bodyfetcher.py:51: [C0111(missing-docstring), BodyFetcher.add_to_queue] Missing method docstring
bodyfetcher.py:61: [R1714(consider-using-in), BodyFetcher.add_to_queue] Consider merging these comparisons with "in" to 'post_id in (3122, 51812)'
bodyfetcher.py:74: [C0123(unidiomatic-typecheck), BodyFetcher.add_to_queue] Using type() instead of isinstance() for a typecheck.
bodyfetcher.py:76: [C0123(unidiomatic-typecheck), BodyFetcher.add_to_queue] Using type() instead of isinstance() for a typecheck.
bodyfetcher.py:76: [C0123(unidiomatic-typecheck), BodyFetcher.add_to_queue] Using type() instead of isinstance() for a typecheck.
bodyfetcher.py:99: [C0111(missing-docstring), BodyFetcher.check_queue] Missing method docstring
bodyfetcher.py:121: [C0111(missing-docstring), BodyFetcher.print_queue] Missing method docstring
bodyfetcher.py:124: [C0111(missing-docstring), BodyFetcher.make_api_call_for_site] Missing method docstring
bodyfetcher.py:124: [R0914(too-many-locals), BodyFetcher.make_api_call_for_site] Too many local variables (42/15)
bodyfetcher.py:234: [W0703(broad-except), BodyFetcher.make_api_call_for_site] Catching too general exception Exception
bodyfetcher.py:290: [C1801(len-as-condition), BodyFetcher.make_api_call_for_site] Do not use `len(SEQUENCE)` to determine if a sequence is empty
bodyfetcher.py:298: [C1801(len-as-condition), BodyFetcher.make_api_call_for_site] Do not use `len(SEQUENCE)` to determine if a sequence is empty
bodyfetcher.py:342: [W0703(broad-except), BodyFetcher.make_api_call_for_site] Catching too general exception Exception
bodyfetcher.py:382: [W0703(broad-except), BodyFetcher.make_api_call_for_site] Catching too general exception Exception
bodyfetcher.py:376: [W0703(broad-except), BodyFetcher.make_api_call_for_site] Catching too general exception Exception
bodyfetcher.py:348: [R1702(too-many-nested-blocks), BodyFetcher.make_api_call_for_site] Too many nested blocks (6/5)
bodyfetcher.py:124: [R0915(too-many-statements), BodyFetcher.make_api_call_for_site] Too many statements (185/50)
bodyfetcher.py:7: [C0411(wrong-import-order), ] standard import "from operator import itemgetter" should be placed before "from spamhandling import handle_spam, check_if_spam"
bodyfetcher.py:8: [C0411(wrong-import-order), ] standard import "from datetime import datetime" should be placed before "from spamhandling import handle_spam, check_if_spam"
bodyfetcher.py:9: [C0411(wrong-import-order), ] standard import "import json" should be placed before "from spamhandling import handle_spam, check_if_spam"
bodyfetcher.py:10: [C0411(wrong-import-order), ] standard import "import time" should be placed before "from spamhandling import handle_spam, check_if_spam"
bodyfetcher.py:11: [C0411(wrong-import-order), ] standard import "import threading" should be placed before "from spamhandling import handle_spam, check_if_spam"
bodyfetcher.py:12: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "from spamhandling import handle_spam, check_if_spam"
bodyfetcher.py:13: [C0411(wrong-import-order), ] standard import "import copy" should be placed before "import requests"
bodyfetcher.py:16: [C0411(wrong-import-order), ] standard import "from itertools import chain" should be placed before "import requests"
************* Module chatcommands
chatcommands.py:33: [W0511(fixme), ] TODO: Do we need uid == -2 check?  Turn into "is_user_valid" check
chatcommands.py:1182: [W0511(fixme), ] TODO: Add check whether smokey reports in that room
chatcommands.py:1486: [W0511(fixme), ] TODO: Postdata refactor, figure out a better way to use apigetpost
chatcommands.py:1705: [W0511(fixme), ] TODO: implement an is_self() in chatcommunicate, don't use magic numbers
chatcommands.py:1: [C0302(too-many-lines), ] Too many lines in module (1971/1000)
chatcommands.py:1: [C0111(missing-docstring), ] Missing module docstring
chatcommands.py:12: [W0401(wildcard-import), ] Wildcard import datahandling
chatcommands.py:15: [W0401(wildcard-import), ] Wildcard import parsing
chatcommands.py:30: [W0401(wildcard-import), ] Wildcard import classes.feedback
chatcommands.py:41: [C0111(missing-docstring), null] Missing function docstring
chatcommands.py:57: [R1705(no-else-return), addblu] Unnecessary "elif" after "return"
chatcommands.py:58: [W0212(protected-access), addblu] Access to a protected member _client of a client class
chatcommands.py:80: [R1705(no-else-return), isblu] Unnecessary "else" after "return"
chatcommands.py:101: [R1705(no-else-return), rmblu] Unnecessary "else" after "return"
chatcommands.py:122: [R1705(no-else-return), addwlu] Unnecessary "elif" after "return"
chatcommands.py:142: [R1705(no-else-return), iswlu] Unnecessary "else" after "return"
chatcommands.py:163: [R1705(no-else-return), rmwlu] Unnecessary "else" after "return"
chatcommands.py:186: [C0111(missing-docstring), check_blacklist] Missing function docstring
chatcommands.py:225: [C0111(missing-docstring), format_blacklist_reasons] Missing function docstring
chatcommands.py:248: [W0212(protected-access), do_blacklist] Access to a protected member _client of a client class
chatcommands.py:256: [W0212(protected-access), do_blacklist] Access to a protected member _regex_core of a client class
chatcommands.py:262: [R1703(simplifiable-if-statement), do_blacklist] The if statement can be replaced with 'var = bool(test)'
chatcommands.py:286: [W0212(protected-access), do_blacklist] Access to a protected member _client of a client class
chatcommands.py:315: [W0703(broad-except), do_blacklist] Catching too general exception Exception
chatcommands.py:329: [W0613(unused-argument), blacklist_keyword] Unused argument 'pattern'
chatcommands.py:345: [W0613(unused-argument), watch] Unused argument 'pattern'
chatcommands.py:374: [W0212(protected-access), unblacklist] Access to a protected member _client of a client class
chatcommands.py:399: [W0703(broad-except), unblacklist] Catching too general exception Exception
chatcommands.py:358: [W0613(unused-argument), unblacklist] Unused argument 'item'
chatcommands.py:420: [W0621(redefined-outer-name), approve] Redefining name 'message' from outer scope (line 3)
chatcommands.py:405: [C0111(missing-docstring), approve] Missing function docstring
chatcommands.py:406: [W0212(protected-access), approve] Access to a protected member _client of a client class
chatcommands.py:412: [W0212(protected-access), approve] Access to a protected member _client of a client class
chatcommands.py:414: [W0212(protected-access), approve] Access to a protected member _client of a client class
chatcommands.py:433: [W0703(broad-except), approve] Catching too general exception Exception
chatcommands.py:441: [C0111(missing-docstring), remotediff] Missing function docstring
chatcommands.py:450: [C0111(missing-docstring), blame] Missing function docstring
chatcommands.py:451: [W0212(protected-access), blame] Access to a protected member _client of a client class
chatcommands.py:454: [W0212(protected-access), blame] Access to a protected member _client of a client class
chatcommands.py:458: [C0103(invalid-name), blame2] Argument name "x" doesn't conform to snake_case naming style
chatcommands.py:458: [C0111(missing-docstring), blame2] Missing function docstring
chatcommands.py:463: [W0212(protected-access), blame2] Access to a protected member _client of a client class
chatcommands.py:465: [W0212(protected-access), blame2] Access to a protected member _client of a client class
chatcommands.py:470: [W0212(protected-access), blame2] Access to a protected member _client of a client class
chatcommands.py:495: [R1705(no-else-return), coffee] Unnecessary "else" after "return"
chatcommands.py:525: [R1705(no-else-return), tea] Unnecessary "else" after "return"
chatcommands.py:571: [W0105(pointless-string-statement), ] String statement has no effect
chatcommands.py:587: [W0212(protected-access), block] Access to a protected member _client of a client class
chatcommands.py:589: [W0212(protected-access), block] Access to a protected member _client of a client class
chatcommands.py:591: [W0212(protected-access), block] Access to a protected member _client of a client class
chatcommands.py:603: [W0212(protected-access), unblock] Access to a protected member _client of a client class
chatcommands.py:605: [W0212(protected-access), unblock] Access to a protected member _client of a client class
chatcommands.py:608: [W0212(protected-access), unblock] Access to a protected member _client of a client class
chatcommands.py:641: [E0102(function-redefined), metasmoke] function already defined line 12
chatcommands.py:641: [C0111(missing-docstring), metasmoke] Missing function docstring
chatcommands.py:690: [R1720(no-else-raise), welcome] Unnecessary "else" after "raise"
chatcommands.py:725: [C0113(unneeded-not), pull] Consider changing "not alias_used == 'pull-force'" to "alias_used != 'pull-force'"
chatcommands.py:743: [R1705(no-else-return), pull] Unnecessary "else" after "return"
chatcommands.py:764: [W0212(protected-access), sync_remote] Access to a protected member _client of a client class
chatcommands.py:774: [C0111(missing-docstring), git] Missing function docstring
chatcommands.py:782: [R1705(no-else-return), git] Unnecessary "elif" after "return"
chatcommands.py:774: [R1710(inconsistent-return-statements), git] Either all return statements in a function should return an expression, or none of them should.
chatcommands.py:799: [W0212(protected-access), reboot] Access to a protected member _client of a client class
chatcommands.py:833: [W0212(protected-access), amicodeprivileged] Access to a protected member _client of a client class
chatcommands.py:867: [W0622(redefined-builtin), inqueue] Redefining built-in 'id'
chatcommands.py:860: [C0111(missing-docstring), inqueue] Missing function docstring
chatcommands.py:875: [C0111(missing-docstring), listening] Missing function docstring
chatcommands.py:881: [E0102(function-redefined), last_feedbacked] function already defined line 12
chatcommands.py:881: [C0111(missing-docstring), last_feedbacked] Missing function docstring
chatcommands.py:895: [W0212(protected-access), stappit] Access to a protected member _client of a client class
chatcommands.py:901: [C0111(missing-docstring), td_format] Missing function docstring
chatcommands.py:940: [C0111(missing-docstring), stopflagging] Missing function docstring
chatcommands.py:962: [W0212(protected-access), standby] Access to a protected member _client of a client class
chatcommands.py:972: [R0914(too-many-locals), test] Too many local variables (16/15)
chatcommands.py:1027: [R1720(no-else-raise), test] Unnecessary "elif" after "raise"
chatcommands.py:1027: [C1801(len-as-condition), test] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1031: [C1801(len-as-condition), test] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1058: [C1801(len-as-condition), test] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1063: [C1801(len-as-condition), test] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1069: [C1801(len-as-condition), test] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:972: [R0915(too-many-statements), test] Too many statements (55/50)
chatcommands.py:1076: [C0103(invalid-name), bisect_regex] Argument name "s" doesn't conform to snake_case naming style
chatcommands.py:1076: [C0111(missing-docstring), bisect_regex] Missing function docstring
chatcommands.py:1091: [C0103(invalid-name), bisect] Argument name "s" doesn't conform to snake_case naming style
chatcommands.py:1091: [C0111(missing-docstring), bisect] Missing function docstring
chatcommands.py:1107: [R1705(no-else-return), bisect] Unnecessary "else" after "return"
chatcommands.py:1151: [W0212(protected-access), whoami] Access to a protected member _br of a client class
chatcommands.py:1151: [W0212(protected-access), whoami] Access to a protected member _client of a client class
chatcommands.py:1164: [W0212(protected-access), allnotificationsites] Access to a protected member _client of a client class
chatcommands.py:1166: [C1801(len-as-condition), allnotificationsites] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1183: [W0212(protected-access), notify] Access to a protected member _client of a client class
chatcommands.py:1186: [R1705(no-else-return), notify] Unnecessary "elif" after "return"
chatcommands.py:1188: [W0212(protected-access), notify] Access to a protected member _client of a client class
chatcommands.py:1183: [W0612(unused-variable), notify] Unused variable 'full_site'
chatcommands.py:1199: [C0111(missing-docstring), migrate_notifications] Missing function docstring
chatcommands.py:1232: [W0212(protected-access), unnotify] Access to a protected member _client of a client class
chatcommands.py:1236: [W0212(protected-access), unnotify] Access to a protected member _client of a client class
chatcommands.py:1251: [W0212(protected-access), willbenotified] Access to a protected member _client of a client class
chatcommands.py:1266: [R0914(too-many-locals), whois] Too many local variables (17/15)
chatcommands.py:1287: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1305: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1306: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1307: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1311: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1312: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1313: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1317: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1318: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1319: [W0212(protected-access), whois] Access to a protected member _client of a client class
chatcommands.py:1348: [C0111(missing-docstring), invite] Missing function docstring
chatcommands.py:1349: [W0212(protected-access), invite] Access to a protected member _client of a client class
chatcommands.py:1352: [W0212(protected-access), invite] Access to a protected member _client of a client class
chatcommands.py:1368: [W0212(protected-access), report] Access to a protected member _client of a client class
chatcommands.py:1381: [W0212(protected-access), report] Access to a protected member _client of a client class
chatcommands.py:1386: [R0123(literal-comparison), report] Comparison to literal
chatcommands.py:1404: [W0212(protected-access), report] Access to a protected member _client of a client class
chatcommands.py:1359: [R1710(inconsistent-return-statements), report] Either all return statements in a function should return an expression, or none of them should.
chatcommands.py:1410: [R0914(too-many-locals), allspam] Too many local variables (24/15)
chatcommands.py:1419: [W0212(protected-access), allspam] Access to a protected member _client of a client class
chatcommands.py:1448: [C1801(len-as-condition), allspam] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1477: [C1801(len-as-condition), allspam] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1484: [W0212(protected-access), allspam] Access to a protected member _client of a client class
chatcommands.py:1524: [C1801(len-as-condition), allspam] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1540: [W0212(protected-access), allspam] Access to a protected member _client of a client class
chatcommands.py:1491: [W0612(unused-variable), allspam] Unused variable 'discard'
chatcommands.py:1410: [R0915(too-many-statements), allspam] Too many statements (84/50)
chatcommands.py:1543: [C0111(missing-docstring), report_posts] Missing function docstring
chatcommands.py:1543: [R0913(too-many-arguments), report_posts] Too many arguments (6/5)
chatcommands.py:1543: [R0914(too-many-locals), report_posts] Too many local variables (29/15)
chatcommands.py:1614: [W0212(protected-access), report_posts] Access to a protected member _is_answer of a client class
chatcommands.py:1615: [W0212(protected-access), report_posts] Access to a protected member _parent of a client class
chatcommands.py:1620: [W0125(using-constant-test), report_posts] Using a conditional statement with a constant value
chatcommands.py:1671: [C1801(len-as-condition), report_posts] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommands.py:1543: [R0915(too-many-statements), report_posts] Too many statements (81/50)
chatcommands.py:1677: [W0621(redefined-outer-name), feedback] Redefining name 'feedback' from outer scope (line 1677)
chatcommands.py:1677: [C0111(missing-docstring), feedback] Missing function docstring
chatcommands.py:1691: [C0111(missing-docstring), dump_data] Missing function docstring
chatcommands.py:1697: [E0602(undefined-variable), dump_data] Undefined variable 'log_exception'
chatcommands.py:1703: [C0111(missing-docstring), load_data] Missing function docstring
chatcommands.py:1712: [E0602(undefined-variable), load_data] Undefined variable 'log_exception'
chatcommands.py:1734: [W0703(broad-except), delete_force] Catching too general exception Exception
chatcommands.py:1748: [R1705(no-else-return), delete] Unnecessary "else" after "return"
chatcommands.py:1757: [W0703(broad-except), delete] Catching too general exception Exception
chatcommands.py:1740: [R1710(inconsistent-return-statements), delete] Either all return statements in a function should return an expression, or none of them should.
chatcommands.py:1780: [W0621(redefined-outer-name), false] Redefining name 'feedback' from outer scope (line 1677)
chatcommands.py:1816: [W0703(broad-except), false] Catching too general exception Exception
chatcommands.py:1827: [W0621(redefined-outer-name), ignore] Redefining name 'feedback' from outer scope (line 1677)
chatcommands.py:1856: [W0621(redefined-outer-name), naa] Redefining name 'feedback' from outer scope (line 1677)
chatcommands.py:1888: [W0621(redefined-outer-name), true] Redefining name 'feedback' from outer scope (line 1677)
chatcommands.py:1912: [W0212(protected-access), true] Access to a protected member _client of a client class
chatcommands.py:1907: [W0612(unused-variable), true] Unused variable 'e'
chatcommands.py:1939: [R1720(no-else-raise), why] Unnecessary "else" after "raise"
chatcommands.py:1944: [R1705(no-else-return), why] Unnecessary "else" after "return"
chatcommands.py:1968: [R1705(no-else-return), autoflagged] Unnecessary "else" after "return"
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import os from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import metasmoke from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import last_feedbacked from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import zlib from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import base64 from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import math from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import blacklists from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import PICKLE_STORAGE from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import Any from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import load_files from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import filter_auto_ignored_posts from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import get_blacklisted_user_data from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import is_ignored_post from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import is_auto_ignored_post from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import add_auto_ignored_post from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import add_why from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import filter_why from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import add_post_site_id_link from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import get_post_site_id_link from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import add_or_update_api_data from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import clear_api_data from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import store_bodyfetcher_queue from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import store_bodyfetcher_max_ids from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import store_queue_timings from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import append_to_latest_questions from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import refresh_sites from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import check_site_and_get_full_name from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import get_user_ids_on_notification_list from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import get_user_names_on_notification_list from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import append_pings from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import has_community_bumped_post from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import dump_cookies from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import api_parameter_from_link from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import post_id_from_link from wildcard import
chatcommands.py:12: [W0614(unused-wildcard-import), ] Unused import ErrorLogs from wildcard import
chatcommands.py:14: [W0611(unused-import), ] Unused load_blacklists imported from blacklists
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import globalvars from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import msg_parser_regex from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import msg_parser from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import fetch_post_url_from_msg_content from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import fetch_post_id_and_site_from_msg_content from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import fetch_owner_url_from_msg_content from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import fetch_title_from_msg_content from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import unescape_title from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import escape_markdown from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import sanitize_title from wildcard import
chatcommands.py:15: [W0614(unused-wildcard-import), ] Unused import user_url_to_shortlink from wildcard import
chatcommands.py:30: [W0614(unused-wildcard-import), ] Unused import itertools from wildcard import
chatcommands.py:30: [W0614(unused-wildcard-import), ] Unused import FEEDBACK_REGEX from wildcard import
chatcommands.py:9: [C0411(wrong-import-order), ] standard import "from datetime import datetime" should be placed before "from chatcommunicate import add_room, block_room, CmdException, command, get_report_data, is_privileged, message, tell_rooms, tell_rooms_with, get_message"
chatcommands.py:18: [C0411(wrong-import-order), ] standard import "import threading" should be placed before "from chatcommunicate import add_room, block_room, CmdException, command, get_report_data, is_privileged, message, tell_rooms, tell_rooms_with, get_message"
chatcommands.py:19: [C0411(wrong-import-order), ] standard import "import random" should be placed before "from chatcommunicate import add_room, block_room, CmdException, command, get_report_data, is_privileged, message, tell_rooms, tell_rooms_with, get_message"
chatcommands.py:20: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "from chatcommunicate import add_room, block_room, CmdException, command, get_report_data, is_privileged, message, tell_rooms, tell_rooms_with, get_message"
chatcommands.py:21: [C0411(wrong-import-order), ] standard import "import sys" should be placed before "import requests"
chatcommands.py:22: [C0411(wrong-import-order), ] standard import "import os" should be placed before "import requests"
chatcommands.py:23: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import requests"
chatcommands.py:24: [C0411(wrong-import-order), ] standard import "from html import unescape" should be placed before "import requests"
chatcommands.py:25: [C0411(wrong-import-order), ] standard import "from ast import literal_eval" should be placed before "import requests"
chatcommands.py:27: [C0411(wrong-import-order), ] third party import "import regex" should be placed before "from chatcommunicate import add_room, block_room, CmdException, command, get_report_data, is_privileged, message, tell_rooms, tell_rooms_with, get_message"
************* Module chatcommunicate
chatcommunicate.py:1: [C0111(missing-docstring), ] Missing module docstring
chatcommunicate.py:2: [E0401(import-error), ] Unable to import 'chatexchange'
chatcommunicate.py:3: [E0401(import-error), ] Unable to import 'chatexchange.browser'
chatcommunicate.py:4: [E0401(import-error), ] Unable to import 'chatexchange.messages'
chatcommunicate.py:17: [E0401(import-error), ] Unable to import 'yaml'
chatcommunicate.py:33: [C0111(missing-docstring), RoomData] Missing class docstring
chatcommunicate.py:33: [R0903(too-few-public-methods), RoomData] Too few public methods (0/2)
chatcommunicate.py:40: [C0111(missing-docstring), CmdException] Missing class docstring
chatcommunicate.py:44: [C0103(invalid-name), ] Constant name "_prefix_commands" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:45: [C0103(invalid-name), ] Constant name "_reply_commands" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:47: [C0103(invalid-name), ] Constant name "_clients" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:53: [C0103(invalid-name), ] Constant name "_command_rooms" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:54: [C0103(invalid-name), ] Constant name "_watcher_rooms" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:55: [C0103(invalid-name), ] Constant name "_room_roles" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:56: [C0103(invalid-name), ] Constant name "_privileges" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:58: [C0103(invalid-name), ] Constant name "_global_block" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:59: [C0103(invalid-name), ] Constant name "_rooms" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:60: [C0103(invalid-name), ] Constant name "_last_messages" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:61: [C0103(invalid-name), ] Constant name "_msg_queue" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:63: [C0103(invalid-name), ] Constant name "_pickle_run" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:66: [C0111(missing-docstring), init] Missing function docstring
chatcommunicate.py:67: [W0603(global-statement), init] Using the global statement
chatcommunicate.py:67: [C0103(invalid-name), init] Constant name "_clients" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:68: [W0603(global-statement), init] Using the global statement
chatcommunicate.py:68: [C0103(invalid-name), init] Constant name "_rooms" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:69: [W0602(global-variable-not-assigned), init] Using global for '_room_data' but no assignment is done
chatcommunicate.py:69: [C0103(invalid-name), init] Constant name "_room_data" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:70: [W0603(global-statement), init] Using the global statement
chatcommunicate.py:70: [C0103(invalid-name), init] Constant name "_last_messages" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:72: [C0201(consider-iterating-dictionary), init] Consider iterating the dictionary directly instead of calling .keys()
chatcommunicate.py:78: [W0212(protected-access), init] Access to a protected member _remove_pickle of a client class
chatcommunicate.py:99: [W0703(broad-except), init] Catching too general exception Exception
chatcommunicate.py:87: [W0612(unused-variable), init] Unused variable 'e'
chatcommunicate.py:88: [W0612(unused-variable), init] Unused variable 'exc_tb'
chatcommunicate.py:95: [W0612(unused-variable), init] Unused variable 'retry'
chatcommunicate.py:128: [C0111(missing-docstring), join_command_rooms] Missing function docstring
chatcommunicate.py:138: [C0111(missing-docstring), parse_room_config] Missing function docstring
chatcommunicate.py:138: [R0914(too-many-locals), parse_room_config] Too many local variables (18/15)
chatcommunicate.py:159: [R1718(consider-using-set-comprehension), parse_room_config] Consider using a set comprehension
chatcommunicate.py:161: [R1718(consider-using-set-comprehension), parse_room_config] Consider using a set comprehension
chatcommunicate.py:178: [R1718(consider-using-set-comprehension), parse_room_config] Consider using a set comprehension
chatcommunicate.py:181: [W0612(unused-variable), parse_room_config] Unused variable 'before'
chatcommunicate.py:192: [C0111(missing-docstring), add_room] Missing function docstring
chatcommunicate.py:200: [C0111(missing-docstring), pickle_last_messages] Missing function docstring
chatcommunicate.py:209: [C0111(missing-docstring), send_messages] Missing function docstring
chatcommunicate.py:222: [W0212(protected-access), send_messages] Access to a protected member _do_action_despite_throttling of a client class
chatcommunicate.py:222: [W0212(protected-access), send_messages] Access to a protected member _client of a client class
chatcommunicate.py:225: [W0212(protected-access), send_messages] Access to a protected member _client of a client class
chatcommunicate.py:210: [R1702(too-many-nested-blocks), send_messages] Too many nested blocks (6/5)
chatcommunicate.py:239: [W0212(protected-access), send_messages] Access to a protected member _client of a client class
chatcommunicate.py:245: [W0212(protected-access), send_messages] Access to a protected member _client of a client class
chatcommunicate.py:210: [R1702(too-many-nested-blocks), send_messages] Too many nested blocks (6/5)
chatcommunicate.py:264: [W0621(redefined-outer-name), on_msg] Redefining name 'message' from outer scope (line 497)
chatcommunicate.py:258: [C0111(missing-docstring), on_msg] Missing function docstring
chatcommunicate.py:259: [W0603(global-statement), on_msg] Using the global statement
chatcommunicate.py:259: [C0103(invalid-name), on_msg] Constant name "_room_roles" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:268: [W0212(protected-access), on_msg] Access to a protected member _br of a client class
chatcommunicate.py:281: [W0212(protected-access), on_msg] Access to a protected member _br of a client class
chatcommunicate.py:314: [C0111(missing-docstring), tell_rooms_with] Missing function docstring
chatcommunicate.py:318: [C0111(missing-docstring), tell_rooms_without] Missing function docstring
chatcommunicate.py:322: [C0111(missing-docstring), tell_rooms] Missing function docstring
chatcommunicate.py:322: [R0914(too-many-locals), tell_rooms] Too many local variables (18/15)
chatcommunicate.py:323: [W0603(global-statement), tell_rooms] Using the global statement
chatcommunicate.py:323: [C0103(invalid-name), tell_rooms] Constant name "_rooms" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:336: [W0640(cell-var-from-loop), tell_rooms.<lambda>] Cell variable room defined in loop
chatcommunicate.py:352: [W0212(protected-access), tell_rooms] Access to a protected member _client of a client class
chatcommunicate.py:355: [W0212(protected-access), tell_rooms] Access to a protected member _client of a client class
chatcommunicate.py:378: [C0111(missing-docstring), get_last_messages] Missing function docstring
chatcommunicate.py:379: [W0212(protected-access), get_last_messages] Access to a protected member _client of a client class
chatcommunicate.py:385: [W0212(protected-access), get_last_messages] Access to a protected member _client of a client class
chatcommunicate.py:388: [W0621(redefined-outer-name), get_report_data] Redefining name 'message' from outer scope (line 497)
chatcommunicate.py:388: [C0111(missing-docstring), get_report_data] Missing function docstring
chatcommunicate.py:389: [W0212(protected-access), get_report_data] Access to a protected member _client of a client class
chatcommunicate.py:391: [R1705(no-else-return), get_report_data] Unnecessary "else" after "return"
chatcommunicate.py:388: [R1710(inconsistent-return-statements), get_report_data] Either all return statements in a function should return an expression, or none of them should.
chatcommunicate.py:400: [C0111(missing-docstring), is_privileged] Missing function docstring
chatcommunicate.py:402: [W0212(protected-access), is_privileged] Access to a protected member _client of a client class
chatcommunicate.py:405: [W0621(redefined-outer-name), block_room] Redefining name 'time' from outer scope (line 16)
chatcommunicate.py:405: [C0111(missing-docstring), block_room] Missing function docstring
chatcommunicate.py:406: [W0603(global-statement), block_room] Using the global statement
chatcommunicate.py:406: [C0103(invalid-name), block_room] Constant name "_global_block" doesn't conform to UPPER_CASE naming style
chatcommunicate.py:414: [C0111(missing-docstring), ChatCommand] Missing class docstring
chatcommunicate.py:414: [R0902(too-many-instance-attributes), ChatCommand] Too many instance attributes (8/7)
chatcommunicate.py:415: [R0913(too-many-arguments), ChatCommand.__init__] Too many arguments (8/5)
chatcommunicate.py:429: [W0212(protected-access), ChatCommand.__call__] Access to a protected member _client of a client class
chatcommunicate.py:459: [W0703(broad-except), ChatCommand.__call__] Catching too general exception Exception
chatcommunicate.py:472: [C0111(missing-docstring), command] Missing function docstring
chatcommunicate.py:497: [C0111(missing-docstring), message] Missing function docstring
chatcommunicate.py:502: [W0622(redefined-builtin), get_message] Redefining built-in 'id'
chatcommunicate.py:502: [C0103(invalid-name), get_message] Argument name "id" doesn't conform to snake_case naming style
chatcommunicate.py:502: [C0111(missing-docstring), get_message] Missing function docstring
chatcommunicate.py:508: [C0111(missing-docstring), dispatch_command] Missing function docstring
chatcommunicate.py:525: [R1705(no-else-return), dispatch_command] Unnecessary "else" after "return"
chatcommunicate.py:530: [R1705(no-else-return), dispatch_command] Unnecessary "elif" after "return"
chatcommunicate.py:540: [R1705(no-else-return), dispatch_command] Unnecessary "elif" after "return"
chatcommunicate.py:508: [R1710(inconsistent-return-statements), dispatch_command] Either all return statements in a function should return an expression, or none of them should.
chatcommunicate.py:508: [R0911(too-many-return-statements), dispatch_command] Too many return statements (8/6)
chatcommunicate.py:549: [C0111(missing-docstring), dispatch_reply_command] Missing function docstring
chatcommunicate.py:568: [R1705(no-else-return), dispatch_reply_command] Unnecessary "elif" after "return"
chatcommunicate.py:549: [R1710(inconsistent-return-statements), dispatch_reply_command] Either all return statements in a function should return an expression, or none of them should.
chatcommunicate.py:601: [W0621(redefined-outer-name), dispatch_shorthand_command] Redefining name 'message' from outer scope (line 497)
chatcommunicate.py:584: [C0111(missing-docstring), dispatch_shorthand_command] Missing function docstring
chatcommunicate.py:587: [C1801(len-as-condition), dispatch_shorthand_command] Do not use `len(SEQUENCE)` to determine if a sequence is empty
chatcommunicate.py:584: [R1710(inconsistent-return-statements), dispatch_shorthand_command] Either all return statements in a function should return an expression, or none of them should.
chatcommunicate.py:6: [C0411(wrong-import-order), ] standard import "import collections" should be placed before "from chatexchange import events"
chatcommunicate.py:7: [C0411(wrong-import-order), ] standard import "import itertools" should be placed before "from chatexchange import events"
chatcommunicate.py:8: [C0411(wrong-import-order), ] standard import "import os" should be placed before "from chatexchange import events"
chatcommunicate.py:9: [C0411(wrong-import-order), ] standard import "import os.path" should be placed before "from chatexchange import events"
chatcommunicate.py:10: [C0411(wrong-import-order), ] standard import "import pickle" should be placed before "from chatexchange import events"
chatcommunicate.py:11: [C0411(wrong-import-order), ] standard import "import queue" should be placed before "from chatexchange import events"
chatcommunicate.py:12: [C0411(wrong-import-order), ] third party import "import regex" should be placed before "from chatexchange import events"
chatcommunicate.py:13: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "from chatexchange import events"
chatcommunicate.py:14: [C0411(wrong-import-order), ] standard import "import sys" should be placed before "import regex"
chatcommunicate.py:15: [C0411(wrong-import-order), ] standard import "import threading" should be placed before "import regex"
chatcommunicate.py:16: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import regex"
chatcommunicate.py:18: [C0411(wrong-import-order), ] standard import "import shlex" should be placed before "import regex"
************* Module chatexchange_extension
chatexchange_extension.py:1: [C0111(missing-docstring), ] Missing module docstring
chatexchange_extension.py:2: [E0401(import-error), ] Unable to import 'chatexchange'
chatexchange_extension.py:8: [C0111(missing-docstring), Room] Missing class docstring
chatexchange_extension.py:9: [C0111(missing-docstring), Room.watch_socket] Missing method docstring
chatexchange_extension.py:21: [W0212(protected-access), Room.watch_socket] Access to a protected member _br of a client class
chatexchange_extension.py:8: [R0903(too-few-public-methods), Room] Too few public methods (1/2)
chatexchange_extension.py:24: [C0111(missing-docstring), Client] Missing class docstring
chatexchange_extension.py:29: [C0111(missing-docstring), Client.get_room] Missing method docstring
chatexchange_extension.py:24: [R0903(too-few-public-methods), Client] Too few public methods (1/2)
chatexchange_extension.py:3: [W0611(unused-import), ] Unused import sys
chatexchange_extension.py:5: [W0611(unused-import), ] Unused log imported from helpers
chatexchange_extension.py:3: [C0411(wrong-import-order), ] standard import "import sys" should be placed before "from chatexchange import client, events, rooms"
chatexchange_extension.py:4: [C0411(wrong-import-order), ] standard import "from datetime import datetime" should be placed before "from chatexchange import client, events, rooms"
************* Module datahandling
datahandling.py:1: [C0111(missing-docstring), ] Missing module docstring
datahandling.py:20: [C0103(invalid-name), ] Constant name "last_feedbacked" doesn't conform to UPPER_CASE naming style
datahandling.py:24: [C0111(missing-docstring), Any] Missing class docstring
datahandling.py:24: [R0903(too-few-public-methods), Any] Too few public methods (1/2)
datahandling.py:82: [C0111(missing-docstring), load_files] Missing function docstring
datahandling.py:120: [C0111(missing-docstring), filter_auto_ignored_posts] Missing function docstring
datahandling.py:136: [C0111(missing-docstring), is_false_positive] Missing function docstring
datahandling.py:141: [C0111(missing-docstring), is_whitelisted_user] Missing function docstring
datahandling.py:146: [C0111(missing-docstring), is_blacklisted_user] Missing function docstring
datahandling.py:150: [C0111(missing-docstring), get_blacklisted_user_data] Missing function docstring
datahandling.py:158: [C0111(missing-docstring), is_ignored_post] Missing function docstring
datahandling.py:163: [C0111(missing-docstring), is_auto_ignored_post] Missing function docstring
datahandling.py:170: [C0111(missing-docstring), update_code_privileged_users_list] Missing function docstring
datahandling.py:175: [C0111(missing-docstring), is_code_privileged] Missing function docstring
datahandling.py:180: [E1135(unsupported-membership-test), is_code_privileged] Value 'GlobalVars.code_privileged_users' doesn't support membership test
datahandling.py:183: [C0111(missing-docstring), update_reason_weights] Missing function docstring
datahandling.py:194: [C0111(missing-docstring), resolve_ms_link] Missing function docstring
datahandling.py:197: [R1705(no-else-return), resolve_ms_link] Unnecessary "elif" after "return"
datahandling.py:222: [C0111(missing-docstring), add_whitelisted_user] Missing function docstring
datahandling.py:229: [C0111(missing-docstring), add_blacklisted_user] Missing function docstring
datahandling.py:236: [C0111(missing-docstring), add_auto_ignored_post] Missing function docstring
datahandling.py:243: [C0111(missing-docstring), add_false_positive] Missing function docstring
datahandling.py:249: [W0603(global-statement), add_false_positive] Using the global statement
datahandling.py:249: [C0103(invalid-name), add_false_positive] Constant name "last_feedbacked" doesn't conform to UPPER_CASE naming style
datahandling.py:254: [C0111(missing-docstring), add_ignored_post] Missing function docstring
datahandling.py:260: [W0603(global-statement), add_ignored_post] Using the global statement
datahandling.py:260: [C0103(invalid-name), add_ignored_post] Constant name "last_feedbacked" doesn't conform to UPPER_CASE naming style
datahandling.py:264: [C0111(missing-docstring), remove_blacklisted_user] Missing function docstring
datahandling.py:274: [C0111(missing-docstring), remove_whitelisted_user] Missing function docstring
datahandling.py:282: [C0111(missing-docstring), add_why] Missing function docstring
datahandling.py:290: [C0111(missing-docstring), get_why] Missing function docstring
datahandling.py:298: [C0111(missing-docstring), filter_why] Missing function docstring
datahandling.py:302: [C0111(missing-docstring), add_post_site_id_link] Missing function docstring
datahandling.py:306: [C0111(missing-docstring), get_post_site_id_link] Missing function docstring
datahandling.py:312: [C0111(missing-docstring), add_or_update_api_data] Missing function docstring
datahandling.py:320: [C0111(missing-docstring), clear_api_data] Missing function docstring
datahandling.py:325: [C0111(missing-docstring), store_bodyfetcher_queue] Missing function docstring
datahandling.py:329: [C0111(missing-docstring), store_bodyfetcher_max_ids] Missing function docstring
datahandling.py:333: [C0111(missing-docstring), store_queue_timings] Missing function docstring
datahandling.py:340: [C0111(missing-docstring), append_to_latest_questions] Missing function docstring
datahandling.py:347: [C0111(missing-docstring), has_already_been_posted] Missing function docstring
datahandling.py:347: [W0613(unused-argument), has_already_been_posted] Unused argument 'title'
datahandling.py:358: [C0111(missing-docstring), fetch_lines_from_error_log] Missing function docstring
datahandling.py:369: [R1705(no-else-return), fetch_lines_from_error_log] Unnecessary "else" after "return"
datahandling.py:379: [C0111(missing-docstring), refresh_sites] Missing function docstring
datahandling.py:406: [C0111(missing-docstring), check_site_and_get_full_name] Missing function docstring
datahandling.py:407: [C1801(len-as-condition), check_site_and_get_full_name] Do not use `len(SEQUENCE)` to determine if a sequence is empty
datahandling.py:414: [R1714(consider-using-in), check_site_and_get_full_name] Consider merging these comparisons with "in" to 'site in (full_name, short_name)'
datahandling.py:423: [C0111(missing-docstring), add_to_notification_list] Missing function docstring
datahandling.py:437: [C0111(missing-docstring), remove_from_notification_list] Missing function docstring
datahandling.py:451: [C0111(missing-docstring), will_i_be_notified] Missing function docstring
datahandling.py:460: [C0111(missing-docstring), remove_all_from_notification_list] Missing function docstring
datahandling.py:472: [C0111(missing-docstring), get_all_notification_sites] Missing function docstring
datahandling.py:480: [C0111(missing-docstring), get_user_ids_on_notification_list] Missing function docstring
datahandling.py:488: [C0111(missing-docstring), get_user_names_on_notification_list] Missing function docstring
datahandling.py:490: [W0212(protected-access), get_user_names_on_notification_list] Access to a protected member _br of a client class
datahandling.py:505: [C0111(missing-docstring), append_pings] Missing function docstring
datahandling.py:506: [C1801(len-as-condition), append_pings] Do not use `len(SEQUENCE)` to determine if a sequence is empty
datahandling.py:515: [C0111(missing-docstring), has_community_bumped_post] Missing function docstring
datahandling.py:531: [C0111(missing-docstring), add_or_update_multiple_reporter] Missing function docstring
datahandling.py:531: [R1710(inconsistent-return-statements), add_or_update_multiple_reporter] Either all return statements in a function should return an expression, or none of them should.
datahandling.py:541: [C0111(missing-docstring), can_report_now] Missing function docstring
datahandling.py:554: [C0111(missing-docstring), dump_cookies] Missing function docstring
datahandling.py:558: [C0111(missing-docstring), SmokeyTransfer] Missing class docstring
datahandling.py:571: [C0111(missing-docstring), SmokeyTransfer.dump] Missing method docstring
datahandling.py:571: [R0914(too-many-locals), SmokeyTransfer.dump] Too many local variables (16/15)
datahandling.py:580: [W0612(unused-variable), SmokeyTransfer.dump] Unused variable 'obj_type'
datahandling.py:604: [C0103(invalid-name), SmokeyTransfer.load] Argument name "s" doesn't conform to snake_case naming style
datahandling.py:604: [C0111(missing-docstring), SmokeyTransfer.load] Missing method docstring
datahandling.py:604: [R0914(too-many-locals), SmokeyTransfer.load] Too many local variables (19/15)
datahandling.py:618: [C0123(unidiomatic-typecheck), SmokeyTransfer.load] Using type() instead of isinstance() for a typecheck.
datahandling.py:604: [W0613(unused-argument), SmokeyTransfer.load] Unused argument 'merge'
datahandling.py:624: [W0612(unused-variable), SmokeyTransfer.load] Unused variable 'obj_type'
datahandling.py:624: [W0612(unused-variable), SmokeyTransfer.load] Unused variable 'proc'
datahandling.py:9: [W0611(unused-import), ] Unused import json
datahandling.py:8: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "import metasmoke"
datahandling.py:9: [C0411(wrong-import-order), ] standard import "import json" should be placed before "import requests"
datahandling.py:10: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import requests"
datahandling.py:11: [C0411(wrong-import-order), ] standard import "import math" should be placed before "import requests"
datahandling.py:13: [C0411(wrong-import-order), ] third party import "import regex" should be placed before "import metasmoke"
************* Module deletionwatcher
deletionwatcher.py:117: [W0311(bad-indentation), ] Bad indentation. Found 16 spaces, expected 12
deletionwatcher.py:1: [C0111(missing-docstring), ] Missing module docstring
deletionwatcher.py:9: [E0401(import-error), ] Unable to import 'websocket'
deletionwatcher.py:11: [E0401(import-error), ] Unable to import 'bs4'
deletionwatcher.py:23: [C0111(missing-docstring), DeletionWatcher] Missing class docstring
deletionwatcher.py:46: [R1702(too-many-nested-blocks), DeletionWatcher._start] Too many nested blocks (8/5)
deletionwatcher.py:73: [W0621(redefined-outer-name), DeletionWatcher.subscribe] Redefining name 'pickle' from outer scope (line 4)
deletionwatcher.py:73: [C0111(missing-docstring), DeletionWatcher.subscribe] Missing method docstring
deletionwatcher.py:132: [W0621(redefined-outer-name), DeletionWatcher._check_batch] Redefining name 'json' from outer scope (line 2)
deletionwatcher.py:153: [C0111(missing-docstring), DeletionWatcher.update_site_id_list] Missing method docstring
deletionwatcher.py:13: [W0611(unused-import), ] Unused import chatcommunicate
deletionwatcher.py:6: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import requests"
deletionwatcher.py:7: [C0411(wrong-import-order), ] standard import "import threading" should be placed before "import requests"
deletionwatcher.py:12: [C0411(wrong-import-order), ] standard import "from urllib.parse import urlparse" should be placed before "import requests"
************* Module excepthook
excepthook.py:1: [C0111(missing-docstring), ] Missing module docstring
excepthook.py:8: [E0401(import-error), ] Unable to import 'websocket'
excepthook.py:15: [C0103(invalid-name), uncaught_exception] Argument name "tb" doesn't conform to snake_case naming style
excepthook.py:15: [C0111(missing-docstring), uncaught_exception] Missing function docstring
excepthook.py:47: [W0706(try-except-raise), install_thread_excepthook.init.run_with_except_hook] The except handler raises immediately
excepthook.py:45: [W0703(broad-except), install_thread_excepthook.init.run_with_except_hook] Catching too general exception Exception
excepthook.py:3: [W0611(unused-import), ] Unused import os
excepthook.py:4: [W0611(unused-import), ] Unused import traceback
excepthook.py:10: [W0611(unused-import), ] Unused log imported from helpers
excepthook.py:9: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "from websocket import WebSocketConnectionClosedException"
************* Module findspam
findspam.py:869: [W0511(fixme), ] FIXME/TODO: Remove "help" once WebApps has stopped being hit with gmail help spam. (added: Art, 2018-10-17)
findspam.py:1178: [W0511(fixme), ] ######## FIXME: code duplication
findspam.py:1182: [W0511(fixme), ] ######## TODO: allow blocking of IP ranges with regex or CIDR
findspam.py:1790: [W0511(fixme), ] TODO: migrate this old stub
findspam.py:1809: [W0511(fixme), ] TODO: Populate this "after city" keyword list
findspam.py:1: [C0302(too-many-lines), ] Too many lines in module (2264/1000)
findspam.py:1: [C0111(missing-docstring), ] Missing module docstring
findspam.py:20: [E0401(import-error), ] Unable to import 'phonenumbers'
findspam.py:21: [E0401(import-error), ] Unable to import 'dns.resolver'
findspam.py:173: [R0913(too-many-arguments), PostFilter.__init__] Too many arguments (7/5)
findspam.py:185: [R1705(no-else-return), PostFilter.match] Unnecessary "elif" after "return"
findspam.py:168: [R0903(too-few-public-methods), PostFilter] Too few public methods (1/2)
findspam.py:198: [R0902(too-many-instance-attributes), Rule] Too many instance attributes (10/7)
findspam.py:205: [W0622(redefined-builtin), Rule.__init__] Redefining built-in 'filter'
findspam.py:205: [R0913(too-many-arguments), Rule.__init__] Too many arguments (10/5)
findspam.py:222: [R0914(too-many-locals), Rule.match] Too many local variables (18/15)
findspam.py:275: [W0612(unused-variable), Rule.match] Unused variable 'useless'
findspam.py:222: [R0915(too-many-statements), Rule.match] Too many statements (58/50)
findspam.py:316: [C0111(missing-docstring), FindSpam] Missing class docstring
findspam.py:326: [C0111(missing-docstring), FindSpam.reload_blacklists] Missing method docstring
findspam.py:327: [W0603(global-statement), FindSpam.reload_blacklists] Using the global statement
findspam.py:327: [C0103(invalid-name), FindSpam.reload_blacklists] Constant name "bad_keywords_nwb" doesn't conform to UPPER_CASE naming style
findspam.py:347: [C0111(missing-docstring), FindSpam.test_post] Missing method docstring
findspam.py:367: [C0111(missing-docstring), FindSpam.match_info] Missing method docstring
findspam.py:373: [C0111(missing-docstring), FindSpam.match_infos] Missing method docstring
findspam.py:400: [W0621(redefined-outer-name), create_rule] Redefining name 'regex' from outer scope (line 6)
findspam.py:400: [W0622(redefined-builtin), create_rule] Redefining built-in 'all'
findspam.py:400: [C0111(missing-docstring), create_rule] Missing function docstring
findspam.py:400: [R0914(too-many-locals), create_rule] Too many local variables (19/15)
findspam.py:412: [R1705(no-else-return), create_rule] Unnecessary "else" after "return"
findspam.py:436: [R1705(no-else-return), create_rule] Unnecessary "else" after "return"
findspam.py:442: [C0111(missing-docstring), is_whitelisted_website] Missing function docstring
findspam.py:447: [C0103(invalid-name), levenshtein] Argument name "s1" doesn't conform to snake_case naming style
findspam.py:447: [C0103(invalid-name), levenshtein] Argument name "s2" doesn't conform to snake_case naming style
findspam.py:447: [C0111(missing-docstring), levenshtein] Missing function docstring
findspam.py:451: [C1801(len-as-condition), levenshtein] Do not use `len(SEQUENCE)` to determine if a sequence is empty
findspam.py:467: [C0103(invalid-name), contains_tld] Argument name "s" doesn't conform to snake_case naming style
findspam.py:467: [C0111(missing-docstring), contains_tld] Missing function docstring
findspam.py:468: [W0603(global-statement), contains_tld] Using the global statement
findspam.py:471: [C1801(len-as-condition), contains_tld] Do not use `len(SEQUENCE)` to determine if a sequence is empty
findspam.py:481: [C0103(invalid-name), misleading_link] Argument name "s" doesn't conform to snake_case naming style
findspam.py:481: [C0111(missing-docstring), misleading_link] Missing function docstring
findspam.py:517: [R1705(no-else-return), misleading_link] Unnecessary "else" after "return"
findspam.py:499: [W0612(unused-variable), misleading_link] Unused variable 'err'
findspam.py:481: [R0911(too-many-return-statements), misleading_link] Too many return statements (7/6)
findspam.py:527: [C0103(invalid-name), has_repeating_words] Argument name "s" doesn't conform to snake_case naming style
findspam.py:527: [C0111(missing-docstring), has_repeating_words] Missing function docstring
findspam.py:527: [W0613(unused-argument), has_repeating_words] Unused argument 'site'
findspam.py:541: [C0103(invalid-name), has_few_characters] Argument name "s" doesn't conform to snake_case naming style
findspam.py:541: [C0111(missing-docstring), has_few_characters] Missing function docstring
findspam.py:559: [C0103(invalid-name), has_repeating_characters] Argument name "s" doesn't conform to snake_case naming style
findspam.py:559: [C0111(missing-docstring), has_repeating_characters] Missing function docstring
findspam.py:559: [W0613(unused-argument), has_repeating_characters] Unused argument 'site'
findspam.py:580: [C0103(invalid-name), link_at_end] Argument name "s" doesn't conform to snake_case naming style
findspam.py:580: [C0111(missing-docstring), link_at_end] Missing function docstring
findspam.py:580: [W0613(unused-argument), link_at_end] Unused argument 'site'
findspam.py:597: [C0103(invalid-name), non_english_link] Argument name "s" doesn't conform to snake_case naming style
findspam.py:597: [C0111(missing-docstring), non_english_link] Missing function docstring
findspam.py:597: [W0613(unused-argument), non_english_link] Unused argument 'site'
findspam.py:619: [C0103(invalid-name), mostly_non_latin] Argument name "s" doesn't conform to snake_case naming style
findspam.py:619: [C0111(missing-docstring), mostly_non_latin] Missing function docstring
findspam.py:619: [W0613(unused-argument), mostly_non_latin] Unused argument 'site'
findspam.py:630: [C0103(invalid-name), has_phone_number] Argument name "s" doesn't conform to snake_case naming style
findspam.py:630: [C0111(missing-docstring), has_phone_number] Missing function docstring
findspam.py:630: [W0613(unused-argument), has_phone_number] Unused argument 'site'
findspam.py:657: [C0103(invalid-name), check_numbers] Argument name "s" doesn't conform to snake_case naming style
findspam.py:673: [R1705(no-else-return), check_numbers] Unnecessary "else" after "return"
findspam.py:679: [C0111(missing-docstring), process_numlist] Missing function docstring
findspam.py:686: [C0103(invalid-name), check_blacklisted_numbers] Argument name "s" doesn't conform to snake_case naming style
findspam.py:686: [C0111(missing-docstring), check_blacklisted_numbers] Missing function docstring
findspam.py:686: [W0613(unused-argument), check_blacklisted_numbers] Unused argument 'site'
findspam.py:693: [C0103(invalid-name), check_watched_numbers] Argument name "s" doesn't conform to snake_case naming style
findspam.py:693: [C0111(missing-docstring), check_watched_numbers] Missing function docstring
findspam.py:693: [W0613(unused-argument), check_watched_numbers] Unused argument 'site'
findspam.py:701: [C0103(invalid-name), has_customer_service] Argument name "s" doesn't conform to snake_case naming style
findspam.py:701: [C0111(missing-docstring), has_customer_service] Missing function docstring
findspam.py:727: [C0103(invalid-name), has_health] Argument name "s" doesn't conform to snake_case naming style
findspam.py:727: [C0111(missing-docstring), has_health] Missing function docstring
findspam.py:727: [W0613(unused-argument), has_health] Unused argument 'site'
findspam.py:758: [C0103(invalid-name), pattern_product_name] Argument name "s" doesn't conform to snake_case naming style
findspam.py:758: [C0111(missing-docstring), pattern_product_name] Missing function docstring
findspam.py:788: [R1718(consider-using-set-comprehension), pattern_product_name] Consider using a set comprehension
findspam.py:795: [C0103(invalid-name), keyword_email] Argument name "s" doesn't conform to snake_case naming style
findspam.py:795: [C0111(missing-docstring), keyword_email] Missing function docstring
findspam.py:819: [C0103(invalid-name), pattern_email] Argument name "s" doesn't conform to snake_case naming style
findspam.py:819: [C0111(missing-docstring), pattern_email] Missing function docstring
findspam.py:819: [W0613(unused-argument), pattern_email] Unused argument 'site'
findspam.py:832: [C0103(invalid-name), keyword_link] Argument name "s" doesn't conform to snake_case naming style
findspam.py:832: [C0111(missing-docstring), keyword_link] Missing function docstring
findspam.py:832: [W0613(unused-argument), keyword_link] Unused argument 'site'
findspam.py:852: [C0103(invalid-name), bad_link_text] Argument name "s" doesn't conform to snake_case naming style
findspam.py:852: [C0111(missing-docstring), bad_link_text] Missing function docstring
findspam.py:852: [W0613(unused-argument), bad_link_text] Unused argument 'site'
findspam.py:885: [C0103(invalid-name), bad_pattern_in_url] Argument name "s" doesn't conform to snake_case naming style
findspam.py:885: [C0111(missing-docstring), bad_pattern_in_url] Missing function docstring
findspam.py:895: [R1705(no-else-return), bad_pattern_in_url] Unnecessary "else" after "return"
findspam.py:885: [W0613(unused-argument), bad_pattern_in_url] Unused argument 'site'
findspam.py:919: [C0111(missing-docstring), dns_query] Missing function docstring
findspam.py:920: [W0603(global-statement), dns_query] Using the global statement
findspam.py:948: [C0103(invalid-name), asn_query] Argument name "ip" doesn't conform to snake_case naming style
findspam.py:955: [R1718(consider-using-set-comprehension), asn_query] Consider using a set comprehension
findspam.py:962: [C0103(invalid-name), ns_for_url_domain] Argument name "s" doesn't conform to snake_case naming style
findspam.py:962: [C0111(missing-docstring), ns_for_url_domain] Missing function docstring
findspam.py:980: [R1718(consider-using-set-comprehension), ns_for_url_domain] Consider using a set comprehension
findspam.py:982: [C0123(unidiomatic-typecheck), ns_for_url_domain] Using type() instead of isinstance() for a typecheck.
findspam.py:962: [W0613(unused-argument), ns_for_url_domain] Unused argument 'site'
findspam.py:991: [C0103(invalid-name), ns_is_host] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1000: [R1718(consider-using-set-comprehension), ns_is_host] Consider using a set comprehension
findspam.py:991: [W0613(unused-argument), ns_is_host] Unused argument 'site'
findspam.py:1016: [C0103(invalid-name), bad_ns_for_url_domain] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1016: [C0111(missing-docstring), bad_ns_for_url_domain] Missing function docstring
findspam.py:1046: [C0103(invalid-name), watched_ns_for_url_domain] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1046: [C0111(missing-docstring), watched_ns_for_url_domain] Missing function docstring
findspam.py:1177: [C0103(invalid-name), ip_for_url_host] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1177: [C0111(missing-docstring), ip_for_url_host] Missing function docstring
findspam.py:1183: [R1718(consider-using-set-comprehension), ip_for_url_host] Consider using a set comprehension
findspam.py:1177: [W0613(unused-argument), ip_for_url_host] Unused argument 'site'
findspam.py:1194: [C0103(invalid-name), watched_ip_for_url_hostname] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1194: [C0111(missing-docstring), watched_ip_for_url_hostname] Missing function docstring
findspam.py:1259: [C0103(invalid-name), bad_ip_for_url_hostname] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1259: [C0111(missing-docstring), bad_ip_for_url_hostname] Missing function docstring
findspam.py:1286: [C0103(invalid-name), asn_for_url_host] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1286: [C0111(missing-docstring), asn_for_url_host] Missing function docstring
findspam.py:1294: [R1718(consider-using-set-comprehension), asn_for_url_host] Consider using a set comprehension
findspam.py:1286: [W0613(unused-argument), asn_for_url_host] Unused argument 'site'
findspam.py:1305: [C0103(invalid-name), watched_asn_for_url_hostname] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1305: [C0111(missing-docstring), watched_asn_for_url_hostname] Missing function docstring
findspam.py:1357: [C0103(invalid-name), is_offensive_post] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1357: [C0111(missing-docstring), is_offensive_post] Missing function docstring
findspam.py:1357: [W0613(unused-argument), is_offensive_post] Unused argument 'site'
findspam.py:1382: [C0111(missing-docstring), username_similar_website] Missing function docstring
findspam.py:1385: [R1705(no-else-return), username_similar_website] Unnecessary "else" after "return"
findspam.py:1396: [C0103(invalid-name), character_utilization_ratio] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1396: [C0111(missing-docstring), character_utilization_ratio] Missing function docstring
findspam.py:1410: [R1705(no-else-return), character_utilization_ratio] Unnecessary "else" after "return"
findspam.py:1396: [W0613(unused-argument), character_utilization_ratio] Unused argument 'site'
findspam.py:1420: [W0603(global-statement), post_links] Using the global statement
findspam.py:1458: [W0603(global-statement), post_hosts] Using the global statement
findspam.py:1522: [C0103(invalid-name), similar_ratio] Argument name "a" doesn't conform to snake_case naming style
findspam.py:1522: [C0103(invalid-name), similar_ratio] Argument name "b" doesn't conform to snake_case naming style
findspam.py:1522: [C0111(missing-docstring), similar_ratio] Missing function docstring
findspam.py:1527: [C0103(invalid-name), get_domain] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1565: [C0111(missing-docstring), similar_answer] Missing function docstring
findspam.py:1585: [C0103(invalid-name), strip_urls_and_tags] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1585: [C0111(missing-docstring), strip_urls_and_tags] Missing function docstring
findspam.py:1591: [C0103(invalid-name), mostly_punctuations] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1591: [C0111(missing-docstring), mostly_punctuations] Missing function docstring
findspam.py:1609: [R1705(no-else-return), mostly_punctuations] Unnecessary "else" after "return"
findspam.py:1591: [W0613(unused-argument), mostly_punctuations] Unused argument 'site'
findspam.py:1617: [C0103(invalid-name), no_whitespace_title] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1617: [C0111(missing-docstring), no_whitespace_title] Missing function docstring
findspam.py:1618: [R1705(no-else-return), no_whitespace_title] Unnecessary "else" after "return"
findspam.py:1617: [W0613(unused-argument), no_whitespace_title] Unused argument 'site'
findspam.py:1625: [C0103(invalid-name), no_whitespace_body] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1625: [C0111(missing-docstring), no_whitespace_body] Missing function docstring
findspam.py:1626: [R1705(no-else-return), no_whitespace_body] Unnecessary "else" after "return"
findspam.py:1625: [W0613(unused-argument), no_whitespace_body] Unused argument 'site'
findspam.py:1632: [C0111(missing-docstring), toxic_check] Missing function docstring
findspam.py:1668: [C0103(invalid-name), ] Constant name "toxic_check" doesn't conform to UPPER_CASE naming style
findspam.py:1673: [C0111(missing-docstring), body_starts_with_title] Missing function docstring
findspam.py:1673: [R0911(too-many-return-statements), body_starts_with_title] Too many return statements (7/6)
findspam.py:1713: [C0103(invalid-name), luncheon_meat] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1713: [C0111(missing-docstring), luncheon_meat] Missing function docstring
findspam.py:1713: [W0613(unused-argument), luncheon_meat] Unused argument 'site'
findspam.py:1735: [C0111(missing-docstring), turkey2] Missing function docstring
findspam.py:1737: [W0212(protected-access), turkey2] Access to a protected member _clients of a client class
findspam.py:1752: [C0103(invalid-name), religion_troll] Argument name "s" doesn't conform to snake_case naming style
findspam.py:1752: [C0111(missing-docstring), religion_troll] Missing function docstring
findspam.py:1752: [W0613(unused-argument), religion_troll] Unused argument 'site'
findspam.py:1791: [C0103(invalid-name), ] Constant name "bad_keywords_nwb" doesn't conform to UPPER_CASE naming style
findspam.py:1817: [C0103(invalid-name), ] Constant name "pattern_websites" doesn't conform to UPPER_CASE naming style
findspam.py:1914: [C0103(invalid-name), ] Constant name "city_list" doesn't conform to UPPER_CASE naming style
findspam.py:9: [W0611(unused-import), ] Unused chain imported from itertools
findspam.py:12: [W0611(unused-import), ] Unused import time
findspam.py:13: [W0611(unused-import), ] Unused import os
findspam.py:7: [C0411(wrong-import-order), ] standard import "from difflib import SequenceMatcher" should be placed before "import regex"
findspam.py:8: [C0411(wrong-import-order), ] standard import "from urllib.parse import urlparse, unquote_plus" should be placed before "import regex"
findspam.py:9: [C0411(wrong-import-order), ] standard import "from itertools import chain" should be placed before "import regex"
findspam.py:10: [C0411(wrong-import-order), ] standard import "from collections import Counter" should be placed before "import regex"
findspam.py:11: [C0411(wrong-import-order), ] standard import "from datetime import datetime" should be placed before "import regex"
findspam.py:12: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import regex"
findspam.py:13: [C0411(wrong-import-order), ] standard import "import os" should be placed before "import regex"
findspam.py:14: [C0411(wrong-import-order), ] standard import "import os.path as path" should be placed before "import regex"
findspam.py:22: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "import phonenumbers"
************* Module flovis
flovis.py:1: [C0111(missing-docstring), ] Missing module docstring
flovis.py:2: [E0401(import-error), ] Unable to import 'websocket'
flovis.py:39: [C0103(invalid-name), Flovis._init_websocket] Attribute name "ws" doesn't conform to snake_case naming style
flovis.py:12: [C0111(missing-docstring), Flovis] Missing class docstring
flovis.py:24: [C0103(invalid-name), Flovis._init_websocket.on_message] Argument name "ws" doesn't conform to snake_case naming style
flovis.py:44: [W0212(protected-access), Flovis._init_websocket.run] Access to a protected member _exceptions of a client class
flovis.py:46: [W0212(protected-access), Flovis._init_websocket.run] Access to a protected member _exceptions of a client class
flovis.py:64: [W0212(protected-access), Flovis._init_websocket] Access to a protected member _exceptions of a client class
flovis.py:70: [C0111(missing-docstring), Flovis.stage] Missing method docstring
flovis.py:12: [R0903(too-few-public-methods), Flovis] Too few public methods (1/2)
flovis.py:58: [W0201(attribute-defined-outside-init), Flovis._init_websocket.run] Attribute 'ws' defined outside __init__
flovis.py:85: [W0201(attribute-defined-outside-init), Flovis.stage] Attribute 'ws' defined outside __init__
flovis.py:3: [C0411(wrong-import-order), ] standard import "import socket" should be placed before "import websocket"
flovis.py:4: [C0411(wrong-import-order), ] standard import "import ssl" should be placed before "import websocket"
flovis.py:5: [C0411(wrong-import-order), ] standard import "import json" should be placed before "import websocket"
flovis.py:6: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import websocket"
flovis.py:7: [C0411(wrong-import-order), ] standard import "import uuid" should be placed before "import websocket"
flovis.py:8: [C0411(wrong-import-order), ] standard import "from threading import Thread" should be placed before "import websocket"
************* Module gitmanager
gitmanager.py:310: [W0511(fixme), ] TODO: PR merged, but branch deletion has something wrong, generate some text
gitmanager.py:1: [C0111(missing-docstring), ] Missing module docstring
gitmanager.py:20: [E0401(import-error), ] Unable to import 'sh.contrib'
gitmanager.py:21: [E0401(import-error), ] Unable to import 'sh'
gitmanager.py:23: [C0413(wrong-import-position), ] Import "from helpers import log, log_exception, only_blacklists_changed" should be placed at the top of the module
gitmanager.py:24: [W0401(wildcard-import), ] Wildcard import blacklists
gitmanager.py:24: [C0413(wrong-import-position), ] Import "from blacklists import *" should be placed at the top of the module
gitmanager.py:27: [C0111(missing-docstring), GitHubManager] Missing class docstring
gitmanager.py:43: [C0111(missing-docstring), GitHubManager.comment_on_thread] Missing method docstring
gitmanager.py:51: [C0111(missing-docstring), GitManager] Missing class docstring
gitmanager.py:55: [C0111(missing-docstring), GitManager.add_to_blacklist] Missing method docstring
gitmanager.py:55: [R0913(too-many-arguments), GitManager.add_to_blacklist] Too many arguments (7/5)
gitmanager.py:55: [R0914(too-many-locals), GitManager.add_to_blacklist] Too many local variables (28/15)
gitmanager.py:196: [W0703(broad-except), GitManager.add_to_blacklist] Catching too general exception Exception
gitmanager.py:164: [R1705(no-else-return), GitManager.add_to_blacklist] Unnecessary "else" after "return"
gitmanager.py:189: [R1705(no-else-return), GitManager.add_to_blacklist] Unnecessary "else" after "return"
gitmanager.py:204: [R1705(no-else-return), GitManager.add_to_blacklist] Unnecessary "elif" after "return"
gitmanager.py:55: [R1710(inconsistent-return-statements), GitManager.add_to_blacklist] Either all return statements in a function should return an expression, or none of them should.
gitmanager.py:196: [W0612(unused-variable), GitManager.add_to_blacklist] Unused variable 'err'
gitmanager.py:55: [R0911(too-many-return-statements), GitManager.add_to_blacklist] Too many return statements (13/6)
gitmanager.py:55: [R0915(too-many-statements), GitManager.add_to_blacklist] Too many statements (86/50)
gitmanager.py:210: [C0111(missing-docstring), GitManager.remove_from_blacklist] Missing method docstring
gitmanager.py:210: [R0913(too-many-arguments), GitManager.remove_from_blacklist] Too many arguments (6/5)
gitmanager.py:210: [R0914(too-many-locals), GitManager.remove_from_blacklist] Too many local variables (18/15)
gitmanager.py:212: [R1705(no-else-return), GitManager.remove_from_blacklist] Unnecessary "else" after "return"
gitmanager.py:270: [W0703(broad-except), GitManager.remove_from_blacklist] Catching too general exception Exception
gitmanager.py:210: [R0911(too-many-return-statements), GitManager.remove_from_blacklist] Too many return statements (7/6)
gitmanager.py:282: [C0111(missing-docstring), GitManager.merge_pull_request] Missing method docstring
gitmanager.py:309: [W0612(unused-variable), GitManager.merge_pull_request] Unused variable 'e'
gitmanager.py:319: [C0111(missing-docstring), GitManager.prepare_git_for_operation] Missing method docstring
gitmanager.py:319: [W0613(unused-argument), GitManager.prepare_git_for_operation] Unused argument 'blacklist_file_name'
gitmanager.py:324: [W0612(unused-variable), GitManager.prepare_git_for_operation] Unused variable 'e'
gitmanager.py:345: [C0111(missing-docstring), GitManager.current_git_status] Missing method docstring
gitmanager.py:346: [R1705(no-else-return), GitManager.current_git_status] Unnecessary "else" after "return"
gitmanager.py:352: [C0111(missing-docstring), GitManager.current_branch] Missing method docstring
gitmanager.py:356: [C0111(missing-docstring), GitManager.merge_abort] Missing method docstring
gitmanager.py:362: [C0111(missing-docstring), GitManager.reset_head] Missing method docstring
gitmanager.py:369: [C0111(missing-docstring), GitManager.get_remote_diff] Missing method docstring
gitmanager.py:371: [R1705(no-else-return), GitManager.get_remote_diff] Unnecessary "else" after "return"
gitmanager.py:377: [C0111(missing-docstring), GitManager.get_local_diff] Missing method docstring
gitmanager.py:378: [R1705(no-else-return), GitManager.get_local_diff] Unnecessary "else" after "return"
gitmanager.py:384: [C0111(missing-docstring), GitManager.pull_remote] Missing method docstring
gitmanager.py:388: [C0111(missing-docstring), GitManager.pull_local] Missing method docstring
gitmanager.py:399: [C0111(missing-docstring), GitManager.sync_remote] Missing method docstring
gitmanager.py:408: [W0703(broad-except), GitManager.sync_remote] Catching too general exception Exception
gitmanager.py:4: [W0611(unused-import), ] Unused import platform
gitmanager.py:7: [W0611(unused-import), ] Unused datetime imported from datetime
gitmanager.py:10: [W0611(unused-import), ] Unused import regex
gitmanager.py:24: [W0614(unused-wildcard-import), ] Unused import load_blacklists from wildcard import
gitmanager.py:24: [W0614(unused-wildcard-import), ] Unused import BlacklistParser from wildcard import
gitmanager.py:24: [W0614(unused-wildcard-import), ] Unused import BasicListParser from wildcard import
gitmanager.py:24: [W0614(unused-wildcard-import), ] Unused import TSVDictParser from wildcard import
gitmanager.py:24: [W0614(unused-wildcard-import), ] Unused import Union from wildcard import
gitmanager.py:14: [C0411(wrong-import-order), ] standard import "from urllib.parse import quote_plus" should be placed before "import regex"
************* Module globalvars
globalvars.py:175: [C0301(line-too-long), ] Line too long (624/120)
globalvars.py:1: [C0111(missing-docstring), ] Missing module docstring
globalvars.py:22: [C0111(missing-docstring), git_commit_info] Missing function docstring
globalvars.py:32: [C0111(missing-docstring), git_ref] Missing function docstring
globalvars.py:41: [C0111(missing-docstring), GlobalVars] Missing class docstring
globalvars.py:178: [C0111(missing-docstring), GlobalVars.reload] Missing method docstring
globalvars.py:41: [R0903(too-few-public-methods), GlobalVars] Too few public methods (1/2)
globalvars.py:9: [W0611(unused-import), ] Unused md5 imported from hashlib
globalvars.py:10: [W0611(unused-import), ] Unused NoOptionError imported from configparser
globalvars.py:13: [W0611(unused-import), ] Unused import regex
globalvars.py:14: [C0411(wrong-import-order), ] standard import "import subprocess as sp" should be placed before "import regex"
globalvars.py:15: [C0411(wrong-import-order), ] standard import "import platform" should be placed before "import regex"
************* Module helpers
helpers.py:1: [C0111(missing-docstring), ] Missing module docstring
helpers.py:10: [C0103(invalid-name), ] Constant name "platform_text" doesn't conform to UPPER_CASE naming style
helpers.py:12: [E0401(import-error), ] Unable to import 'colorama'
helpers.py:14: [E0401(import-error), ] Unable to import 'termcolor'
helpers.py:14: [C0413(wrong-import-position), ] Import "from termcolor import colored" should be placed at the top of the module
helpers.py:15: [C0413(wrong-import-position), ] Import "import requests" should be placed at the top of the module
helpers.py:16: [C0413(wrong-import-position), ] Import "import regex" should be placed at the top of the module
helpers.py:17: [C0413(wrong-import-position), ] Import "from glob import glob" should be placed at the top of the module
helpers.py:18: [C0413(wrong-import-position), ] Import "import sqlite3" should be placed at the top of the module
helpers.py:21: [C0111(missing-docstring), exit_mode] Missing function docstring
helpers.py:31: [W0212(protected-access), exit_mode] Access to a protected member _exit of a client class
helpers.py:34: [C0111(missing-docstring), ErrorLogs] Missing class docstring
helpers.py:48: [C0111(missing-docstring), ErrorLogs.get_db] Missing method docstring
helpers.py:55: [W0621(redefined-outer-name), ErrorLogs.add] Redefining name 'traceback' from outer scope (line 4)
helpers.py:55: [C0111(missing-docstring), ErrorLogs.add] Missing method docstring
helpers.py:62: [C0103(invalid-name), ErrorLogs.fetch_last] Argument name "n" doesn't conform to snake_case naming style
helpers.py:62: [C0111(missing-docstring), ErrorLogs.fetch_last] Missing method docstring
helpers.py:69: [C0103(invalid-name), ErrorLogs.truncate] Argument name "n" doesn't conform to snake_case naming style
helpers.py:82: [C0111(missing-docstring), Helpers] Missing class docstring
helpers.py:82: [R0903(too-few-public-methods), Helpers] Too few public methods (0/2)
helpers.py:86: [C0103(invalid-name), escape_format] Argument name "s" doesn't conform to snake_case naming style
helpers.py:86: [C0111(missing-docstring), escape_format] Missing function docstring
helpers.py:90: [C0103(invalid-name), expand_shorthand_link] Argument name "s" doesn't conform to snake_case naming style
helpers.py:90: [C0111(missing-docstring), expand_shorthand_link] Missing function docstring
helpers.py:106: [C0111(missing-docstring), log] Missing function docstring
helpers.py:133: [C0111(missing-docstring), log_file] Missing function docstring
helpers.py:149: [C0103(invalid-name), log_exception] Argument name "tb" doesn't conform to snake_case naming style
helpers.py:149: [C0103(invalid-name), log_exception] Argument name "f" doesn't conform to snake_case naming style
helpers.py:149: [C0111(missing-docstring), log_exception] Missing function docstring
helpers.py:158: [C0103(invalid-name), log_current_exception] Argument name "f" doesn't conform to snake_case naming style
helpers.py:158: [C0111(missing-docstring), log_current_exception] Missing function docstring
helpers.py:162: [C0111(missing-docstring), files_changed] Missing function docstring
helpers.py:167: [C0103(invalid-name), ] Constant name "core_files" doesn't conform to UPPER_CASE naming style
helpers.py:178: [C0103(invalid-name), ] Constant name "reloadable_modules" doesn't conform to UPPER_CASE naming style
helpers.py:181: [C0103(invalid-name), ] Constant name "module_files" doesn't conform to UPPER_CASE naming style
helpers.py:184: [C0111(missing-docstring), only_blacklists_changed] Missing function docstring
helpers.py:188: [C0111(missing-docstring), only_modules_changed] Missing function docstring
helpers.py:192: [C0111(missing-docstring), reload_modules] Missing function docstring
helpers.py:207: [C0111(missing-docstring), unshorten_link] Missing function docstring
helpers.py:229: [C0103(invalid-name), ] Constant name "pcre_comment" doesn't conform to UPPER_CASE naming style
helpers.py:232: [C0111(missing-docstring), blacklist_integrity_check] Missing function docstring
helpers.py:257: [C0111(missing-docstring), SecurityError] Missing class docstring
helpers.py:15: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "from termcolor import colored"
helpers.py:16: [C0411(wrong-import-order), ] third party import "import regex" should be placed before "from termcolor import colored"
helpers.py:17: [C0411(wrong-import-order), ] standard import "from glob import glob" should be placed before "import requests"
helpers.py:18: [C0411(wrong-import-order), ] standard import "import sqlite3" should be placed before "import requests"
************* Module metasmoke
metasmoke.py:308: [W0511(fixme), ] TODO: What could happen here?
metasmoke.py:45: [C0330(bad-continuation), ] Wrong continued indentation (add 14 spaces).
                                      "\"key\":\"" + GlobalVars.metasmoke_key + "\"}"})
                                      ^             |
metasmoke.py:306: [W0311(bad-indentation), ] Bad indentation. Found 24 spaces, expected 20
metasmoke.py:1: [C0111(missing-docstring), ] Missing module docstring
metasmoke.py:8: [E0401(import-error), ] Unable to import 'websocket'
metasmoke.py:9: [E0611(no-name-in-module), ] No name 'Iterable' in module 'collections'
metasmoke.py:35: [C0111(missing-docstring), Metasmoke] Missing class docstring
metasmoke.py:37: [C0111(missing-docstring), Metasmoke.init_websocket] Missing method docstring
metasmoke.py:67: [W0703(broad-except), Metasmoke.init_websocket] Catching too general exception Exception
metasmoke.py:58: [W0703(broad-except), Metasmoke.init_websocket] Catching too general exception Exception
metasmoke.py:76: [C0111(missing-docstring), Metasmoke.handle_websocket_data] Missing method docstring
metasmoke.py:91: [W0212(protected-access), Metasmoke.handle_websocket_data] Access to a protected member _exit of a client class
metasmoke.py:112: [W0101(unreachable), Metasmoke.handle_websocket_data] Unreachable code
metasmoke.py:119: [C1801(len-as-condition), Metasmoke.handle_websocket_data] Do not use `len(SEQUENCE)` to determine if a sequence is empty
metasmoke.py:121: [E1101(no-member), Metasmoke.handle_websocket_data] Module 'findspam' has no 'reload_blacklists' member
metasmoke.py:76: [R0915(too-many-statements), Metasmoke.handle_websocket_data] Too many statements (77/50)
metasmoke.py:176: [C0111(missing-docstring), Metasmoke.send_stats_on_post] Missing method docstring
metasmoke.py:176: [R0913(too-many-arguments), Metasmoke.send_stats_on_post] Too many arguments (11/5)
metasmoke.py:176: [R0914(too-many-locals), Metasmoke.send_stats_on_post] Too many local variables (17/15)
metasmoke.py:178: [R1705(no-else-return), Metasmoke.send_stats_on_post] Unnecessary "elif" after "return"
metasmoke.py:202: [W0703(broad-except), Metasmoke.send_stats_on_post] Catching too general exception Exception
metasmoke.py:206: [C0111(missing-docstring), Metasmoke.send_feedback_for_post] Missing method docstring
metasmoke.py:207: [R1705(no-else-return), Metasmoke.send_feedback_for_post] Unnecessary "elif" after "return"
metasmoke.py:231: [W0703(broad-except), Metasmoke.send_feedback_for_post] Catching too general exception Exception
metasmoke.py:235: [C0111(missing-docstring), Metasmoke.send_deletion_stats_for_post] Missing method docstring
metasmoke.py:236: [R1705(no-else-return), Metasmoke.send_deletion_stats_for_post] Unnecessary "elif" after "return"
metasmoke.py:256: [W0703(broad-except), Metasmoke.send_deletion_stats_for_post] Catching too general exception Exception
metasmoke.py:260: [C0111(missing-docstring), Metasmoke.send_status_ping] Missing method docstring
metasmoke.py:261: [R1705(no-else-return), Metasmoke.send_status_ping] Unnecessary "elif" after "return"
metasmoke.py:311: [W0703(broad-except), Metasmoke.send_status_ping] Catching too general exception Exception
metasmoke.py:308: [W0703(broad-except), Metasmoke.send_status_ping] Catching too general exception Exception
metasmoke.py:331: [W0622(redefined-builtin), Metasmoke.update_code_privileged_users_list] Redefining built-in 'id'
metasmoke.py:315: [C0111(missing-docstring), Metasmoke.update_code_privileged_users_list] Missing method docstring
metasmoke.py:325: [W0703(broad-except), Metasmoke.update_code_privileged_users_list] Catching too general exception Exception
metasmoke.py:361: [W0622(redefined-builtin), Metasmoke.determine_if_autoflagged] Redefining built-in 'id'
metasmoke.py:352: [W0703(broad-except), Metasmoke.determine_if_autoflagged] Catching too general exception Exception
metasmoke.py:366: [C1801(len-as-condition), Metasmoke.determine_if_autoflagged] Do not use `len(SEQUENCE)` to determine if a sequence is empty
metasmoke.py:372: [C0111(missing-docstring), Metasmoke.stop_autoflagging] Missing method docstring
metasmoke.py:380: [C0111(missing-docstring), Metasmoke.send_statistics] Missing method docstring
metasmoke.py:407: [C0111(missing-docstring), Metasmoke.post_auto_comment] Missing method docstring
metasmoke.py:426: [C1801(len-as-condition), Metasmoke.post_auto_comment] Do not use `len(SEQUENCE)` to determine if a sequence is empty
metasmoke.py:431: [W0212(protected-access), Metasmoke.post_auto_comment] Access to a protected member _client of a client class
metasmoke.py:436: [C0111(missing-docstring), Metasmoke.get_post_bodies_from_ms] Missing method docstring
metasmoke.py:453: [C0111(missing-docstring), Metasmoke.get_reason_weights] Missing method docstring
metasmoke.py:476: [C0111(missing-docstring), Metasmoke.request_sender] Missing method docstring
metasmoke.py:509: [C0111(missing-docstring), Metasmoke.reset_failure_count] Missing method docstring
metasmoke.py:4: [W0611(unused-import), ] Unused import importlib
metasmoke.py:6: [W0611(unused-import), ] Unused import threading
metasmoke.py:10: [W0611(unused-import), ] Unused timedelta imported from datetime
metasmoke.py:11: [W0611(unused-import), ] Unused glob imported from glob
metasmoke.py:12: [W0611(unused-import), ] Unused sub imported from regex
metasmoke.py:13: [W0611(unused-import), ] Unused import sys
metasmoke.py:20: [W0611(unused-import), ] Unused import apigetpost
metasmoke.py:21: [W0611(unused-import), ] Unused import spamhandling
metasmoke.py:22: [W0611(unused-import), ] Unused import classes
metasmoke.py:4: [C0411(wrong-import-order), ] standard import "import importlib" should be placed before "import requests"
metasmoke.py:6: [C0411(wrong-import-order), ] standard import "import threading" should be placed before "import requests"
metasmoke.py:9: [C0411(wrong-import-order), ] standard import "from collections import Iterable" should be placed before "import requests"
metasmoke.py:10: [C0411(wrong-import-order), ] standard import "from datetime import datetime, timedelta" should be placed before "import requests"
metasmoke.py:11: [C0411(wrong-import-order), ] standard import "from glob import glob" should be placed before "import requests"
metasmoke.py:12: [C0411(wrong-import-order), ] third party import "from regex import sub" should be placed before "from globalvars import GlobalVars"
metasmoke.py:13: [C0411(wrong-import-order), ] standard import "import sys" should be placed before "import requests"
metasmoke.py:14: [C0411(wrong-import-order), ] standard import "import traceback" should be placed before "import requests"
metasmoke.py:15: [C0411(wrong-import-order), ] standard import "import time" should be placed before "import requests"
metasmoke.py:16: [C0411(wrong-import-order), ] standard import "import os" should be placed before "import requests"
metasmoke.py:17: [C0411(wrong-import-order), ] standard import "import subprocess as sp" should be placed before "import requests"
************* Module nocrash
nocrash.py:1: [C0111(missing-docstring), ] Missing module docstring
nocrash.py:13: [C0103(invalid-name), ] Constant name "on_windows" doesn't conform to UPPER_CASE naming style
nocrash.py:19: [E0401(import-error), ] Unable to import 'sh.contrib'
nocrash.py:30: [C0103(invalid-name), ] Constant name "options" doesn't conform to UPPER_CASE naming style
nocrash.py:31: [C0103(invalid-name), ] Constant name "persistent_arguments" doesn't conform to UPPER_CASE naming style
nocrash.py:33: [C0103(invalid-name), ] Constant name "count" doesn't conform to UPPER_CASE naming style
nocrash.py:34: [C0103(invalid-name), ] Constant name "crashcount" doesn't conform to UPPER_CASE naming style
nocrash.py:35: [C0103(invalid-name), ] Constant name "stoprunning" doesn't conform to UPPER_CASE naming style
nocrash.py:36: [C0103(invalid-name), ] Constant name "ecode" doesn't conform to UPPER_CASE naming style
nocrash.py:39: [C0111(missing-docstring), log] Missing function docstring
nocrash.py:40: [W1202(logging-format-interpolation), log] Use % formatting in logging functions and pass the % parameters as arguments
nocrash.py:43: [C0111(missing-docstring), warn] Missing function docstring
nocrash.py:44: [W1202(logging-format-interpolation), warn] Use % formatting in logging functions and pass the % parameters as arguments
nocrash.py:47: [C0111(missing-docstring), error] Missing function docstring
nocrash.py:48: [W1202(logging-format-interpolation), error] Use % formatting in logging functions and pass the % parameters as arguments
nocrash.py:70: [C0103(invalid-name), ] Constant name "command" doesn't conform to UPPER_CASE naming style
nocrash.py:72: [C0103(invalid-name), ] Constant name "command" doesn't conform to UPPER_CASE naming style
nocrash.py:75: [C0103(invalid-name), ] Constant name "command" doesn't conform to UPPER_CASE naming style
nocrash.py:77: [C0103(invalid-name), ] Constant name "command" doesn't conform to UPPER_CASE naming style
nocrash.py:80: [C0103(invalid-name), ] Constant name "ecode" doesn't conform to UPPER_CASE naming style
nocrash.py:82: [C0103(invalid-name), ] Constant name "exc_type" doesn't conform to UPPER_CASE naming style
nocrash.py:82: [C0103(invalid-name), ] Constant name "exc_obj" doesn't conform to UPPER_CASE naming style
nocrash.py:82: [C0103(invalid-name), ] Constant name "exc_tb" doesn't conform to UPPER_CASE naming style
nocrash.py:89: [C0103(invalid-name), ] Constant name "exit_info" doesn't conform to UPPER_CASE naming style
nocrash.py:90: [C0103(invalid-name), ] Constant name "exit_info" doesn't conform to UPPER_CASE naming style
nocrash.py:94: [C0103(invalid-name), ] Constant name "exit_info" doesn't conform to UPPER_CASE naming style
nocrash.py:111: [C0103(invalid-name), ] Constant name "count" doesn't conform to UPPER_CASE naming style
nocrash.py:112: [C0103(invalid-name), ] Constant name "crashcount" doesn't conform to UPPER_CASE naming style
nocrash.py:126: [C0103(invalid-name), ] Constant name "count" doesn't conform to UPPER_CASE naming style
nocrash.py:127: [C0103(invalid-name), ] Constant name "crashcount" doesn't conform to UPPER_CASE naming style
nocrash.py:134: [C0103(invalid-name), ] Constant name "count" doesn't conform to UPPER_CASE naming style
nocrash.py:138: [C0103(invalid-name), ] Constant name "stoprunning" doesn't conform to UPPER_CASE naming style
nocrash.py:148: [C0103(invalid-name), ] Constant name "count" doesn't conform to UPPER_CASE naming style
nocrash.py:149: [C0103(invalid-name), ] Constant name "crashcount" doesn't conform to UPPER_CASE naming style
nocrash.py:154: [C0103(invalid-name), ] Constant name "count" doesn't conform to UPPER_CASE naming style
************* Module parsing
parsing.py:1: [C0111(missing-docstring), ] Missing module docstring
parsing.py:9: [C0103(invalid-name), rebuild_str] Argument name "s" doesn't conform to snake_case naming style
parsing.py:9: [C0111(missing-docstring), rebuild_str] Missing function docstring
parsing.py:14: [C0111(missing-docstring), get_user_from_url] Missing function docstring
parsing.py:27: [C0111(missing-docstring), get_api_sitename_from_url] Missing function docstring
parsing.py:32: [R1705(no-else-return), get_api_sitename_from_url] Unnecessary "else" after "return"
parsing.py:40: [C0111(missing-docstring), api_parameter_from_link] Missing function docstring
parsing.py:53: [R1705(no-else-return), api_parameter_from_link] Unnecessary "elif" after "return"
parsing.py:63: [C0111(missing-docstring), post_id_from_link] Missing function docstring
parsing.py:65: [R1705(no-else-return), post_id_from_link] Unnecessary "else" after "return"
parsing.py:71: [C0111(missing-docstring), to_metasmoke_link] Missing function docstring
parsing.py:77: [C0103(invalid-name), ] Constant name "msg_parser_regex" doesn't conform to UPPER_CASE naming style
parsing.py:84: [C0103(invalid-name), ] Constant name "msg_parser" doesn't conform to UPPER_CASE naming style
parsing.py:88: [C0111(missing-docstring), fetch_post_url_from_msg_content] Missing function docstring
parsing.py:99: [C0111(missing-docstring), fetch_post_id_and_site_from_url] Missing function docstring
parsing.py:134: [C0111(missing-docstring), fetch_post_id_and_site_from_msg_content] Missing function docstring
parsing.py:140: [C0111(missing-docstring), fetch_owner_url_from_msg_content] Missing function docstring
parsing.py:152: [C0111(missing-docstring), fetch_title_from_msg_content] Missing function docstring
parsing.py:163: [C0111(missing-docstring), edited_message_after_postgone_command] Missing function docstring
parsing.py:175: [C0111(missing-docstring), unescape_title] Missing function docstring
parsing.py:180: [C0103(invalid-name), escape_markdown] Argument name "s" doesn't conform to snake_case naming style
parsing.py:180: [C0111(missing-docstring), escape_markdown] Missing function docstring
parsing.py:185: [C0111(missing-docstring), sanitize_title] Missing function docstring
parsing.py:190: [C0111(missing-docstring), get_user_from_list_command] Missing function docstring
parsing.py:211: [R1705(no-else-return), get_user_from_list_command] Unnecessary "else" after "return"
parsing.py:219: [C0111(missing-docstring), url_to_shortlink] Missing function docstring
parsing.py:223: [R1705(no-else-return), url_to_shortlink] Unnecessary "else" after "return"
parsing.py:234: [C0111(missing-docstring), user_url_to_shortlink] Missing function docstring
parsing.py:242: [C0111(missing-docstring), to_protocol_relative] Missing function docstring
parsing.py:243: [R1705(no-else-return), to_protocol_relative] Unnecessary "elif" after "return"
************* Module queue_timings
queue_timings.py:1: [C0111(missing-docstring), ] Missing module docstring
queue_timings.py:12: [C0111(missing-docstring), main] Missing function docstring
************* Module socketscience
socketscience.py:73: [C0330(bad-continuation), ] Wrong continued indentation (remove 8 spaces).
                            .format(content["location"]))
                    |       ^
socketscience.py:1: [C0111(missing-docstring), ] Missing module docstring
socketscience.py:5: [E0401(import-error), ] Unable to import 'msgpack'
socketscience.py:37: [C0111(missing-docstring), SocketScience.send] Missing method docstring
socketscience.py:37: [W0613(unused-argument), SocketScience.send] Unused argument 'single_message'
socketscience.py:45: [C0111(missing-docstring), SocketScience.receive] Missing method docstring
socketscience.py:57: [C0103(invalid-name), SocketScience.register] Argument name "cb" doesn't conform to snake_case naming style
socketscience.py:57: [C0111(missing-docstring), SocketScience.register] Missing method docstring
socketscience.py:64: [C0111(missing-docstring), SocketScience.handle] Missing method docstring
socketscience.py:87: [C0111(missing-docstring), SocketScience.check_recent_pings] Missing method docstring
socketscience.py:93: [C1801(len-as-condition), SocketScience.check_recent_pings] Do not use `len(SEQUENCE)` to determine if a sequence is empty
socketscience.py:99: [C0111(missing-docstring), SocketScience.switch_to_active] Missing method docstring
socketscience.py:6: [W0611(unused-import), ] Unused import regex
socketscience.py:6: [C0411(wrong-import-order), ] third party import "import regex" should be placed before "import msgpack"
************* Module spamhandling
spamhandling.py:1: [C0111(missing-docstring), ] Missing module docstring
spamhandling.py:20: [C0111(missing-docstring), should_whitelist_prevent_alert] Missing function docstring
spamhandling.py:27: [C0111(missing-docstring), sum_weight] Missing function docstring
spamhandling.py:47: [C0111(missing-docstring), check_if_spam] Missing function docstring
spamhandling.py:82: [R1705(no-else-return), check_if_spam] Unnecessary "else" after "return"
spamhandling.py:95: [C0111(missing-docstring), check_if_spam_json] Missing function docstring
spamhandling.py:107: [C0111(missing-docstring), handle_spam] Missing function docstring
spamhandling.py:107: [R0914(too-many-locals), handle_spam] Too many local variables (20/15)
spamhandling.py:112: [R0916(too-many-boolean-expressions), handle_spam] Too many boolean expressions in if statement (8/5)
spamhandling.py:122: [R0123(literal-comparison), handle_spam] Comparison to literal
spamhandling.py:190: [W0703(broad-except), handle_spam] Catching too general exception Exception
spamhandling.py:190: [W0612(unused-variable), handle_spam] Unused variable 'e'
spamhandling.py:107: [R0915(too-many-statements), handle_spam] Too many statements (56/50)
spamhandling.py:3: [W0611(unused-import), ] Unused import random
spamhandling.py:8: [C0411(wrong-import-order), ] standard import "from datetime import datetime, timedelta" should be placed before "import findspam"
spamhandling.py:9: [C0411(wrong-import-order), ] third party import "import regex" should be placed before "import findspam"
spamhandling.py:15: [C0412(ungrouped-imports), ] Imports from package parsing are not grouped
************* Module tasks
tasks.py:1: [C0111(missing-docstring), ] Missing module docstring
tasks.py:6: [C0111(missing-docstring), Tasks] Missing class docstring
tasks.py:19: [C0103(invalid-name), Tasks.do] Method name "do" doesn't conform to snake_case naming style
tasks.py:19: [C0111(missing-docstring), Tasks.do] Missing method docstring
tasks.py:21: [W0212(protected-access), Tasks.do] Access to a protected member _write_to_self of a client class
tasks.py:26: [C0111(missing-docstring), Tasks.later] Missing method docstring
tasks.py:28: [W0212(protected-access), Tasks.later] Access to a protected member _write_to_self of a client class
tasks.py:33: [C0111(missing-docstring), Tasks.periodic] Missing method docstring
tasks.py:35: [C0103(invalid-name), Tasks.periodic.f] Function name "f" doesn't conform to snake_case naming style
tasks.py:41: [W0212(protected-access), Tasks.periodic] Access to a protected member _write_to_self of a client class
tasks.py:46: [W0212(protected-access), ] Access to a protected member _run of a client class
************* Module util
util.py:1: [C0111(missing-docstring), ] Missing module docstring
util.py:12: [C0413(wrong-import-position), ] Import "import chatcommands" should be placed at the top of the module
util.py:16: [C0103(invalid-name), ] Constant name "utilities" doesn't conform to UPPER_CASE naming style
util.py:19: [C0111(missing-docstring), utility] Missing function docstring
util.py:21: [W0603(global-statement), utility.wrapper] Using the global statement
util.py:21: [C0103(invalid-name), utility.wrapper] Constant name "utilities" doesn't conform to UPPER_CASE naming style
util.py:28: [C0111(missing-docstring), util_bisect] Missing function docstring
util.py:34: [C0111(missing-docstring), util_exit] Missing function docstring
util.py:39: [C0111(missing-docstring), util_help] Missing function docstring
util.py:46: [C0111(missing-docstring), main_start_interactive] Missing function docstring
util.py:48: [W0611(unused-import), main_start_interactive] Unused import readline
util.py:54: [C0111(missing-docstring), main_loop] Missing function docstring
util.py:64: [W1505(deprecated-method), main_loop] Using deprecated method getargspec()
util.py:63: [W0612(unused-variable), main_loop] Unused variable 'desc'
util.py:74: [C0111(missing-docstring), get_input] Missing function docstring
util.py:6: [W0611(unused-import), ] Unused import os
************* Module ws
ws.py:1: [C0111(missing-docstring), ] Missing module docstring
ws.py:16: [C0413(wrong-import-position), ] Import "import os" should be placed at the top of the module
ws.py:18: [E0401(import-error), ] Unable to import 'websocket'
ws.py:18: [C0413(wrong-import-position), ] Import "import websocket" should be placed at the top of the module
ws.py:19: [C0413(wrong-import-position), ] Import "from threading import Thread" should be placed at the top of the module
ws.py:20: [C0413(wrong-import-position), ] Import "import traceback" should be placed at the top of the module
ws.py:21: [C0413(wrong-import-position), ] Import "from bodyfetcher import BodyFetcher" should be placed at the top of the module
ws.py:22: [C0413(wrong-import-position), ] Import "import chatcommunicate" should be placed at the top of the module
ws.py:23: [C0413(wrong-import-position), ] Import "from datetime import datetime" should be placed at the top of the module
ws.py:24: [C0413(wrong-import-position), ] Import "from spamhandling import check_if_spam_json" should be placed at the top of the module
ws.py:25: [C0413(wrong-import-position), ] Import "from globalvars import GlobalVars" should be placed at the top of the module
ws.py:26: [C0413(wrong-import-position), ] Import "from datahandling import load_files, filter_auto_ignored_posts" should be placed at the top of the module
ws.py:27: [C0413(wrong-import-position), ] Import "from metasmoke import Metasmoke" should be placed at the top of the module
ws.py:28: [C0413(wrong-import-position), ] Import "from deletionwatcher import DeletionWatcher" should be placed at the top of the module
ws.py:29: [C0413(wrong-import-position), ] Import "import json" should be placed at the top of the module
ws.py:30: [C0413(wrong-import-position), ] Import "import time" should be placed at the top of the module
ws.py:31: [C0413(wrong-import-position), ] Import "import requests" should be placed at the top of the module
ws.py:33: [C0413(wrong-import-position), ] Import "from tld.utils import update_tld_names, TldIOError" should be placed at the top of the module
ws.py:34: [C0413(wrong-import-position), ] Import "from helpers import exit_mode, log, Helpers, log_exception" should be placed at the top of the module
ws.py:35: [C0413(wrong-import-position), ] Import "from flovis import Flovis" should be placed at the top of the module
ws.py:36: [C0413(wrong-import-position), ] Import "from tasks import Tasks" should be placed at the top of the module
ws.py:38: [C0413(wrong-import-position), ] Import "import chatcommands" should be placed at the top of the module
ws.py:44: [W0703(broad-except), ] Catching too general exception Exception
ws.py:43: [E0401(import-error), ] Unable to import 'plugin'
ws.py:45: [C0103(invalid-name), ] Constant name "exc_type" doesn't conform to UPPER_CASE naming style
ws.py:45: [C0103(invalid-name), ] Constant name "exc_obj" doesn't conform to UPPER_CASE naming style
ws.py:45: [C0103(invalid-name), ] Constant name "exc_tb" doesn't conform to UPPER_CASE naming style
ws.py:46: [C0103(invalid-name), ] Constant name "error_msg" doesn't conform to UPPER_CASE naming style
ws.py:46: [E1305(too-many-format-args), ] Too many arguments for format string
ws.py:50: [C0103(invalid-name), ] Constant name "levels" doesn't conform to UPPER_CASE naming style
ws.py:57: [C0103(invalid-name), ] Constant name "idx" doesn't conform to UPPER_CASE naming style
ws.py:58: [C0103(invalid-name), ] Constant name "arg" doesn't conform to UPPER_CASE naming style
ws.py:76: [C0111(missing-docstring), restart_automatically] Missing function docstring
ws.py:98: [W0107(unnecessary-pass), ] Unnecessary pass statement
ws.py:104: [W0107(unnecessary-pass), ] Unnecessary pass statement
ws.py:111: [C0103(invalid-name), ] Constant name "username" doesn't conform to UPPER_CASE naming style
ws.py:114: [C0103(invalid-name), ] Constant name "username" doesn't conform to UPPER_CASE naming style
ws.py:121: [C0103(invalid-name), ] Constant name "password" doesn't conform to UPPER_CASE naming style
ws.py:124: [C0103(invalid-name), ] Constant name "password" doesn't conform to UPPER_CASE naming style
ws.py:154: [C0111(missing-docstring), check_socket_connections] Missing function docstring
ws.py:155: [W0212(protected-access), check_socket_connections] Access to a protected member _clients of a client class
ws.py:168: [W0621(redefined-outer-name), setup_websocket] Redefining name 'ws' from outer scope (line 178)
ws.py:166: [C0111(missing-docstring), setup_websocket] Missing function docstring
ws.py:176: [C0103(invalid-name), ] Constant name "max_tries" doesn't conform to UPPER_CASE naming style
ws.py:192: [C0103(invalid-name), ] Constant name "metasmoke_ws_t" doesn't conform to UPPER_CASE naming style
ws.py:214: [W0703(broad-except), ] Catching too general exception Exception
ws.py:197: [C0103(invalid-name), ] Constant name "a" doesn't conform to UPPER_CASE naming style
ws.py:199: [C0103(invalid-name), ] Constant name "action" doesn't conform to UPPER_CASE naming style
ws.py:204: [C0103(invalid-name), ] Constant name "data" doesn't conform to UPPER_CASE naming style
ws.py:207: [C0103(invalid-name), ] Constant name "is_spam" doesn't conform to UPPER_CASE naming style
ws.py:207: [C0103(invalid-name), ] Constant name "reason" doesn't conform to UPPER_CASE naming style
ws.py:207: [C0103(invalid-name), ] Constant name "why" doesn't conform to UPPER_CASE naming style
ws.py:209: [C0103(invalid-name), ] Constant name "t" doesn't conform to UPPER_CASE naming style
ws.py:215: [C0103(invalid-name), ] Constant name "exc_type" doesn't conform to UPPER_CASE naming style
ws.py:215: [C0103(invalid-name), ] Constant name "exc_obj" doesn't conform to UPPER_CASE naming style
ws.py:215: [C0103(invalid-name), ] Constant name "exc_tb" doesn't conform to UPPER_CASE naming style
ws.py:216: [C0103(invalid-name), ] Constant name "now" doesn't conform to UPPER_CASE naming style
ws.py:217: [C0103(invalid-name), ] Constant name "delta" doesn't conform to UPPER_CASE naming style
ws.py:218: [C0103(invalid-name), ] Constant name "seconds" doesn't conform to UPPER_CASE naming style
ws.py:219: [C0103(invalid-name), ] Constant name "tr" doesn't conform to UPPER_CASE naming style
ws.py:220: [C0103(invalid-name), ] Constant name "exception_only" doesn't conform to UPPER_CASE naming style
ws.py:222: [C0103(invalid-name), ] Constant name "n" doesn't conform to UPPER_CASE naming style
ws.py:223: [C0103(invalid-name), ] Constant name "logged_msg" doesn't conform to UPPER_CASE naming style
ws.py:229: [C0103(invalid-name), ] Constant name "ws" doesn't conform to UPPER_CASE naming style
ws.py:38: [W0611(unused-import), ] Unused import chatcommands
ws.py:43: [W0611(unused-import), ] Unused import plugin
ws.py:6: [C0411(wrong-import-order), ] standard import "import sys" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:16: [C0411(wrong-import-order), ] standard import "import os" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:19: [C0411(wrong-import-order), ] standard import "from threading import Thread" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:20: [C0411(wrong-import-order), ] standard import "import traceback" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:23: [C0411(wrong-import-order), ] standard import "from datetime import datetime" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:29: [C0411(wrong-import-order), ] standard import "import json" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:30: [C0411(wrong-import-order), ] standard import "import time" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:31: [C0411(wrong-import-order), ] third party import "import requests" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:33: [C0411(wrong-import-order), ] third party import "from tld.utils import update_tld_names, TldIOError" should be placed before "from excepthook import uncaught_exception, install_thread_excepthook"
ws.py:1: [R0401(cyclic-import), ] Cyclic import (globalvars -> helpers)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (datahandling -> parsing)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommunicate -> socketscience)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommunicate -> datahandling -> metasmoke -> findspam)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommunicate -> metasmoke -> findspam)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (apigetpost -> parsing -> datahandling -> metasmoke)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (datahandling -> metasmoke)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (metasmoke -> spamhandling)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommunicate -> parsing -> datahandling -> metasmoke -> findspam)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommands -> findspam -> chatcommunicate -> parsing -> datahandling -> metasmoke)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommunicate -> parsing -> datahandling -> metasmoke -> spamhandling -> findspam)
ws.py:1: [R0401(cyclic-import), ] Cyclic import (chatcommands -> metasmoke)