forked from LBRYCommunity/lbry-sdk
155 lines
4.2 KiB
Python
155 lines
4.2 KiB
Python
import re
|
|
import sys
|
|
import argparse
|
|
from pathlib import Path
|
|
from textwrap import fill, indent
|
|
|
|
|
|
INDENT = ' ' * 4
|
|
|
|
CLASS = """
|
|
|
|
class {name}({parents}):{doc}
|
|
"""
|
|
|
|
INIT = """
|
|
def __init__({args}):
|
|
super().__init__({format}"{message}")
|
|
"""
|
|
|
|
|
|
class ErrorClass:
|
|
|
|
def __init__(self, hierarchy, name, message):
|
|
self.hierarchy = hierarchy.replace('**', '')
|
|
self.other_parents = []
|
|
if '(' in name:
|
|
assert ')' in name, f"Missing closing parenthesis in '{name}'."
|
|
self.other_parents = name[name.find('(')+1:name.find(')')].split(',')
|
|
name = name[:name.find('(')]
|
|
self.name = name
|
|
self.class_name = name+'Error'
|
|
self.message = message
|
|
self.comment = ""
|
|
if '--' in message:
|
|
self.message, self.comment = message.split('--')
|
|
self.message = self.message.strip()
|
|
self.comment = self.comment.strip()
|
|
|
|
@property
|
|
def is_leaf(self):
|
|
return 'x' not in self.hierarchy
|
|
|
|
@property
|
|
def code(self):
|
|
return self.hierarchy.replace('x', '')
|
|
|
|
@property
|
|
def parent_codes(self):
|
|
return self.hierarchy[0:2], self.hierarchy[0]
|
|
|
|
def get_arguments(self):
|
|
args = ['self']
|
|
for arg in re.findall('{([a-z0-1]+)}', self.message):
|
|
args.append(arg)
|
|
return args
|
|
|
|
@staticmethod
|
|
def get_doc_string(doc):
|
|
if doc:
|
|
return f'\n{INDENT}"""\n{indent(fill(doc, 100), INDENT)}\n{INDENT}"""'
|
|
return ""
|
|
|
|
def render(self, out, parent):
|
|
if not parent:
|
|
parents = ['BaseError']
|
|
else:
|
|
parents = [parent.class_name]
|
|
parents += self.other_parents
|
|
args = self.get_arguments()
|
|
if self.is_leaf:
|
|
out.write((CLASS + INIT).format(
|
|
name=self.class_name, parents=', '.join(parents), args=', '.join(args),
|
|
message=self.message, doc=self.get_doc_string(self.comment), format='f' if len(args) > 1 else ''
|
|
))
|
|
else:
|
|
out.write(CLASS.format(
|
|
name=self.class_name, parents=', '.join(parents),
|
|
doc=self.get_doc_string(self.comment or self.message)
|
|
))
|
|
|
|
|
|
def get_errors():
|
|
with open('README.md', 'r') as readme:
|
|
lines = iter(readme.readlines())
|
|
for line in lines:
|
|
if line.startswith('## Exceptions Table'):
|
|
break
|
|
for line in lines:
|
|
if line.startswith('---:|'):
|
|
break
|
|
for line in lines:
|
|
if not line:
|
|
break
|
|
yield ErrorClass(*[c.strip() for c in line.split('|')])
|
|
|
|
|
|
def find_parent(stack, child):
|
|
for parent_code in child.parent_codes:
|
|
parent = stack.get(parent_code)
|
|
if parent:
|
|
return parent
|
|
|
|
|
|
def generate(out):
|
|
out.write('from .base import BaseError\n')
|
|
stack = {}
|
|
for error in get_errors():
|
|
error.render(out, find_parent(stack, error))
|
|
if not error.is_leaf:
|
|
assert error.code not in stack, f"Duplicate code: {error.code}"
|
|
stack[error.code] = error
|
|
|
|
|
|
def analyze():
|
|
errors = {e.class_name: [] for e in get_errors() if e.is_leaf}
|
|
here = Path(__file__).absolute().parents[0]
|
|
module = here.parent
|
|
for file_path in module.glob('**/*.py'):
|
|
if here in file_path.parents:
|
|
continue
|
|
with open(file_path) as src_file:
|
|
src = src_file.read()
|
|
for error in errors.keys():
|
|
found = src.count(error)
|
|
if found > 0:
|
|
errors[error].append((file_path, found))
|
|
|
|
print('Unused Errors:\n')
|
|
for error, used in errors.items():
|
|
if used:
|
|
print(f' - {error}')
|
|
for use in used:
|
|
print(f' {use[0].relative_to(module.parent)} {use[1]}')
|
|
print('')
|
|
|
|
print('')
|
|
print('Unused Errors:')
|
|
for error, used in errors.items():
|
|
if not used:
|
|
print(f' - {error}')
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("action", choices=['generate', 'analyze'])
|
|
args = parser.parse_args()
|
|
if args.action == "analyze":
|
|
analyze()
|
|
elif args.action == "generate":
|
|
generate(sys.stdout)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|