def main(csv_name, version, overlay):
with open(csv_name, mode='r') as csv_file:
csv_reader = csv.DictReader(csv_file)
line_count = 0
total_func = 0
done_func = 0
total_byte = 0
done_byte = 0
for row in csv_reader:
if (row["version"] == version):
total_func += 1
total_byte += int(row['length'])
if row['matching'] == 'yes':
done_func += 1
done_byte += int(row['length'])
percent = ((done_byte / total_byte) * 100)
print("%s: bytes: %3.4f%% (%d/%d), funcs: %3.4f%% (%d/%d)" %
(overlay, percent, done_byte, total_byte,
((done_func / total_func) * 100), done_func, total_func))
green = min(255, round(min(1, (percent / 100) * 2) * 256))
red = min(255, round(min(1, ((100 - percent) / 100) * 2) * 256))
color = RGB_to_hex([red, green, 0])
if overlay == 'total':
badge = anybadge.Badge("Banjo-Kazooie (us.v10)",
"%3.4f%%" % (percent),
default_color=color)
else:
badge = anybadge.Badge(overlay,
"%3.4f%%" % (percent),
default_color=color)
badge.write_badge('progress/progress_' + overlay + '.svg',
overwrite=True)
def pylint_check(int_only, create_badge):
try:
import re
import anybadge
from pylint import epylint
pylint_stdout, pylint_stderr = epylint.py_run("hyperglass",
return_std=True)
pylint_output = pylint_stdout.getvalue()
pylint_score = re.search(
r"Your code has been rated at (\d+\.\d+)\/10.*",
pylint_output).group(1)
if not pylint_score == "10.00":
raise RuntimeError(f"Pylint score {pylint_score} not acceptable.")
if create_badge:
badge_file = os.path.join(working_directory, "pylint.svg")
if os.path.exists(badge_file):
os.remove(badge_file)
ab_thresholds = {1: "red", 10: "green"}
badge = anybadge.Badge("pylint",
pylint_score,
thresholds=ab_thresholds)
badge.write_badge("pylint.svg")
if not int_only:
click.secho(f"Created Pylint badge for score: {pylint_score}",
fg="blue",
bold=True)
if int_only:
click.echo(pylint_score)
except ImportError as error_exception:
click.secho(f"Import error:\n{error_exception}", fg="red", bold=True)
def badge_render():
try:
badge = anybadge.Badge('CI', report_status, thresholds={'PASS': '******', 'FAIL': 'red'})
badge.write_badge(outdir + 'badge.svg')
with open(outdir + 'ci-status.yml', 'w') as f:
f.write('CI: "' + report_status + '"')
except Exception as error:
print(error)
def badge_generator(status):
thresholds = {
'critical': 'red',
'minor': 'yellow',
'passed': 'green',
'processing': 'lightgrey',
}
badge = anybadge.Badge('Smart Contracts', status, thresholds=thresholds)
return badge.badge_svg_text
def badge_render():
try:
badge = anybadge.Badge('CI',
report_status,
thresholds={
'PASS': '******',
'FAIL': 'red'
})
badge.write_badge(outdir + 'badge.svg')
except Exception as error:
print(error)
def generate_coverage_badge(coverage):
badge_path = os.path.join(BASE_DIR, '.meta', 'media', 'coverage.svg')
badge = anybadge.Badge('coverage',
coverage,
thresholds={
50: 'red',
60: 'orange',
80: 'yellow',
100: 'green'
},
value_suffix='%')
os.remove(badge_path)
badge.write_badge(badge_path)
def generate_badge(target, layout, attribute):
"""
Generate a badge
:param target: Dict
:param layout: Dict
:param attribute: String
:return:
"""
thresholds = {50: 'red',
90: 'yellow',
100: 'green'}
badge = anybadge.Badge(layout['label'], round(layout['value']), thresholds=thresholds)
badge.write_badge(f'{utility.get_data_dir()}_{target["identifier"]}.{attribute}.svg', overwrite=True)
def public_stats(summary: int, label, badgesvg, badgeid, logfile):
print('public_stats')
badge = anybadge.Badge(label=label,
value=summary,
default_color='green',
num_padding_chars=1)
badge.write_badge(badgesvg, overwrite=True)
badge_put = requests.put(
url=
f'https://gitlab.com/api/v4/projects/{CI_PROJECT_ID}/badges/{badgeid}',
json={
'link_url': f'{CI_JOB_URL}/artifacts/raw/{logfile}',
'image_url': f'{CI_JOB_URL}/artifacts/raw/{badgesvg}'
},
headers={'PRIVATE-TOKEN': PRIVATE_TOKEN})
if badge_put.status_code in [200, 201]:
pprint('badge published')
else:
pprint('badge publish failed')
sys.exit(1)
#!/usr/bin/python
"""
anybadge test module.
"""
import anybadge
if __name__ == '__main__':
thresholds = {2: 'red', 4: 'orange', 6: 'green', 8: 'brightgreen'}
badge = anybadge.Badge('test',
'2.22',
value_suffix='%',
thresholds=thresholds,
text_color='#010101,#101010')
print(badge.badge_svg_text)
def setUpClass(cls):
cls.my_db = Database(db_name="campusdb", dbs_type="mysql")
# add tables
cls.my_db.add_table(table_name="studiengang", n_rows=10)
cls.my_db.add_table(table_name="student", n_rows=150)
# add columns to studiengang table
cls.my_db.tables["studiengang"].add_primary_key(
column_name="studiengang_id"
)
cls.my_db.tables["studiengang"].add_column(
column_name="bezeichnung",
data_type="varchar(50)",
data_target="name"
)
cls.my_db.tables["studiengang"].add_column(
column_name="start_datum",
data_type="date",
data_target="date"
)
# add columns to student table
cls.my_db.tables["student"].add_primary_key(
column_name="student_id"
)
cls.my_db.tables["student"].add_column(
column_name="firstname",
data_type="varchar(50)",
data_target="first_name"
)
cls.my_db.tables["student"].add_column(
column_name="lastname",
data_type="varchar(50)",
data_target="last_name"
)
cls.my_db.tables["student"].add_foreign_key(
column_name="studiengang_id",
target_table="studiengang",
target_column="studiengang_id"
)
# generate data
cls.my_db.generate_data()
cls.my_db.export_sql("test_1.sql")
# add recursive db
cls.hr = Database(db_name="hr", dbs_type="mysql")
cls.hr.add_table(table_name="employee", n_rows=10)
cls.hr.tables["employee"].add_primary_key(column_name="emp_id")
cls.hr.tables["employee"].add_column(column_name="firstname", data_type="varchar(50)", data_target="first_name")
cls.hr.tables["employee"].add_column(column_name="lastname", data_type="varchar(50)", data_target="last_name")
cls.hr.tables["employee"].add_foreign_key(column_name="boss_id", target_table="employee", target_column="emp_id")
cls.hr.generate_data(recursive = True)
cls.hr.export_sql("test_2.sql")
# create test badge
if os.path.exists('badges/dbsetup.svg'):
os.remove('badges/dbsetup.svg')
thresholds = {
0.2: 'red',
0.4: 'orange',
0.6: 'yellow',
1: 'green'
}
badge_runs = anybadge.Badge(
'Database Setup',
round(1, 2),
thresholds=thresholds
)
badge_runs.write_badge('badges/dbsetup.svg')
"""
Utility to run pylint and update the badge
"""
import re
import sys
import json
from io import StringIO
import anybadge
# Get the score
data = json.load(open(sys.argv[1], 'r'))
coverage_pct = round(data['totals']['percent_covered'])
# Define thresholds: <2=red, <4=orange <8=yellow <10=green
thresholds = {20: 'red',
40: 'orange',
70: 'yellow',
90: 'green'}
badge = anybadge.Badge('coverage', coverage_pct,
thresholds=thresholds, value_suffix="%")
badge.write_badge('imgs/coverage.svg', overwrite=True)
# failunder
if coverage_pct < 90:
exit(1)
PARSER.add_argument("--gitHubPat", type=str, required=True)
ARGS = PARSER.parse_args()
PYLINT_CMD = ["pylint --exit-zero ./**/*.py"]
PYLINT_OUTPUT = subprocess.run(PYLINT_CMD,
check=True,
stdout=subprocess.PIPE,
shell=True).stdout.decode("utf-8")
PYLINT_SCORE = PYLINT_OUTPUT.split("at ", 1)[1].split("/", 1)[0]
print(f"[INFO] PYLINT_SCORE: {PYLINT_SCORE}")
ANYBADGE_THRESHOLDS = {2: "red", 4: "orange", 6: "yellow", 10: "green"}
BADGE = anybadge.Badge("pylint", PYLINT_SCORE, thresholds=ANYBADGE_THRESHOLDS)
BADGE.write_badge("pylint.svg")
SVG = open("pylint.svg", "r")
SVG_READ = SVG.read()
URL = "https://api.github.com/gists/{}".format(ARGS.gistId)
HEADERS = {"Authorization": f"token {ARGS.gitHubPat}"}
DATA = {
"description": "Created via API",
"files": {
"pylint.svg": {
"content": f"{SVG_READ}"
}
},
}
with open("build/reports/ci-metrics.json", "r") as json_file:
data = json.load(json_file)
###############################################################################
# BUILD STATUS
## GREEN BUILD DATE ===========================================================
# Extract metric
label = "green build"
metric = data["build-status"]["green"]["timestamp"]
timestamp = datetime.fromtimestamp(metric)
value = timestamp.strftime("%Y/%m/%d %H:%M:%S")
color = "lightgrey"
# Create badge
badge = anybadge.Badge(label=label, value=value, default_color=color, value_prefix=' ', value_suffix=' ')
# Write badge
badge.write_badge("build/badges/build_green_date.svg", overwrite=True)
## LAST BUILD STATUS ==========================================================
# Extract metric
label = "last build"
metric = data["build-status"]["last"]["status"]
value = metric
if metric == "failed":
# set colour
color = "red"
elif metric == "success":
# set colour
options[_screens[i]['number']] = {
'current': 0,
'total': len(screens[_screens[i]['number']]['forwards'])
}
if options[_screens[i]['number']]['total'] > 1:
nPaths += options[_screens[i]['number']]['total'] - 1
del _screens
maxStepsToEnding = 200
for _iPath in range(nPaths):
iScreen = 0
for i in range(maxStepsToEnding):
iScreen, options = moveToNextScreen(iScreen, options, screens)
if iScreen == 888:
break
if i == maxStepsToEnding - 1:
raise ValueError('Potential loop found!')
print('All checks complete and successful!')
#Define thresholds: <2=red, <4=orange <8=yellow <10=green
thresholds = {4: 'red', 8: 'orange', 12: 'yellow', 16: 'green'}
badge = anybadge.Badge('Anzahl Geschichten',
str(int(nPaths)),
thresholds=thresholds)
badge.write_badge('paths.svg')
def main():
"""
Main function to check the implemementation files herein this repo
and what is specced out in the TFC API docs.
"""
non_admin_endpoints = get_docs_from_github()
admin_endpoints = get_docs_from_github(is_admin=True)
# Merge the endpoint types
endpoints = non_admin_endpoints.copy()
endpoints.update(admin_endpoints)
endpoints = check_contributor_requirements(endpoints)
endpoints = check_methods_implementation(endpoints)
write_pretty_json_to_file("./ref/data/endpoint_data.raw.json", endpoints)
# High level comparison which shows if the endpoint is implemented at all.
# Build a markdown table for GitHub display
endpoint_headers = [
"Endpoint", "Module", "Has Implementation", "Has Test", "Has Docs"
]
endpoint_rows = []
# TODO: make sure implementation and test and docs work
for ep_name in endpoints:
endpoint = endpoints[ep_name]
endpoint_rows.append([
f'[{ep_name.replace("_", " ").title()}]({endpoint["docs-url"]})',
f'`{ep_name}`', "implementation" in endpoint, "test" in endpoint,
"docs" in endpoint
])
endpoint_rows.sort(key=lambda x: x[0])
write_table_to_file("./CONTRIBUTING_REQS_TABLE.md", endpoint_rows,
endpoint_headers, "github")
md_method_headers = [
"API Endpoint", "Endpoint Description", "HTTP Method",
"Terrasnek Method", "Implemented"
]
md_method_rows = []
for ep_name in endpoints:
endpoint = endpoints[ep_name]
for method_header in endpoint["methods"]:
method = endpoint["methods"][method_header]
method_name = None
if method["implementation-method-name"] is not None:
method_name = f'`{ep_name}.{method["implementation-method-name"]}`'
md_method_row = [
ep_name.replace("_", " ").replace("-", " ").title(),
f"[{method_header}]({method['permalink']})",
method["http-paths"][0], method_name, method["implemented"]
]
md_method_rows.append(md_method_row)
md_method_rows.sort(key=lambda x: x[0])
write_table_to_file("./TERRASNEK_API_COVERAGE_COMPLETENESS.md", \
md_method_rows, md_method_headers, "github")
# Build an RST table for the Sphinx Python Docs
rst_method_headers = [
"API Endpoint", "Endpoint Description", "HTTP Method",
"Terrasnek Method", "Implemented", "Permalink"
]
rst_method_rows = []
for ep_name in endpoints:
endpoint = endpoints[ep_name]
for method_header in endpoint["methods"]:
method = endpoint["methods"][method_header]
method_name = None
if method["implementation-method-name"] is not None:
method_name = f'`{ep_name}.{method["implementation-method-name"]}`'
rst_method_row = [
ep_name.replace("_", " ").title(), f'`{method_header}`',
f'`{method["http-paths"][0]}`', method_name,
method["implemented"], method["permalink"]
]
rst_method_rows.append(rst_method_row)
rst_method_rows.sort(key=lambda x: x[0])
write_table_to_file("./docs/TERRASNEK_API_COVERAGE_COMPLETENESS.rst", \
rst_method_rows, rst_method_headers, "rst")
# Write a badge for the # of implemented methods vs the total # of method endpoints
num_methods_implemented = 0
num_total_methods = 0
for ep_name in endpoints:
endpoint = endpoints[ep_name]
for method_header in endpoint["methods"]:
method = endpoint["methods"][method_header]
num_total_methods += 1
if method["implemented"]:
num_methods_implemented += 1
badge_text = f"{num_methods_implemented}/{num_total_methods} API endpoints implemented"
print(badge_text)
implemented_pct = round(
((num_methods_implemented / num_total_methods) * 100), 2)
badge = anybadge.Badge(badge_text,
f"{implemented_pct}%",
default_color="lightgrey")
badge.write_badge("api_endpoints_implemented.svg", overwrite=True)
# We want this to error if we fall below 99% coverage so we know we have to do work
if implemented_pct <= 99:
sys.exit(1)
import anybadge
if __name__ == '__main__':
print("""| Color Name | Hex Code | Example |
| ---------- | -------- | ------- |""")
for color, hex in sorted(anybadge.COLORS.items()):
file = 'examples/color_' + color + '.svg'
url = 'https://cdn.rawgit.com/jongracecox/anybadge/master/' + file
anybadge.Badge(label='Color', value=color, default_color=color).write_badge(file, overwrite=True)
print("| {color} | {hex} |  |".format(color=color, hex=hex.upper(), url=url))
def main():
endpoints = scrape_endpoint_info()
endpoints = check_contributor_requirements(endpoints)
endpoints = check_methods_implementation(endpoints)
# High level comparison which shows if the endpoint is implemented at all.
# Build a markdown table for GitHub display
endpoint_headers = [
"Endpoint", "Module", "Has Implementation", "Has Test", "Has Docs"
]
endpoint_rows = []
for ep_name in endpoints:
endpoint = endpoints[ep_name]
endpoint_rows.append([
f'[{ep_name.replace("_", " ").title()}]({endpoint["url"]})',
f'`{ep_name}`', "implementation" in endpoint, "test" in endpoint,
"docs" in endpoint
])
endpoint_rows.sort(key=lambda x: x[0])
write_table_to_file("./CONTRIBUTING_REQS_TABLE.md", endpoint_rows,
endpoint_headers, "github")
md_method_headers = [
"API Endpoint", "Method Description", "HTTP Method",
"Terrasnek Method", "Implemented"
]
md_method_rows = []
for ep_name in endpoints:
endpoint = endpoints[ep_name]
for method in endpoint["methods"]:
method_name = None
if method["implementation-method-name"] is not None:
method_name = f'`{ep_name}.{method["implementation-method-name"]}`'
md_method_row = [
ep_name.replace("_", " ").title(),
f'[{method["description"]}]({endpoint["url"]}{method["permalink"]})',
f'`{method["http-path"]}`', method_name, method["implemented"]
]
md_method_rows.append(md_method_row)
md_method_rows.sort(key=lambda x: x[0])
write_table_to_file("./API_PARITY_TABLE.md", md_method_rows,
md_method_headers, "github")
# Build an RST table for the Sphinx Python Docs
rst_method_headers = [
"API Endpoint", "Method Description", "HTTP Method",
"Terrasnek Method", "Implemented", "Permalink"
]
rst_method_rows = []
for ep_name in endpoints:
endpoint = endpoints[ep_name]
for method in endpoint["methods"]:
method_name = None
if method["implementation-method-name"] is not None:
method_name = f'`{ep_name}.{method["implementation-method-name"]}`'
rst_method_row = [
ep_name.replace("_",
" ").title(), f'`{method["description"]}`',
f'`{method["http-path"]}`', method_name, method["implemented"],
f'{endpoint["url"]}{method["permalink"]}'
]
rst_method_rows.append(rst_method_row)
rst_method_rows.sort(key=lambda x: x[0])
write_table_to_file("./docs/api_parity_table.rst", rst_method_rows,
rst_method_headers, "rst")
# TODO: write the endpoints mapping out to a file
# Write a badge for the # of implemented methods vs the total # of method endpoints
num_methods_implemented = 0
num_total_methods = 0
for ep_name in endpoints:
endpoint = endpoints[ep_name]
for method in endpoint["methods"]:
num_total_methods += 1
if method["implemented"]:
num_methods_implemented += 1
badge_text = f"{num_methods_implemented}/{num_total_methods} API endpoints implemented"
implemented_pct = round(
((num_methods_implemented / num_total_methods) * 100), 2)
badge = anybadge.Badge(badge_text,
f"{implemented_pct}%",
default_color="lightgrey")
badge.write_badge("api_endpoints_implemented.svg", overwrite=True)
if os.path.exists('badges/errors.svg'):
os.remove('badges/errors.svg')
if os.path.exists('badges/failures.svg'):
os.remove('badges/failures.svg')
if os.path.exists('badges/tests.svg'):
os.remove('badges/tests.svg')
if os.path.exists('badges/total.svg'):
os.remove('badges/total.svg')
thresholds = {
1: 'green',
2: "orange",
3: "red"
}
badge_errors = anybadge.Badge('Test errors', number_of_errors, thresholds=thresholds)
badge_errors.write_badge('badges/errors.svg')
thresholds = {
1: 'green',
2: "orange",
3: "red"
}
badge_failures = anybadge.Badge('Tests failed', number_of_failures, thresholds=thresholds)
badge_failures.write_badge('badges/failures.svg')
thresholds = {
0: 'green'
}
badge_runs = anybadge.Badge('Tests run', number_of_tests, thresholds=thresholds)
badge_runs.write_badge('badges/tests.svg')
import anybadge
import coverage
import unittest
tresholds = {
40: 'red',
60: 'orange',
80: 'yellow',
100: 'green',
}
if __name__ == '__main__':
cov = coverage.Coverage()
cov.start()
from tests import test # Needs to be after cov.start to count lines with function definition
suite = unittest.TestLoader().loadTestsFromModule(test)
unittest.TextTestRunner(verbosity=2).run(suite)
cov.stop()
value = round(cov.report(morfs='src/to_be_tested.py'), 2)
badge = anybadge.Badge("Coverage",
value,
thresholds=tresholds,
value_suffix='%')
badge.write_badge("docs/img/Coverage.svg", overwrite=True)
import anybadge
from pylint.lint import Run
results = Run(['fleet_management'], do_exit=False)
score = results.linter.stats['global_note']
thresholds = {2: 'red', 4: 'orange', 6: 'yellow', 10: 'green'}
badge = anybadge.Badge('pylint score', round(score, 2), thresholds=thresholds)
badge.write_badge('pylint.svg')
from io import StringIO
import anybadge
from pylint.lint import Run
from pylint.reporters.text import TextReporter
# run pylint
output = StringIO()
Run(['--rcfile=.pylintrc', 'truvari'],
reporter=TextReporter(output),
exit=False)
output.seek(0)
output = output.read()
# Get the score
search = re.search("Your code has been rated at (?P<score>.*)/10", output)
pylint_score = float(search.groupdict()['score'])
if pylint_score == 10:
pylint_score = int(pylint_score)
# Define thresholds: <2=red, <4=orange <8=yellow <10=green
thresholds = {2: 'red', 4: 'orange', 6: 'yellow', 10: 'green'}
badge = anybadge.Badge('pylint', pylint_score, thresholds=thresholds)
badge.write_badge('imgs/pylint.svg', overwrite=True)
sys.stdout.write(output)
# failunder
if pylint_score != 10:
exit(1)
