def test_check_required_files():
path = '../circuitfiles/amp/'
file_hand = FileHandler(path)
file_hand.form_simulation_environment(4)
assert os.path.isdir('../circuitfiles/amp_temp/0')
assert os.path.isdir('../circuitfiles/amp_temp/1')
assert os.path.isdir('../circuitfiles/amp_temp/2')
assert os.path.isdir('../circuitfiles/amp_temp/3')
def build_abstract_syntax_tree_dir(self, main_dir):
for dirName, subdirList, file_list in FileHandler.walklevel(main_dir.description, level=0):
for file_name in file_list:
# add extension logic here
if self.base_node.code is None or file_name.lower().endswith("."+self.base_node.code):
child = main_dir.open_new_context(self.next_node_id(), "file", description=os.path.join(dirName, file_name))
self.build_abstract_syntax_tree(child)
for subdir in subdirList:
next_dir = main_dir.open_new_context(self.next_node_id(), "dir", description=os.path.join(dirName, subdir))
self.build_abstract_syntax_tree_dir(next_dir)
def build_abstract_syntax_tree(self, main_node):
if main_node.code is None and main_node.context_type == "file" and main_node.description is not None:
main_node.code = FileHandler.file_to_string(main_node.description)
if main_node.context_type == "dir":
self.build_abstract_syntax_tree_dir(main_node)
return
main_node.start = 0
main_node.end = len(main_node.code)
main_node.line_start = 1
main_node.line_end = StringTools.count_lines(main_node.code)
current_context = main_node
line = 1
last_n = None
offset = main_node.start
while offset < main_node.end:
previous_context = current_context
# increase line counter at end of loop whenever you find '\n'
line_flag = False
if offset != last_n and main_node.code[offset] == '\n':
last_n = offset # if \n is not eaten, we must be sure we do not compute the line skip more than once
line_flag = True
# close priority contexts: ignore all but the closure, used for strings and comments
[current_context, offset, stop_flag] = \
self.priority_rule_check_close(main_node=main_node, rules=self.priority_context_rules,
current_context=current_context, offset=offset, line=line)
# here, we are sure we are not in a priority rule
if not stop_flag:
[current_context, offset, stop_flag] = \
self.priority_rule_check_open(main_node=main_node, rules=self.priority_context_rules,
current_context=current_context, offset = offset, line=line)
# Non priority contexts:
if not stop_flag:
[current_context, offset, stop_flag] = \
self.non_priority_rule_check(main_node=main_node, rules=self.context_rules,
current_context=current_context, offset=offset, line=line)
# if we did not find anything, remember to skip to next character
if not stop_flag:
offset = offset + 1
# increase line counter at end of loop whenever you find '\n'
if line_flag:
line = line + 1
def generate_file_doc(base_node, out, prepend=""):
filename = base_node.context_type
destination = out + '/index.html'
if base_node.description:
filename = REGEX_PATH_SPLIT.split(base_node.description)
filename = filename[len(filename) - 1]
destination = out + '/' + filename[:len(filename) - 3] + '.html'
destination = Path(destination)
template_location = Path(gen_directory + '/index.html')
if template_location != destination:
fh.copy_file(template_location, destination)
fh.replace_in_file("assets/",
prepend + "assets/",
destination,
replace_all=True)
fh.replace_in_file('@filename', filename, destination, replace_all=True)
generate_code_doc(base_node, destination)
from src.OzDocParser import OzDocParser
from src.ArgumentsHandler import parse_args
from src import FileHandler
if __name__ == '__main__':
# Recover program arguments (file, dir, text, out, settings, template, docgen)
args = parse_args()
try:
os.makedirs(args.out)
except FileExistsError:
if not os.access(args.out, os.W_OK):
raise IOError(errno.EIO, "Error writing out folder", args.out)
# Check program mode
settings = FileHandler.import_module("settings", args.settings)
if args.file[0] is not None: # file mode
parser = OzDocParser(
context_type="file",
description=args.file[0],
priority_context_rules=settings.priority_context_rules,
context_rules=settings.context_rules)
elif args.dir is not None: # directory mode
if args.extension is None:
parser = OzDocParser(
context_type="dir",
description=args.dir,
priority_context_rules=settings.priority_context_rules,
context_rules=settings.context_rules)
else:
def run(parser, settings, out):
destination = out + '/index.html'
code = parser.base_node.code
# Creation of the repository of all functions
fun_repo = OzDocParser.build_link_context_with_repo(
parser.base_node, settings.fun_keyword, settings.def_keyword)
OzDocParser.link_following_regex_to_repo(
parser.base_node,
fun_repo,
settings.fun_regex,
exception=settings.comment_keyword)
# Creation of the repository of all function calls
call_repo = OzDocParser.build_context_repo_not_in(
parser.base_node, settings.def_keyword,
ListTools.get_list_column(fun_repo, 1))
# Creation of the repository of all comments
comment_repo = OzDocParser.build_context_repo(parser.base_node,
settings.comment_keyword)
OzDocParser.link_all_regex_to_repo(parser.base_node, comment_repo,
settings.ozdoc_tag_regex)
# Generating the body of the table containing all of the functions.
doc, tag, text = Doc().tagtext()
with tag('tbody'):
for function in fun_repo:
funcname = function[2]
if funcname != '$':
with tag('tr'):
with tag('td'):
text(funcname)
with tag('td'):
description = ""
prev_sister = function[0].find_previous_sister()
if prev_sister:
if prev_sister.context_type in settings.comment_keyword: # if previous sister is a comment
description = code[prev_sister.
start:prev_sister.
end].split('\n')[0][:80]
description = description.lstrip(
'/*% ').rstrip('/*% ')
text(description)
new_tablebody = doc.getvalue()
fh.replace_in_file('@tablebody', new_tablebody, destination)
# Generating the head of the table containing all of the functions.
doc, tag, text = Doc().tagtext()
with tag('thead'):
with tag('tr'):
with tag('th'):
text('Function')
with tag('th'):
text('Description')
new_tablehead = indent(doc.getvalue())
fh.replace_in_file('@tablehead', new_tablehead, destination)
# Generating the section containing the details of all of the functions.
doc, tag, text, line = Doc().ttl()
with tag('ul', klass='blockList'):
with tag('li', klass='blockList'):
with tag('ul', klass='blockList'):
with tag('li', klass='blockList'):
for function in fun_repo:
funcname = function[2]
if funcname != '$':
line('h4', funcname)
with tag('pre', style='font-style: italic;'):
text(code[function[1].start:function[1].end])
# @TODO
# Check if the @throws tag is used.
# (get sister, make taglist)
# throws_found = tag_found_in_comment('@throws', taglist)
# # If exception thrown, add :
# text('\n\t\t\tthrows ')
# line('a', 'Insert Exception Name', href='')
description = ""
prev_sister = function[0].find_previous_sister()
k = -1 # index of previous sister (if it is a comment) in comment_repo
if prev_sister:
if prev_sister.context_type in settings.comment_keyword:
# Entered if previous sister is a comment
start = prev_sister.start
end = prev_sister.end
# Find it in comment_repo as well.
for i, x in enumerate(comment_repo):
if x[0].start == prev_sister.start:
k = i
for tag_found in comment_repo[k][
1]:
if tag_found[
0] in supported_tags:
end = tag_found[1]
break
break
description = code[start:end]
with tag('pre'):
description = description.split('\n')
for d in description:
line('code',
d.lstrip('/*% '),
klass='block')
if k != -1:
if comment_repo[k][1]:
with tag('dl'):
taglist = comment_repo[k][1]
end_of_comment = comment_repo[k][0].end
for i in range(len(supported_tags)):
found = tag_found_in_comment(
supported_tags[i], taglist)
if found:
make_tagged_section(
supported_tags[i],
supported_names[i],
supported_labels[i],
taglist, end_of_comment,
tag, text, line, code)
# Making the button to show the Source Code.
with tag('dt'):
line('span', 'Source Code:', klass='codeLabel')
with tag('dd'):
id = str(function[0].node_id)
line('button',
'Show',
onclick='show' + id + '()')
with tag('pre', id=id, style='display: none;'):
line('code', (code[function[0].
start:function[0].end]))
show_fun_def = 'function %s() {' \
' var x = document.getElementById("%s");' \
' if (x.style.display === "none") {' \
' x.style.display = "block";' \
' } else {' \
' x.style.display = "none";' \
' }' \
'}' % ('show' + id, id)
line('script', show_fun_def)
new_functiondetails = indent(doc.getvalue())
fh.replace_in_file('@functiondetails', new_functiondetails, destination)
f"but given {multi_thread}.")
with open(cfg_path) as file:
yaml_file = yaml.load(file, Loader=yaml.FullLoader)
CIRCUIT_PROPERTIES = yaml_file["Circuit"]
SPEA2_PROPERTIES = yaml_file["SPEA2"]
if not os.path.isdir(CIRCUIT_PROPERTIES["path_to_output"]):
raise SystemExit(f"There is no such direction "
f"{CIRCUIT_PROPERTIES['path_to_output']}")
if __name__ == "__main__":
from src import FileHandler, process
# Create temp folder to perform simulations
file_handler = FileHandler(CIRCUIT_PROPERTIES['path_to_circuit'])
file_handler.form_simulation_environment(multi_thread)
path = file_handler.get_folder_path()
# start time_perf counter.
start = time.perf_counter()
# start the process
saved_file_path = process(CIRCUIT_PROPERTIES, SPEA2_PROPERTIES, path,
multi_thread, saving_mode, only_cct)
# stop time_perf counter
stop = time.perf_counter()
constraints_as_str = [
k + '->' + i + ':' + str(j)
from src import FileHandler
from src.Iterator import Iterator
from src.PerfNum import isPerfect
import time
import sys
path = sys.argv[1]
n = int(sys.argv[2])
start_time = time.time()
data = FileHandler.fileToArray(path)
if n <= len(data):
myiterator = iter(data)
generator = Iterator(len(data), n)
for index in generator:
sum = 0
for i in index:
sum = sum + data[i]
if isPerfect(sum):
print("La combinacion de las posiciones: " + str(index) +
" genera el numero perfecto: " + str(sum))
else:
pass
else:
print("No puede haber más valores a permutar que valores en la lista")
print("Ejecución terminada")
def make_table_section(type, main_repo, sub_repo, code, destination, fun_repo,
class_repo, meth_repo, comment_repo):
if type != 'function' and type != 'class':
return
iname = 1 if type == 'class' else 2 # Index of the repository column containing the name of the class/function
repo_is_useful = bool(main_repo)
if type == 'function':
repo_is_useful = bool(main_repo) and any(
map(lambda e: e[iname] != '$', main_repo))
if repo_is_useful:
################################################################################################################
# Generating the head of the table #
################################################################################################################
doc, tag, text = Doc().tagtext()
with tag('thead'):
with tag('tr'):
with tag('th'):
text(type.capitalize())
if type == 'function':
with tag('th'):
text('Type')
with tag('th'):
text('Description')
fh.replace_in_file('@' + type + 'tablehead', indent(doc.getvalue()),
destination)
################################################################################################################
# Generating the body of the table #
################################################################################################################
doc, tag, text, line = Doc().ttl()
with tag('tbody'):
for elem in main_repo:
elemname = elem[iname]
if type == 'function' and elemname == '$':
continue
with tag('tr'):
with tag('td'):
with tag('a',
href="#" + elemname + str(elem[0].node_id)):
text(elemname)
if type == 'function':
with tag('td'):
text(elem[0].context_type)
with tag('td'):
description = ""
prev_sister = elem[0].find_previous_sister()
if prev_sister:
if prev_sister.context_type in settings.comment_keyword: # if previous sister is a comment
# Default value for the description
description = code[prev_sister.
start:prev_sister.
end].split('\n')[0][:200]
description = description.lstrip(
'/*% ').rstrip('/*% ')
# If a summary tag is in use
# @TODO : transform this next bit into a function
# Find it in comment_repo as well.
for i, x in enumerate(comment_repo):
if x[0].start == prev_sister.start:
k = i
taglist = comment_repo[k][1]
if tag_found_in_comment(
SUMMARY_TAG, taglist):
for j, tag_found in enumerate(
taglist):
if tag_found[0] == SUMMARY_TAG:
start = tag_found[1]
end = taglist[j + 1][1] - 1 if j < (len(taglist) - 1) else \
comment_repo[k][0].end
description = code[
start:end][(
len(SUMMARY_TAG)
):].rstrip(' ').rstrip(
'/*%')
break
break
text(description)
if type == 'class':
# Getting methods of the class
methlist = []
for meth in sub_repo:
if meth[0].start > elem[0].start and meth[
0].end < elem[0].end:
methlist.append(meth)
if methlist:
doc.stag('br')
line('u', 'Contains methods')
text(' : ')
for i, meth in enumerate(methlist):
if i > 0:
doc.asis(' ')
text(',')
doc.asis(' ')
with tag('a',
href="#" + meth[1] +
str(meth[0].node_id)):
text(meth[1])
text('.')
# Making context hierarchy
context_hierarchy = make_context_hierarchy(
elem[0].parent if elem[0].parent else elem[0],
fun_repo, class_repo, meth_repo)
if context_hierarchy:
doc.stag('br')
with tag('i'):
text('(from: ' + context_hierarchy + ')')
fh.replace_in_file('@' + type + 'tablebody', indent(doc.getvalue()),
destination)
################################################################################################################
# Generating the section containing details about the functions or methods #
################################################################################################################
if type == 'class' and not bool(sub_repo):
empty = ""
fh.replace_in_file('@' + type + 'details', empty, destination)
else:
doc, tag, text, line = Doc().ttl()
with tag('ul', klass='blockList'):
with tag('li', klass='blockList'):
if type == 'function':
line('h2', 'Function details')
make_details_section(type, main_repo, code,
destination, fun_repo, class_repo,
meth_repo, comment_repo, doc, tag,
text, line)
else: # meaning type == 'class'
for klass in main_repo:
line('h2',
klass[1],
id=klass[1] + str(klass[0].node_id))
make_details_section(type,
sub_repo,
code,
destination,
fun_repo,
class_repo,
meth_repo,
comment_repo,
doc,
tag,
text,
line,
klass=klass)
fh.replace_in_file('@' + type + 'details', indent(doc.getvalue()),
destination)
else:
empty = ""
fh.replace_in_file('@' + type + 'tablehead', empty, destination)
fh.replace_in_file('@' + type + 'tablebody', empty, destination)
fh.replace_in_file('@' + type + 'details', empty, destination)
def generate_code_doc(base_node, destination):
code = base_node.code
OzDocParser.fuse_similar_successive_contexts(
base_node, settings.inline_comment_keyword)
###################################################################################################################
# Generating abstract syntax tree #
###################################################################################################################
doc, tag, text = Doc().tagtext()
with tag('pre', klass='oz-code'):
doc.asis(
gen_html_ast(base_node, ROOT_CONTEXTS + settings.oz_block_keywords,
["\'", "\"", "`"]))
ast = doc.getvalue()
fh.replace_in_file('@abstract_syntax_tree', ast, destination)
###################################################################################################################
# Generating source code #
###################################################################################################################
doc, tag, text = Doc().tagtext()
with tag('pre', klass='line-numbers'):
with tag('code', klass='language-oz'):
text(code)
source_code = doc.getvalue()
fh.replace_in_file('@source_code', source_code, destination)
###################################################################################################################
# Creation of repositories containing functions, classes, comments, etc. #
###################################################################################################################
try:
fun_repo = OzDocParser.build_link_context_with_repo(
base_node, settings.fun_keyword, settings.def_keyword)
OzDocParser.link_following_regex_to_repo(
base_node,
fun_repo,
settings.declarations_name_regex,
exception=settings.comment_keyword)
# Example of how to print a repository:
# PrintTools.print_repo(fun_repo)
fun_call_repo = OzDocParser.build_context_repo_not_in(
base_node, settings.def_keyword,
ListTools.get_list_column(fun_repo, 1))
class_repo = OzDocParser.build_context_repo(base_node,
settings.class_keyword)
OzDocParser.link_following_regex_to_repo(
base_node,
class_repo,
settings.declarations_name_regex,
exception=settings.comment_keyword)
meth_repo = OzDocParser.build_context_repo(base_node,
settings.meth_keyword)
OzDocParser.link_following_regex_to_repo(
base_node,
meth_repo,
settings.meth_regex,
exception=settings.comment_keyword)
comment_repo = OzDocParser.build_context_repo(base_node,
settings.comment_keyword)
OzDocParser.link_all_regex_to_repo(base_node, comment_repo,
settings.ozdoc_tag_regex)
except Exception as exception:
doc, tag, text, line = Doc().ttl()
with tag('h2', style='color: #FF0000; font-weight: bold;'):
text("You did not input a vaild, errorless Oz file.")
doc.stag('br')
text("This file could thus not be parsed correctly.")
doc.stag('br')
text("(Hint: look for unclosed parentheses and curly brackets)")
doc.stag('br')
doc.stag('br')
text(
"The following exception happened during creation of repositories:"
)
doc.stag('br')
line('i', exception.__class__.__name__)
fh.replace_in_file('@general_info', doc.getvalue(), destination)
for type in ['function', 'class']:
fh.replace_in_file('@' + type + 'tablehead', "", destination)
fh.replace_in_file('@' + type + 'tablebody', "", destination)
fh.replace_in_file('@' + type + 'details', "", destination)
return
###################################################################################################################
# Generating general information #
###################################################################################################################
doc, tag, text, line = Doc().ttl()
with tag('div', klass='general-info'):
title = base_node.context_type
if base_node.description:
title = REGEX_PATH_SPLIT.split(base_node.description)
title = title[len(title) - 1]
line('h2', title, style='font-weight: bold;')
doc.stag('br')
nothing = True
# Section for file summary
if base_node.children:
if base_node.children[0].context_type in settings.comment_keyword:
taglist = comment_repo[0][1]
if tag_found_in_comment(SUMMARY_TAG, taglist):
nothing = False
for i, tag_found in enumerate(taglist):
if tag_found[0] == SUMMARY_TAG:
# Content
start = tag_found[1]
end = taglist[i + 1][1] - 1 if i < (
len(taglist) - 1) else comment_repo[0][0].end
content = code[start:end][(
len(SUMMARY_TAG)):].rstrip(' ').rstrip('/*%')
line('font', content, size='+1')
doc.stag('br')
doc.stag('br')
break
# Section for context hierarchy, if not root node
if base_node.parent:
nothing = False
line('h3', 'From:')
with tag('ul'):
with tag('li'):
text(
make_context_hierarchy(base_node.parent,
fun_repo,
class_repo,
meth_repo,
go_all_the_way=True))
doc.stag('br')
# Section for unusual keywords found
unusual_kw = []
USUAL_CONTEXT = USUAL_KEYWORDS + settings.fun_keyword + settings.class_keyword + settings.meth_keyword \
+ settings.comment_keyword + settings.def_keyword + settings.string_keyword\
+ ROOT_CONTEXTS + ["[]", "var", "atom"]
for node in base_node.iter_children():
if node.context_type not in USUAL_CONTEXT:
unusual_kw.append(node)
if unusual_kw:
nothing = False
line('h3', 'Non-frequent keywords found:')
with tag('ul'):
for kw in unusual_kw:
with tag('li', klass='oz-code'):
line('span',
kw.context_type,
klass=OZ_KEYWORD_SIMPLE_CLASS)
text(", at line " + str(kw.line_start))
hierarchy = make_context_hierarchy(
kw.parent if kw.parent else kw,
fun_repo,
class_repo,
meth_repo,
get_root=False)
if hierarchy:
text(" (in ")
line('i', hierarchy)
text(")")
doc.stag('br')
# Section for TODO tags
todotags = []
for comment in comment_repo:
taglist = comment[1]
for i, tag_found in enumerate(taglist):
if tag_found[0] == TODO_TAG:
# Origin (for context hierarchy)
origin = comment[0]
next_sister = origin.find_next_sister()
if next_sister:
if next_sister.context_type in settings.fun_keyword \
or next_sister.context_type in settings.meth_keyword \
or next_sister.context_type in settings.class_keyword:
origin = next_sister
if origin.context_type in settings.comment_keyword:
if origin.parent:
origin = origin.parent
# Content
start = tag_found[1]
end = taglist[i + 1][1] - 1 if i < (len(taglist) -
1) else comment[0].end
content = code[start:end][(
len(TODO_TAG)):].rstrip(' ').rstrip('/*%')
if todotags:
if origin.start == todotags[len(todotags) -
1][0].start:
todotags[len(todotags) - 1][1].append(content)
else:
todotags.append([origin, [content]])
else:
todotags.append([origin, [content]])
if todotags:
nothing = False
with tag('div', klass='TODO'):
line('h3', 'TODO', style='font-weight: bold;')
for t in todotags:
with tag('ul'):
with tag('li'):
text(
make_context_hierarchy(t[0], fun_repo,
class_repo, meth_repo) +
', at line ' + str(t[0].line_start) + ':')
for content in t[1]:
with tag('ul'):
line('li', content)
doc.stag('br')
if nothing:
text('No unusual information concerning ' + title + '.')
fh.replace_in_file('@general_info', doc.getvalue(), destination)
###################################################################################################################
# Generating class and function tables #
###################################################################################################################
make_table_section('class', class_repo, meth_repo, code, destination,
fun_repo, class_repo, meth_repo, comment_repo)
make_table_section('function', fun_repo, None, code, destination, fun_repo,
class_repo, meth_repo, comment_repo)