def _write_arguments(cls, file: MdUtils, title: str, args: List[SerializedArgument]): def _process_flag(arg: SerializedArgument) -> str: flag = arg.flags if flag and arg.choices: return f'{flag}={arg.choices}' if flag and arg.name: return f'{flag}={arg.name}' return arg.name if arg.name else flag def _process_description(arg: SerializedArgument) -> str: description = arg.description.replace('*', r'\*') description += '. Multiple arguments' if arg.nargs else '' return f'{description}. Default: `{arg.default}`' if arg.default else description if not args: return file.new_header(level=3, title=title, add_table_of_contents='n') for arg in args: description = _process_description(arg).replace('..', '.') file.new_header(level=5, title=f'`{_process_flag(arg)}`', add_table_of_contents='n') file.new_paragraph(description)
def createMarkdownFile(pz_releases, issues, markdownFileName): # title md_title = "PPG Services Release Summary ({}, {})".format( dayOfWeek, date_str) # Header mdFile = MdUtils(file_name=markdownFileName, title=md_title) # for each release line, add issues releases = sorted(pz_releases.keys(), reverse=True) for r in releases: release = pz_releases.get(r) mdFile.new_line() mdFile.new_line() mdFile.new_header(level=1, title='Release {} ({}):'.format( release[1], release[2])) for issue in issues: if issue.fields.customfield_10414[0] == release[1]: text = '{}: {}.\n'.format(issue.key, issue.fields.summary) mdFile.new_line(text) mdFile.new_line() # Write to markdown document mdFile.create_md_file() # create html file with open('{}.md'.format(markdownFileName), "r", encoding="utf-8") as input_file: text = input_file.read() html = markdown.markdown(text) with open('{}.html'.format(markdownFileName), "w", encoding="utf-8", errors="xmlcharrefreplace") as output_file: output_file.write(html)
def generate_report(): df_final = predictionsPerSecond() explode = (0.1, 0.1, 0.1) plt.pie(df_final.Label.value_counts(), explode=explode, labels=df_final.Label.value_counts().index.to_list(), autopct='%1.1f%%', shadow=True, startangle=90) plt.title('Tiempo de uso de mascarilla') plt.savefig('predictions.png') mdFile = MdUtils( file_name='report', title='Reporte de predicción de uso correcto de mascarilla') mdFile.new_line( mdFile.new_inline_image(text='Predicciones', path='predictions.png')) mdFile.new_header(title='Tablas de resultados', level=1) mdFile.new_line('Juan Pablo Carranza Hurtado') mdFile.new_line('José Alberto Ligorría Taracena') mdFile.create_md_file() f = open("report.html", "w") f.write(markdown2.markdown_path('report.md')) f.write(pd.crosstab(df_final.Time, df_final.Label).to_html()) f.write('<h1> Cantidad de segundos de utilización de mascarilla </h1>') f.write(pd.DataFrame(df_final.Label.value_counts()).to_html()) f.close()
def main(): md_file = MdUtils(file_name='hacker_news', title='temp') md_file.new_header(level=1, title='Daily Hacker News') stories = get_top_stories() for i, v in enumerate(stories): item = get_topic_item(v) id = item['id'] title = item['title'] url = item.get('url', None) if url: domain = url_parser(url) md_file.new_line( '{}. {} `{}` [`comments`](https://news.ycombinator.com/item?id={})' .format( str(i + 1), md_file.new_inline_link(link=url, text=title, bold_italics_code='b'), domain, str(id))) else: link = 'https://news.ycombinator.com/item?id={}'.format(str(id)) md_file.new_line('{}. {} [`comments`]({})'.format( str(i + 1), md_file.new_inline_link(link=link, text=title, bold_italics_code='b'), link)) issue_body = md_file.file_data_text date = get_date() issue_url = create_issue('Daily Hacker News {}'.format(date), issue_body)
def generateShapeWorksCommandDocumentation(mdFilename = '../../docs/tools/ShapeWorksCommands.md', add_toc = False): # settings from Executable.cpp opt_width = 32 indent = 2 spacedelim = ''.ljust(indent) mdFile = MdUtils(file_name = mdFilename, title = '') mdFile.new_header(level = 1, title = 'ShapeWorks Commands') # add intro paragraph intro_paragraph = "`shapeworks` is a single executable for ShapeWorks with a set of sub-executables (commands) that are flexible, modular, loosely coupled, and standardized subcommands, with interactive help to perform individual operations needed for a typical shape modeling workflow that includes the Groom, Optimize, and Analyze phases.\n" intro_paragraph = intro_paragraph + "!!! danger " + "\"" + "Activate shapeworks environment" + "\"" + "\n" intro_paragraph = intro_paragraph + "\t Each time you use ShapeWorks from the command line, you must first activate its environment using the `conda activate shapeworks` command on the terminal. \n" intro_paragraph = intro_paragraph + "!!! danger " + "\"" + "Add shapeworks to your path" + "\"" + "\n" intro_paragraph = intro_paragraph + "\t Please make sure that `shapeworks` is in your path. See [Adding to PATH Environment Variable](../dev/paths.md). \n" mdFile.new_paragraph(intro_paragraph) if add_toc: intro_marker = mdFile.create_marker(" ") # mark the after-intro to add table of contents after the introduction paragraph cmd = "shapeworks" CommandsUtils.addCommand(mdFile, cmd, level = 2, spacedelim = spacedelim, verbose = True) if add_toc: mdFile.new_table_of_contents(table_title='Table of Contents', depth=3, marker = intro_marker) mdFile.create_md_file()
def generateReadme(): # defining a function to generate the readme file mdFile = MdUtils(file_name = "LOCAL_README.md") mdFile.new_header(level=1, title="Compilation Of DSC-RAIT resources") mdFile.new_paragraph("This is a compiled list of resources shared on the DSC-RAIT Discord Server!") for d in db.resources.find(): ''' db.resources.find() queries the database and returns all the data stored in the form of an iterable which contains all the domains and links present under each domain, so we are looping through the iterable to insert each domain and its respective resources in the readme file. Each element of the iterable is a python dictionary (in this case, it is 'd') { 'domain': <domain name>, 'links': [ {'info': <link-info1>, 'link': <link1>}, {'info': <link-info2>, 'link': <link2>}, .... ] } ''' mdFile.new_header(level = 2, title = d['domain']) for l in d['links']: mdFile.new_paragraph(text= f"{l['info']}: {l['link']}") mdFile.create_md_file() text = mdFile.read_md_file(file_name = "LOCAL_README.md") # Read the created Readme file return its contents as a string return text
def report(self, reports): xml_dict = parsexmlfile(self.files[0]) result = json.dumps(xml_dict) nmap_results = json.loads(result) ports = nmap_results["nmaprun"]["host"]["ports"] #cpe, portid, product, name, version, hosts/up if 'port' in ports: open_ports = ports["port"] else: open_ports = [] # temp self.logger.info("Creating report for " + self.name) outfile = f"{self.reportdir}/{self.name}.md" title = f"PENSEC - {self.name.capitalize()} Report" reportfile = MdUtils(file_name=outfile, title=title) reportfile.new_header(level=1, title="Common Statistics") reportfile.new_paragraph(f"{len(open_ports)} open ports\n") if len(open_ports) > 0: reportfile.new_header(level=2, title="Open Ports") # list with open ports, cpe, etc reportfile.create_md_file() self.logger.info("Report saved in " + outfile) return {"open_ports": open_ports}
def gen_api_markdown(target_api_class: Any, output_file_path: str, extra_head: str = ""): md_file = MdUtils(file_name=output_file_path) if extra_head: md_file.write(extra_head) md_file.new_header(level=1, title="") for method in get_own_methods(target_api_class): method_name = method.__name__ md_file.new_header(level=2, title=method_name) docstring = method.__doc__ if docstring: md_file.write(f"\n{method.__doc__}\n") parameter_table = ["参数名称", "类型", "默认值"] for parameter in inspect.signature(method).parameters.values(): if parameter.name == "self": continue row = [parameter.name] if isinstance(parameter.annotation, str): row.append(parameter.annotation) else: if get_origin(parameter.annotation) is Union: # group_msg = group_message continue row.append(parameter.annotation.__name__) if parameter.default == inspect._empty: row.append("无") else: if parameter.default: row.append(parameter.default) else: row.append("无") parameter_table.extend(row) # debug(parameter_table) # md_file.new_line() if len(parameter_table) > 3: md_file.new_table( columns=3, rows=int(len(parameter_table) / 3), text=parameter_table, text_align="center", ) md_file.create_md_file() print(f"成功生成{output_file_path}文件")
def main(self): mdFile = MdUtils(file_name='sitelist', title='Scraper Site List') mdFile.new_header(level=1, title='Sites') data = self.loop_spiders() mdFile.new_line() mdFile.new_table(columns=4, rows=int(len(data) / 4), text=data, text_align='center') mdFile.create_md_file()
def create_readme(self): '''saves a .md file with descritption of a maximal setup TODO minimal readme just for subset making - n articles - regex patterns used for subsetting ''' readme = MdUtils(file_name=os.path.join(self.work_dir_path, 'README'), title='Subset readme') # produce content date_generated = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') # SECTION 1: DATE GENERATED readme.new_paragraph() readme.new_header(level=1, title='Date', style='setext') readme.new_line(date_generated) # SECTION 2: FOLDER STRUCTURE SCPECIFICATION readme.new_paragraph() readme.new_header(level=1, title='File structure', style='setext') # top folder: workdir readme.new_line('```') readme.new_line('{}/'.format(os.path.basename(self.work_dir_path))) readme.new_line('├── data_subset/ #raw data used for this analysis') readme.new_line('│ └── *.ndjson') readme.new_line('├── preprocessed/ #preprocessed data') readme.new_line('│ └── *.ndjson') readme.new_line('├── model_input/ #dataset used for topic modeling') readme.new_line('│ └── *.ndjson') readme.new_line('├── mdl_lda/ #outputs of LDA') readme.new_line('│ ├── model_states/ #serialized trained LDAs') readme.new_line('│ │ └── *.pkl') readme.new_line('│ ├── topic_overviews/ #top terms per topic') readme.new_line('│ │ └── *.txt') readme.new_line('│ ├── doc_top_mat/ #document-topic matrices') readme.new_line('│ │ └── *.ndjson') readme.new_line('│ ├── pyldavis/ #pyldavis plots') readme.new_line('│ │ └── *.html') readme.new_line( '│ └── model_comparison.png #elbow plot of n topics and coherence' ) readme.new_line( '└── mdl_ntr/ #outputs of Novelty, Transience, Resonance') readme.new_line(' └── w{number}/ #results at window n') readme.new_line(' ├── *.csv') readme.new_line(' └── fig/ #plots of results at that window') readme.new_line(' └── *.png') readme.new_line('```') readme.new_line() readme.create_md_file()
def generate_report(): report = MdUtils(file_name=f'./report.md') report.new_header(level=1, title='Выделение признаков символов') report.new_line(text='Выполнил Ахманов Алексей Б18-514') report.new_line(text=f'Алфавит - {ALPHABET}') for letter in ALPHABET: letter_folder_path = f'./{folder_helper.IMAGES_FOLDER_PATH}/letter_{letter}' os.makedirs(letter_folder_path, exist_ok=True) letter_image_path = f'{letter_folder_path}/{letter}.png' letter_image = Image.new(mode=constants.GRAYSCALE_MODE, size=(FONT_SIZE, FONT_SIZE), color=WHITE) result = ImageDraw.Draw(im=letter_image, mode=constants.GRAYSCALE_MODE) result.text(xy=(0, 0), text=letter, font=FONT, fill=0, anchor='lt') letter_image = cut_empty_rows_and_cols(letter_image) letter_image.save(letter_image_path) report.new_header(level=2, title=f'Буква {letter}') report.new_line(report.new_inline_image(text=letter, path=letter_image_path)) thresholded = simple_threshold(letter_image, 100) report.new_line(text=f'Вес черного - {black_weight(thresholded)}') report.new_line(text=f'Удельный вес черного - {normalized_black_weight(thresholded)}') center = gravity_center(thresholded) report.new_line(text=f'Координаты центра масс - ({center[0]}, {center[1]})') normalized_center = normalized_gravity_center(thresholded) report.new_line(text=f'Нормированные координаты центра масс - ({normalized_center[0]}, {normalized_center[1]})') report.new_line(text=f'Центральный горизонтальный осевой момент - {central_horizontal_axial_moment(thresholded)}') report.new_line(text=f'Центральный вертикальный осевой момент - {central_vertical_axial_moment(thresholded)}') report.new_line(text=f'Нормированный центральный горизонтальный осевой момент -' f'{normalized_central_horizontal_axial_moment(thresholded)}') report.new_line(text=f'Нормированный центральный вертикальный осевой момент -' f'{normalized_central_vertical_axial_moment(thresholded)}') h_levels, h_projections = horizontal_projection(thresholded) pyplot.plot(h_levels, h_projections) pyplot.title(f'Horizontal projection {letter}') path = f'{letter_folder_path}/horizontal_projection_{letter}.png' pyplot.savefig(path) pyplot.close() report.new_line(report.new_inline_image(text=letter, path=path)) v_levels, v_projections = vertical_projection(thresholded) pyplot.plot(v_levels, v_projections) pyplot.title(f'Vertical projection {letter}') path = f'{letter_folder_path}/vertical_projection_{letter}.png' pyplot.savefig(path) pyplot.close() report.new_line(report.new_inline_image(text=letter, path=path)) report.new_line() report.create_md_file()
def generateReadme(): mdFile = MdUtils(file_name="LOCAL_README.md") mdFile.new_header(level=1, title="Compilation Of DSC-RAIT resources") mdFile.new_paragraph( "This is a ``README.md`` file generated by asmrPy to test it's capabilities. Stay tuned for more updates!" ) for d in db.resources.find(): mdFile.new_header(level=2, title=d['domain']) for l in d['links']: mdFile.new_paragraph(text=f"{l['info']}: {l['link']}") mdFile.create_md_file() text = mdFile.read_md_file(file_name="LOCAL_README.md") return text
def create_report(self, reports, sorted_tools): outfile = f"{self.outdir}/reports/Report.md" title = f"PENSEC - Report of {self.target.hostname}" reportfile = MdUtils(file_name=outfile, title=title) # "Execute Summary" reportfile.new_header(level=3, title="Common Statistics") for tool in sorted_tools: tool.write_report_summary(reportfile, reports) # "Technical Details" for tool in sorted_tools: tool.write_report(reportfile, reports) reportfile.create_md_file() self.logger.info("Report saved in " + outfile)
def create_file(files): data = get_data(files) md_file = MdUtils(file_name='repositories') md_file.new_header(level=1, title='Repositories') grouped_by_type = groupby(data, key=itemgetter('type')) for key, value in grouped_by_type: value_sorted = sorted(value, key=lambda x: x['name']) md_file.new_header(level=2, title=key) if key == 'Reading': write_reading_entries(value_sorted, md_file) else: for item in value_sorted: write_item(item, md_file) md_file.new_line() md_file.create_md_file()
def generate_singular_templates(bib_data): """ Parses a .bibtex file and creates a singular markdown write-up template for each entry. Args: bib_data: A pybtex parsed file Returns: Outputs singular markdown write-up templates """ for entry in tqdm(bib_data.entries.values()): title = entry.fields['title'] year = entry.fields['year'] url = entry.fields['url'] authors = str(entry.persons['author'][0]) if 'journal' in entry.fields: journal = entry.fields['journal'] file_name = authors.lower() + '-' + str(year) if 'journal' in locals(): title = authors + ', ' + title + ', ' + year + ', ' + journal else: title = authors + ', ' + title + ', ' + year mdfile = MdUtils(file_name=file_name, title=title) # Add the correct header information mdfile.new_header(level=1, title='TLDR') mdfile.new_header(level=1, title='Links') mdfile.new_line('Paper - ' + mdfile.new_inline_link(text='Link to Paper', link=url)) mdfile.new_header(level=1, title='Summary') mdfile.new_header(level=1, title='Comments') mdfile.new_header(level=1, title='Reference') mdfile.insert_code(entry.to_string(bib_format='bibtex')) mdfile.create_md_file()
def gen_kwargs_markdown(mapping: T_HandlerKwargMapping, output_file_path: str, extra_head: str = ""): md_file = MdUtils(file_name=output_file_path) if extra_head: md_file.write(extra_head) md_file.new_header(level=1, title="") for event_name, kwargs in mapping.items(): md_file.new_header(level=2, title=event_name) parameter_table = ["参数名称", "类型"] for kwarg in kwargs: row = [kwarg.name] if isinstance(kwarg.type_, str): row.append(kwarg.type_) else: # if get_origin(parameter.annotation) is Union: # # group_msg = group_message # continue row.append(kwarg.type_) parameter_table.extend(row) # debug(parameter_table) if len(parameter_table) > 2: md_file.new_table( columns=2, rows=int(len(parameter_table) / 2), text=parameter_table, text_align="center", ) md_file.create_md_file() print(f"成功生成{output_file_path}文件")
def publish_event_page(logs, website_src_path): # Generate the about file. mdFile = MdUtils( file_name=os.path.join(website_src_path, "content", "log"), title="Container Event Logging", ) status_table = ["Container Action", "Time (UTC)"] for entry in logs: container_status = (("~~" + entry[0].attrs["Config"]["Image"].split("/")[0] + "~~") if entry[2] == "destroyed" else ("**" + entry[0].attrs["Config"]["Image"].split("/")[0] + "**")) status_table.extend([ container_status, strf_time_diff(datetime.now(), entry[1]) + " ago" ]) mdFile.new_line() mdFile.new_table(columns=2, rows=len(logs) + 1, text=status_table, text_align="center") mdFile.new_header(level=5, title="Status Update Time") tz_table = ["TZ", "Time"] for city, tz in timezones.items(): tz_table.extend([city, datetime.now().astimezone(tz).strftime(fmt)]) mdFile.new_table(columns=2, rows=len(timezones) + 1, text=tz_table, text_align="center") mdFile.create_md_file() return None
def report(self, reports): report_dict = reports[Tool.Dependencies.NMAP_SERVICES] self.logger.info("Creating report for " + self.name) obj = {} for f in self.files: with open(f, "r") as scanfile: for s in scanfile.read().split("\n\n")[:-1]: scan = json.loads(s) if 'RESULTS_EXPLOIT' in scan and 'SEARCH' in scan: obj[scan["SEARCH"]] = { "exploits": scan["RESULTS_EXPLOIT"] } #temp outfile = f"{self.reportdir}/{self.name}.md" title = f"PENSEC - {self.name.capitalize()} Report" reportfile = MdUtils(file_name=outfile, title=title) reportfile.new_header(level=1, title="Common Statistics") reportfile.new_paragraph(f"X exploits found\n") reportfile.create_md_file() self.logger.info("Report saved in " + outfile) #report_dict["searchsploit_info"] = obj return obj
def publish_status_page(running_containers, website_src_path): # Generate the about file. mdFile = MdUtils( file_name=os.path.join(website_src_path, "content", "status"), title="System Status", ) status_table = ["Container", "Status"] for container in sorted( running_containers, key=lambda c: c.attrs["Config"]["Image"].split("/")[0]): status_table.extend([ container.attrs["Config"]["Image"].split("/")[0], container.attrs["State"]["Status"], ]) mdFile.new_line() mdFile.new_table( columns=2, rows=len(running_containers) + 1, text=status_table, text_align="center", ) mdFile.new_header(level=5, title="Status Update Time") tz_table = ["TZ", "Time"] for city, tz in timezones.items(): tz_table.extend([city, datetime.now().astimezone(tz).strftime(fmt)]) mdFile.new_table(columns=2, rows=len(timezones) + 1, text=tz_table, text_align="center") mdFile.create_md_file() return None
def test_new_header(self): file_name = 'Test_file' md_file = MdUtils(file_name) string_headers_expected = "\n# Header 0\n\n## Header 1\n\n### Header 2\n\n#### Header 3\n\n" \ "##### Header 4\n\n###### Header 5\n" string_headers = "" for x in range(6): string_headers += md_file.new_header(level=(x + 1), title='Header ' + str(x), style='atx') self.assertEqual(string_headers, string_headers_expected) md_file.create_md_file() file_result = md_file.read_md_file(file_name) self.assertEqual(file_result, '\n\n\n' + string_headers_expected)
def write_md(json_obj, md_fn, overwrite=True, wire_obj=True): if (not overwrite): if (os.path.isfile(md_fn)): return; print('->', md_fn) md_title = json_obj['title'] mdFile = MdUtils(file_name=md_fn,title=md_title) desc = md_title if 'description' in json_obj: desc = json_obj['description'] mdFile.new_paragraph(desc); if wire_obj: mdFile.new_paragraph('All wire objects have a set of basic attributes ```{object_id, action, type, persist, data}```. The ```data``` attribute defines the object-specific attributes'); mdFile.new_header(level=2, title=f'\n{md_title} Attributes', style='setext', add_table_of_contents='n') object_table(mdFile, md_title, json_obj) if not 'properties' in json_obj: mdFile.create_md_file() return if not 'data' in json_obj['properties']: mdFile.create_md_file() return mdFile.new_header(level=3, title=f'{md_title} Data Attributes', add_table_of_contents='n') if '$ref' in json_obj['properties']['data']: obj_name = json_obj['properties']['data']['$ref'][len('#/definitions/'):] object_table(mdFile, md_title, json_obj['definitions'][obj_name], json_obj['definitions']) else: object_table(mdFile, md_title, json_obj['properties']['data'], json_obj['definitions']) mdFile.create_md_file()
def asMarkdown(self) -> MarkdownDocument: """Return document as markdown.""" # TODO: example, needs to be dynamic mdFile = MdUtils(file_name="file1.md", title="Schema") mdFile.new_header(level=1, title=self.title) # document meta headings documentMeta = ["Information", "Value"] # document meta rows documentMeta.extend(["Schema Id", self.id]) documentMeta.extend(["Title", self.title]) mdFile.new_table(columns=2, rows=3, text=documentMeta) # TODO: generate code snippet sections like those in the gantree docs as of 2020/03/29 mdFile.new_paragraph('```jsonc\n{\n "example": "text"\n}\n```') props = self.schema["properties"] resolved = resolve_all(props, None) print("resolved:", resolved) # style is set 'atx' format by default. # list_of_strings = ["Name", "Value"] # for x in range(5): # list_of_strings.extend(["Schema ID", schema_id]) # mdFile.new_line() # mdFile.new_table( # columns=2, rows=6, text=list_of_strings, text_align="center" # ) filename = mdFile.file_name content = mdFile.file_data_text return {"filename": filename, "content": content}
def create_markdown(file_path, title, publication_date="None"): mdFile = MdUtils(file_name=file_path, title= title) mdFile.new_line(" [@wikidata:" + wd_id + "]") mdFile.new_line() if publication_date != "None": mdFile.new_line("Publication date : " + str(publication_date)) mdFile.new_line() mdFile.new_header(1, "Highlights") mdFile.new_header(1, "Comments") mdFile.new_header(2, "Tags") mdFile.new_header(1, "Links") mdFile.new_line(" * [Scholia Profile](https://scholia.toolforge.org/work/" + wd_id + ")") mdFile.new_line(" * [Wikidata](https://www.wikidata.org/wiki/" + wd_id + ")") mdFile.new_line(" * [TABernacle](https://tabernacle.toolforge.org/?#/tab/manual/" + wd_id + "/P921%3BP4510)") mdFile.new_line() mdFile.create_md_file()
def makeMd(): main() lastDate = 0 lastMonth = 0 lastYear = 0 lastTime = "" os.chdir(saveLocation) mdOutputLocation = saveLocation + 'logbook.md' if os.path.exists(mdOutputLocation): #If file output.txt exists, remove it. If it doesn't, create it os.remove(mdOutputLocation) mdFile = MdUtils(file_name='logbook',title='My Logbook') with open(outputFileLocation, "r") as textDoc: lines = textDoc.readlines() for line in lines: firstTwoDigits = line[:2] if firstTwoDigits.isdigit(): date = line[:2] month = line[3:5] year = line[6:10] lastTime = line[11:19] if year != lastYear: mdFile.new_header(level=1, title=year) lastYear = year if month != lastMonth: monthWorded = monthToWords(month) mdFile.new_header(level=2, title=monthWorded) lastMonth = month if date != lastDate: mdFile.new_header(level=3, title=date) lastDate = date if (firstTwoDigits.isdigit() == False) and (line != "\n"): entryContent = lastTime + " - " + line mdFile.new_paragraph(entryContent) mdFile.create_md_file() print("md file created")
from mdutils.mdutils import MdUtils mdFile = MdUtils(file_name='league01', title='Grundle Me This') mdFile.new_header(level=2, title='ROS Valuations', add_table_of_contents='n') list_of_strings = ["Rank", "Player", "Value"] player = ["AB", "asdf", "asdfad"] value = [60, 45, 12] for x in range(3): list_of_strings.extend([str(x), player[x], str(value[x])]) mdFile.new_table(columns=3, rows=4, text=list_of_strings, text_align='center') mdFile.new_header(level=3, title='Your Roster', add_table_of_contents='n') mdFile.new_header(level=3, title='Available Free Agents', add_table_of_contents='n') mdFile.new_header(level=2, title='Weekly Tiers', add_table_of_contents='n') mdFile.new_header(level=3, title='Suggested Starting Lineup', add_table_of_contents='n') mdFile.new_header(level=3, title='Substitutions Necessary', add_table_of_contents='n') mdFile.new_header(level=3, title='Skill Streams Available', add_table_of_contents='n') mdFile.new_header(level=2, title='Weekly Streaming Advice', add_table_of_contents='n')
user_agent="redditcoronav1", ) subreddit = reddit.subreddit("Coronavirus") submission = reddit.submission(id="fgy7rg") submission.comments.replace_more(limit=0) all_comments = submission.comments found = 0 mdFile = MdUtils(file_name="test", title="Reddit ama corona virus") for comment in all_comments: if len(comment.replies) > 0: for reply in comment.replies: if reply.author == "Emergencydocs": found = 1 print(20 * "=") print("QUESTION: ") mdFile.new_header(level=1, title=comment.body) print(comment.body) print("ANSWER: ") mdFile.new_paragraph(reply.body) print(reply.body) else: continue mdFile.create_md_file() # hot_python = subreddit.hot() # for submission in hot_python: # # check for removing pinned posts... # if not submission.stickied: # print( # "Title: {}, ups:{}, downs:{}, Have We visited: {}".format(
I've learned that creating something `fun` will help you to retain all the learning steps taken to develop something. \n During the workflow, we will use a simple bash script to simulate the `roll` and log the output to a text file.\n That text file will then be stored in the repository and parsed to display at the bottom of this README file. \n I wanted to demonstrate how utilizing `MdUtils` will make writing Markdown files extremely easy. \n What I tested during this process: \n - Saving diceroll.txt to an artifact. \n - Saving diceroll.txt as a cache/key. \n - Establishing a lambda call utilizing an AWS API Gateway. \n In the end, I chose to save the file in the repository to allow anyone to pick up the dice as the shooter. \n. I'll expand more in my blog but for now, let's start rolling! \n New Shooooooooooooooooooootaaaaa!!" """ # style is set 'atx' format by default. mdFile.new_header(level=1, title='Overview') mdFile.new_paragraph(string) #Overview information mdFile.new_header(level=1, title='Let\'s Play!') mdFile.new_paragraph( "Welcome to Casino Del Ray. This is a simple game of Craps that incorporates some of the sayings that you would normally hear around the table." " If you’ve never played craps, you’re seriously missing out (unless you’re coding, in which case you will inevitably make more $$ doing that in the long run)." ) mdFile.new_paragraph( "**IMPORTANT:** This game will not teach you <ins>strategery</ins> or make you a pro. All bets are off..... (I'm not liable for any real $$ lost at the table)", bold_italics_code='bi', color='purple') # How to play mdFile.new_header(level=1, title="Rules of the Game")
diff_messages = list(map(lambda x: x.commit.message.split('\n', 1)[0], diff)) # Delete unwanted commit messages from changelog unwanted_commits = [ 'update changelog', 'update image tag in docker compose', 'merge branch.*' ] temp = '(?:% s)' % '|'.join(unwanted_commits) for message in list(diff_messages): if re.match(temp, message.strip().lower()): diff_messages.remove(message) # Update CHANGELOG.md changelog_new = MdUtils(file_name='') changelog_new.new_header(level=1, title=new_version) changelog_new.new_list(diff_messages) changelog_new.write(' \n') changelog_before = MdUtils(file_name='').read_md_file(file_name='CHANGELOG.md') MarkDownFile('/tmp/CHANGELOG.md').rewrite_all_file( changelog_before + changelog_new.file_data_text) changelog_contents = repo.get_contents("/CHANGELOG.md") with open('/tmp/CHANGELOG.md', 'rb') as f: repo.update_file(changelog_contents.path, 'Update CHANGELOG', f.read(), changelog_contents.sha) # Update docker-compose.yml file with open('docker-compose/docker-compose.yaml', encoding='UTF-8') as f: compose_file = safe_load(f)
class RegisterBank(vhdl.BasicVHDL): def __init__(self, entity_name, architecture_name, datasize, RegisterNumber): vhdl.BasicVHDL.__init__(self, entity_name, architecture_name) self.generate_code = False self.reg = RegisterList() self.datasize = pow(2,math.ceil(math.log(datasize, 2))) self.addr_low = math.log(self.datasize/8,2) self.addr_increment = math.ceil(pow(2,self.addr_low)) self.addrsize = math.ceil(math.log(RegisterNumber, 2) + self.addr_low ) self.useRecords = False #aux files self.document = MdUtils(file_name="output/"+entity_name, title='Register Bank: %s' % entity_name) self.version = datetime.now().strftime("%Y%m%d_%H%m") #Companion Package self.pkg = pkgvhdl.PkgVHDL(entity_name + "_pkg") self.pkg.library.add("IEEE") self.pkg.library["IEEE"].package.add("std_logic_1164") self.pkg.library["IEEE"].package.add("numeric_std") self.pkg.packageDeclaration.constant.add("package_version_c", "String", "\"%s\"" % self.version) # Libraries self.library.add("IEEE") self.library["IEEE"].package.add("std_logic_1164") self.library["IEEE"].package.add("numeric_std") self.library.add("expert") self.library["expert"].package.add("std_logic_expert") self.work.add(self.pkg.name) # Generics self.entity.generic.add("C_S_AXI_ADDR_WIDTH", "integer", str(self.addrsize)) self.entity.generic.add("C_S_AXI_DATA_WIDTH", "integer", str(self.datasize)) # Architecture # Constant self.architecture.constant.add("register_bank_version_c", "String", "\"%s\"" % self.version) self.architecture.constant.add("C_S_AXI_ADDR_BYTE", "integer", "(C_S_AXI_DATA_WIDTH/8) + (C_S_AXI_DATA_WIDTH MOD 8)") self.architecture.constant.add("C_S_AXI_ADDR_LSB", "integer", str(math.ceil(self.addr_low))) self.architecture.constant.add("REG_NUM", "integer", "2**(C_S_AXI_ADDR_WIDTH-C_S_AXI_ADDR_LSB)") # Custom type self.architecture.customTypes.add("reg_t", "Array", "REG_NUM-1 downto 0", "std_logic_vector(C_S_AXI_DATA_WIDTH-1 downto 0)") # Signals self.architecture.signal.add("awaddr_s", "std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0)") self.architecture.signal.add("awready_s", "std_logic") self.architecture.signal.add("wready_s", "std_logic") self.architecture.signal.add("wtimeout_sr", "std_logic_vector(15 downto 0)", "( 0 => '1', others=>'0')") self.architecture.signal.add("wtimeout_s", "std_logic") self.architecture.signal.add("bresp_s", "std_logic_vector(1 downto 0)") self.architecture.signal.add("bvalid_s", "std_logic") self.architecture.signal.add("bresp_timer_sr", "std_logic_vector(15 downto 0)", "( 0 => '1', others=>'0')") self.architecture.signal.add("wtimeout_s", "std_logic") self.architecture.signal.add("araddr_s", "std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0)") self.architecture.signal.add("arready_s", "std_logic") self.architecture.signal.add("rresp_s", "std_logic_vector(1 downto 0)") self.architecture.signal.add("rvalid_s", "std_logic") self.architecture.signal.add("rtimeout_sr", "std_logic_vector(15 downto 0)", "( 0 => '1', others=>'0')") self.architecture.signal.add("rtimeout_s", "std_logic") self.architecture.signal.add("regwrite_s", "reg_t", "(others=>(others=>'0'))") self.architecture.signal.add("regread_s", "reg_t", "(others=>(others=>'0'))") self.architecture.signal.add("regclear_s", "reg_t", "(others=>(others=>'0'))") self.architecture.signal.add("regset_s", "reg_t", "(others=>(others=>'0'))") self.architecture.signal.add("regread_en", "std_logic") self.architecture.signal.add("regwrite_en", "std_logic") self.architecture.bodyCodeHeader.add("assert register_bank_version_c = package_version_c\r\n" + indent(2) + "report \"Package and Register Bank version mismatch.\"\r\n" + indent(2) + "severity warning;\r\n") for lines in TemplateCode.splitlines(): self.architecture.bodyCodeHeader.add(lines) self._resetPort() self._resetArchBodyFooter() # PRIVATE API def _resetArchBodyFooter(self): self.architecture.bodyCodeFooter = vhdl.GenericCodeBlock() def _resetPort(self): self.entity.port = vhdl.PortList() self.entity.port.add("S_AXI_ACLK", "in", "std_logic") self.entity.port.add("S_AXI_ARESETN", "in", "std_logic") self.entity.port.add("S_AXI_AWADDR", "in", "std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0)") self.entity.port.add("S_AXI_AWPROT", "in", "std_logic_vector(2 downto 0)") self.entity.port.add("S_AXI_AWVALID", "in", "std_logic") self.entity.port.add("S_AXI_AWREADY", "out", "std_logic") self.entity.port.add("S_AXI_WDATA", "in", "std_logic_vector(C_S_AXI_DATA_WIDTH-1 downto 0)") self.entity.port.add("S_AXI_WSTRB", "in", "std_logic_vector((C_S_AXI_DATA_WIDTH/8)-1 downto 0)") self.entity.port.add("S_AXI_WVALID", "in", "std_logic") self.entity.port.add("S_AXI_WREADY", "out", "std_logic") self.entity.port.add("S_AXI_BRESP", "out", "std_logic_vector(1 downto 0)") self.entity.port.add("S_AXI_BVALID", "out", "std_logic") self.entity.port.add("S_AXI_BREADY", "in", "std_logic") self.entity.port.add("S_AXI_ARADDR", "in", "std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0)") self.entity.port.add("S_AXI_ARPROT", "in", "std_logic_vector(2 downto 0)") self.entity.port.add("S_AXI_ARVALID", "in", "std_logic") self.entity.port.add("S_AXI_ARREADY", "out", "std_logic") self.entity.port.add("S_AXI_RDATA", "out", "std_logic_vector(C_S_AXI_DATA_WIDTH-1 downto 0)") self.entity.port.add("S_AXI_RRESP", "out", "std_logic_vector(1 downto 0)") self.entity.port.add("S_AXI_RVALID", "out", "std_logic") self.entity.port.add("S_AXI_RREADY", "in", "std_logic") for local_port in list(self.entity.port.keys()): self.entity.port[local_port].assign(local_port) def _registerPortAdd(self): if self.useRecords: self.entity.port.add(self.entity.name+"_i","in",self.entity.name+"_i_t") self.entity.port.add(self.entity.name+"_o","out",self.entity.name+"_o_t") else: for register_num, register_word in self.reg.items(): if isinstance(register_word,RegisterWord): for index, register in register_word.items(): if (isinstance(register,RegisterBit) or isinstance(register,RegisterSlice)): register.updatePort() for port_name, port_data in register.port.items(): self.entity.port.append(port_data) self.entity.port[port_name].assign(port_name) def _registerConnection(self): self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "--Register Connection") for register_num, register_word in self.reg.items(): for index, register in register_word.items(): if isinstance(register, RegisterBit) or isinstance(register, RegisterSlice): if register.size == 1: vectorRange = str(index) else: vectorRange = "%d downto %d" % (index+register.size-1, index) register.name = register.name+"(%d downto 0)" % (register.size-1) if "ReadOnly" in register.regType: self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regread_s(%d)(%s) <= %s;" % (register_num, vectorRange, register.vhdlName)) elif "SplitReadWrite" in register.regType: self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "%s <= regwrite_s(%d)(%s);" % (register.inv_vhdlName, register_num, vectorRange)) self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regread_s(%d)(%s) <= %s;" % (register_num, vectorRange, register.vhdlName)) elif "ReadWrite" in register.regType: self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "%s <= regwrite_s(%d)(%s);" % (register.vhdlName, register_num, vectorRange)) self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regread_s(%d)(%s) <= regwrite_s(%d)(%s);" % (register_num, vectorRange, register_num, vectorRange)) elif "Write2Clear" in register.regType: # self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regread_s(%d)(%s) <= %s;" % (register_num,vectorRange,register.name)) pass elif "Write2Pulse" in register.regType: self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "%s <= regwrite_s(%d)(%s);" % (register.vhdlName, register_num, vectorRange)) self.architecture.bodyCodeFooter.add("\r\n") def _registerSetConnection(self): self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "--Set Connection for Write to Clear") for reg_num, register_word in self.reg.items(): for index, register in register_word.items(): if isinstance(register, RegisterBit) or isinstance(register, RegisterSlice): if register.size == 1: vectorRange = str(index) else: vectorRange = "%d downto %d" % (index+register.size-1, index) if register.regType == "Write2Clear": self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regset_s(%d)(%s) <= %s;" % (reg_num, vectorRange, register.vhdlName)) self.architecture.bodyCodeFooter.add("") def _registerClearConnection(self): self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "--External Clear Connection") for register_num, register_word in self.reg.items(): for index, register in register_word.items(): if (isinstance(register,RegisterBit) or isinstance(register,RegisterSlice)): if self.useRecords: clearname = register.clearName else: clearname = register.clearName + "_i" if register.size == 1: defaultvalue = "'1'" elsevalue = "'0'" vectorRange = str(index) else: vectorRange = "%d downto %d" % (index+register.size-1, index) tmp = register.vhdlRange.replace("(","") tmp = tmp.replace(")","") defaultvalue = "(%s => '1')" % tmp elsevalue = "(%s => '0')" % tmp if ( register.regType == "Write2Clear" or register.regType == "Write2Pulse"): elsevalue = "regwrite_s(%d)(%s)" % (register_num, vectorRange) if register.externalClear: self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regclear_s(%d)(%s) <= %s when %s = '1' else %s;" % (register_num, vectorRange, defaultvalue, clearname, elsevalue)) elif ( register.regType == "Write2Clear" or register.regType == "Write2Pulse"): self.architecture.bodyCodeFooter.add(vhdl.indent(1) + "regclear_s(%d)(%s) <= %s;" % (register_num, vectorRange, elsevalue) ) def _generate(self): if (not self.generate_code): self._resetPort() self._resetArchBodyFooter self._registerPortAdd() self._registerConnection() self._registerSetConnection() self._registerClearConnection() self.pkg.packageDeclaration.component.append(self.dec_object()) self.generate_code = True # PUBLIC API def add(self, number, name): self.generate_code = False self.reg.add(number, RegisterWord(name, self.datasize)) def SetPortAsRecord(self): self.generate_code = False self.useRecords = True out_record_name = self.entity.name+"_o_t" in_record_name = self.entity.name+"_i_t" self.pkg.packageDeclaration.customTypes.add(out_record_name, "Record") self.pkg.packageDeclaration.customTypes.add(in_record_name, "Record") for reg_num, register_word in self.reg.items(): for index, register in register_word.items(): if (isinstance(register,RegisterBit) or isinstance(register,RegisterSlice)): for j in register.port: if register.externalClear: self.pkg.packageDeclaration.customTypes[in_record_name].add(register.clearName,"std_logic") self.reg[reg_num][index].clearName = self.entity.name+"_i."+register.clearName if "SplitReadWrite" in register.regType: self.pkg.packageDeclaration.customTypes[out_record_name].add(register.name,register.vhdlType) self.pkg.packageDeclaration.customTypes[in_record_name].add(register.name,register.vhdlType) self.reg[reg_num][index].vhdlName = self.entity.name+"_i."+register.name self.reg[reg_num][index].inv_vhdlName = self.entity.name+"_o."+register.name elif "out" in register.direction: self.pkg.packageDeclaration.customTypes[out_record_name].add(register.name,register.vhdlType) self.reg[reg_num][index].vhdlName = self.entity.name+"_o."+register.name else: self.pkg.packageDeclaration.customTypes[in_record_name].add(register.name,register.vhdlType) self.reg[reg_num][index].vhdlName = self.entity.name+"_i."+register.name def code(self): self._generate() return vhdl.BasicVHDL.code(self) def write_package(self): self.pkg.write_file() def write_document(self): self._generate() if (not os.path.exists("output")): os.makedirs("output") self.document.new_header(1, "Details") self.document.new_line("Data Width: %d" % self.datasize) self.document.new_line("Number of registers: %d" % len(self.reg)) self.document.new_line("Version: v%s" % self.version) self.document.new_line("Register Bank auto-generated using the hdltools/regbank_gen.py") self.document.new_line() self.document.new_header(1, "List of Registers") self.document.new_line() for index in self.reg: register = self.reg[index] self.document.new_header(2, "Register %d: %s" % (index, register.name)) self.document.new_line("Address: BASE + 0x%x" % index) if (register.description): self.document.new_line("Description: %s" % register.description) self.document.new_line() list_of_strings = ["Bit", "Field", "Type", "Reset", "Description"] numOfRows = 1 for bit in register: if isinstance(register[bit], RegisterBit): numOfRows = numOfRows + 1 if register[bit].size > 1: range = "%d-%d" % (bit+register[bit].size-1, bit) else: range = "%d" % (bit) field = register[bit].radix type = register[bit].regType # Default value init = register[bit].init if init == "(others => '0')" or init == "'0'": init = "0x0" elif init == "'1'": init = "1" else: init = "0" + init.replace("\"", "") # decription description = register[bit].description list_of_strings.extend([range, field, type, init, description]) self.document.new_table(columns=5, rows=numOfRows, text=list_of_strings, text_align='center') self.document.new_line() self.document.new_line("hdltools available at https://github.com/rftafas/hdltools.") self.document.create_md_file() def write_header(self): self._generate() if (not os.path.exists("output")): os.makedirs("output") header_code = "" header_code = header_code + "#ifndef %s_H\n\r" % (self.entity.name.upper()) header_code = header_code + "#define %s_H\n\r" % (self.entity.name.upper()) header_code = header_code + "\n\r" header_code = header_code + "/*This auto-generated header file was created using hdltools. File version:*/\n\r" header_code = header_code + "#define %s_VERSION \"%s\"\n\r" % (self.entity.name.upper(), self.version) header_code = header_code + "\n\r" for index in self.reg: register = self.reg[index] header_code = header_code + "/*Register %s address */\n\r" % register.name header_code = header_code + "#define %s_OFFSET 0x%x\n\r" % (register.name.upper(), index) for bit in register: if isinstance(register[bit], RegisterBit): header_code = header_code + "/*Register %s field %s */\n\r" % (register.name, register[bit].radix) fieldName = register.name.upper() + "_" + register[bit].radix.upper() header_code = header_code + "#define %s_FIELD_OFFSET %d\n\r" % (fieldName, bit) header_code = header_code + "#define %s_FIELD_WIDTH %d\n\r" % (fieldName, register[bit].size) # compute field mask mask = 0 for i in range(bit, bit + register[bit].size): mask = mask + 2**i header_code = header_code + "#define %s_FIELD_MASK %s\n\r" % (fieldName, hex(mask)) # Field default value if register[bit].init == "(others => '0')" or register[bit].init == "'0'": header_code = header_code + "#define %s_RESET %s\n\r" % (fieldName, "0x0") else: header_code = header_code + "#define %s_RESET 0%s\n\r" % (fieldName, register[bit].init.replace("\"", "")) header_code = header_code + "\n\r" header_code = header_code + "\n\r" output_file_name = "output/"+self.entity.name+".h" # to do: check if file exists. If so, emit a warning and # check if must clear it. output_file = open(output_file_name, "w+") for line in header_code: output_file.write(line) output_file.close() def write_testbench(self): self._generate() testbench = vhdl.BasicVHDL(self.entity.name+"_tb","simulation") testbench.entity.generic.add("runner_cfg", "string", "") testbench.entity.generic.add("run_time", "integer", "100") testbench.library = self.library testbench.library.add("std") testbench.library["std"].package.add("textio") testbench.library.add("vunit_lib") testbench.library["vunit_lib"].context.add("vunit_context") testbench.library["vunit_lib"].context.add("vc_context") testbench.work.add(self.pkg.name) for index, generic in self.entity.generic.items(): testbench.architecture.constant.add(index,generic.type,generic.value) testbench.architecture.constant.add("axi_handle","bus_master_t","new_bus(data_length => C_S_AXI_DATA_WIDTH, address_length => C_S_AXI_ADDR_WIDTH)") testbench.architecture.constant.add("addr_increment_c","integer",str(self.addr_increment)) for port in self.entity.port: testbench.architecture.signal.add(port,self.entity.port[port].type) # set starting value to clock. All other signals should be handled by reset. testbench.architecture.signal["S_AXI_ACLK"].value = "'0'" testbench.architecture.instances.add("axi_master_u","entity vunit_lib.axi_lite_master") testbench.architecture.instances["axi_master_u"].generic.add("bus_handle","","axi_handle") for local_port in list(vunitPort.keys()): testbench.architecture.instances["axi_master_u"].port.add(local_port,"","") testbench.architecture.instances["axi_master_u"].port[local_port].assign(vunitPort[local_port]) testbench.architecture.instances.append(self.instanciation("dut_u")) read_only = vhdl.GenericCodeBlock() read_write = vhdl.GenericCodeBlock() split_read_write = vhdl.GenericCodeBlock() write_to_clear = vhdl.GenericCodeBlock() write_to_pulse = vhdl.GenericCodeBlock() external_clear = vhdl.GenericCodeBlock() for reg_number, register_word in self.reg.items(): reg_address = reg_number * self.addr_increment for index, register in register_word.items(): if not (isinstance(register,RegisterBit) or isinstance(register,RegisterSlice)): continue if register.size == 1: tb_value = random_bit() vector_location = "(%s)" % index all_one = "'1'" all_zero = "'0'" else: tb_value = random_vector(register.size) vector_location = "(%s downto %s)" % (register.size + index - 1, index) all_one = "(others=>'1')" all_zero = "(others=>'0')" if register.regType == "ReadOnly": testbench.architecture.bodyCodeFooter.add(vhdl.indent(1) + "--Read Only: %s;" % register.vhdlName) testbench.architecture.bodyCodeFooter.add(vhdl.indent(1) + "%s <= %s;" % (register.vhdlName, tb_value)) read_only.add(vhdl.indent(1) + "--Testing %s" % register.vhdlName) read_only.add(vhdl.indent(1) + "read_bus(net,axi_handle,%d,rdata_v);" % reg_address ) read_only.add(vhdl.indent(1) + "check_equal(rdata_v%s,%s,result(\"Test Read: %s.\"));" % ( vector_location, register.vhdlName, register.vhdlName )) if register.regType == "ReadWrite": tb_value = random_vector(self.datasize) read_write.add(vhdl.indent(1) + "--Testing %s" % register.vhdlName) read_write.add(vhdl.indent(1) + "rdata_v := %s;" % tb_value) read_write.add(vhdl.indent(1) + "write_bus(net,axi_handle,%d,rdata_v,%s);" % (reg_address, register.byte_enable) ) read_write.add(vhdl.indent(1) + "read_bus(net,axi_handle,%d,rdata_v);" % reg_address ) read_write.add(vhdl.indent(1) + "check_equal(%s,rdata_v%s,result(\"Test Readback and Port value: %s.\"));" % ( register.vhdlName, vector_location, register.vhdlName )) if register.regType == "SplitReadWrite": testbench.architecture.bodyCodeFooter.add(vhdl.indent(1) + "--Split Read and Write: %s;" % register.vhdlName) testbench.architecture.bodyCodeFooter.add(vhdl.indent(1) + "%s <= %s;" % (register.vhdlName, tb_value)) split_read_write.add(vhdl.indent(1) + "--Testing %s" % register.vhdlName) split_read_write.add(vhdl.indent(1) + "read_bus(net,axi_handle,%d,rdata_v);" % reg_address ) split_read_write.add(vhdl.indent(1) + "check_equal(rdata_v%s,%s,result(\"Test Read: %s.\"));" % ( vector_location, register.vhdlName, register.vhdlName )) tb_value = random_vector(self.datasize) split_read_write.add(vhdl.indent(1) + "--Testing %s" % register.inv_vhdlName) split_read_write.add(vhdl.indent(1) + "rdata_v := %s;" % tb_value ) split_read_write.add(vhdl.indent(1) + "write_bus(net,axi_handle,%d,rdata_v,%s);" % (reg_address, register.byte_enable) ) split_read_write.add(vhdl.indent(1) + "wait for 1 us;") split_read_write.add(vhdl.indent(1) + "check_equal(%s,rdata_v%s,result(\"Test Read: %s.\"));" % ( register.inv_vhdlName, vector_location, register.inv_vhdlName )) if register.regType == "Write2Clear": write_to_clear.add(vhdl.indent(1) + "--Testing %s: Set to %s" % (register.vhdlName, all_one) ) write_to_clear.add(vhdl.indent(1) + "%s <= %s;" % (register.vhdlName, all_one)) write_to_clear.add(vhdl.indent(1) + "wait until rising_edge(S_AXI_ACLK);") write_to_clear.add(vhdl.indent(1) + "%s <= %s;" % (register.vhdlName, all_zero)) write_to_clear.add(vhdl.indent(1) + "wait until rising_edge(S_AXI_ACLK);") write_to_clear.add(vhdl.indent(1) + "read_bus(net,axi_handle,%d,rdata_v);" % reg_address ) write_to_clear.add(vhdl.indent(1) + "check(rdata_v%s = %s,result(\"Test Read Ones: %s.\"));" % ( vector_location, tb_value.replace('0','1'), register.vhdlName )) write_to_clear.add(vhdl.indent(1) + "rdata_v := (others=>'0');" ) write_to_clear.add(vhdl.indent(1) + "rdata_v%s := %s;" % (vector_location, all_one) ) write_to_clear.add(vhdl.indent(1) + "write_bus(net,axi_handle,%d,rdata_v,%s);" % (reg_address, register.byte_enable) ) write_to_clear.add(vhdl.indent(1) + "read_bus(net,axi_handle,%d,rdata_v);" % reg_address ) write_to_clear.add(vhdl.indent(1) + "check(rdata_v%s = %s,result(\"Test Read Zeroes: %s.\"));" % ( vector_location, tb_value.replace('1','0'), register.vhdlName )) if register.regType == "Write2Pulse": write_to_pulse.add(vhdl.indent(1) + "--Testing %s" % register.vhdlName) write_to_pulse.add(vhdl.indent(1) + "rdata_v%s := %s;" % (vector_location, all_one) ) write_to_pulse.add(vhdl.indent(1) + "write_bus(net,axi_handle,%d,rdata_v,%s);" % (reg_address, register.byte_enable) ) write_to_pulse.add(vhdl.indent(1) + "wait until %s = %s;" % (register.vhdlName, tb_value.replace("0","1")) ) read_only.add(vhdl.indent(1) + "check_passed(result(\"Read Out Test Pass.\"));") read_write.add(vhdl.indent(1) + "check_passed(result(\"Read and Write Test Pass.\"));") split_read_write.add(vhdl.indent(1) + "check_passed(result(\"Split Read Write Test Pass.\"));") write_to_clear.add(vhdl.indent(1) + "check_passed(result(\"Write to Clear Test Pass.\"));") write_to_pulse.add(vhdl.indent(1) + "check_passed(result(\"Write to Pulse Test Pass.\"));") external_clear.add(vhdl.indent(1) + "check_passed(result(\"External Clear Test Pass.\"));") new_tb_code = testBenchCode.replace("--read_only_tag",read_only.code(4)) new_tb_code = new_tb_code.replace("--read_write_tag",read_write.code(4)) new_tb_code = new_tb_code.replace("--split_read_write_tag",split_read_write.code(4)) new_tb_code = new_tb_code.replace("--write_to_clear_tag",write_to_clear.code(4)) new_tb_code = new_tb_code.replace("--write_to_pulse_tag",write_to_pulse.code(4)) new_tb_code = new_tb_code.replace("--external_clear_tag",external_clear.code(4)) testbench.architecture.bodyCodeHeader.add(new_tb_code) testbench.write_file() def write_script(self): tmpScript = templateScript.replace("<name>",self.entity.name) if (not os.path.exists("output")): os.makedirs("output") output_file_name = "output/"+self.entity.name+"_run.py" # to do: check if file exists. If so, emit a warning and # check if must clear it. output_file = open(output_file_name, "w+") for line in tmpScript: output_file.write(line) output_file.close() def write_file(self): self._generate() vhdl.BasicVHDL.write_file(self) return True def __call__(self): self.write_file() self.write_package() self.write_testbench() self.write_script() self.write_header() self.write_document()
def _write_command_usage(cls, file: MdUtils, lines: List[str]): file.new_header(level=3, title='Usage', add_table_of_contents='n') main_lines = ''.join([f' {line}\n' for line in lines[1:]]) file.write(f'```bash\n{lines[0]}\n{main_lines}```')