class BRTest(unittest.TestCase):
def showMsg(self, msg):
print "[%s/%s/%s] %s" % (self.testname, self.testinstance,
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
msg)
def setUp(self):
if os.getenv("REUSE_BUILD"):
self.builddir = os.getenv("REUSE_BUILD").rstrip("/")
skip_build = True
else:
skip_build = False
b = subprocess.check_output(["mktemp", "-d", "buildroot.XXXXX"],
cwd=configtest.builddir)
b = b.strip()
self.builddir = os.path.join(configtest.builddir, b)
self.testname = self.__class__.__name__
self.testinstance = os.path.basename(self.builddir)
self.buildlog = self.builddir + "-build.log"
self.runlog = self.builddir + "-run.log"
self.s = None
self.showMsg("Starting")
self.b = Builder(self.__class__.config, self.builddir, self.buildlog)
if not skip_build:
self.showMsg("Building")
self.b.build()
self.showMsg("Building done")
self.s = System(self.runlog)
def tearDown(self):
self.showMsg("Cleaning up")
if self.s:
self.s.stop()
if self.b and os.getenv("KEEP_BUILD"):
self.b.delete()
class BRTest(unittest.TestCase):
def showMsg(self, msg):
print "[%s/%s/%s] %s" % (
self.testname, self.testinstance,
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), msg)
def setUp(self):
if os.getenv("REUSE_BUILD"):
self.builddir = os.getenv("REUSE_BUILD").rstrip("/")
skip_build = True
else:
skip_build = False
b = subprocess.check_output(["mktemp", "-d", "buildroot.XXXXX"],
cwd=configtest.builddir)
b = b.strip()
self.builddir = os.path.join(configtest.builddir, b)
self.testname = self.__class__.__name__
self.testinstance = os.path.basename(self.builddir)
self.buildlog = self.builddir + "-build.log"
self.runlog = self.builddir + "-run.log"
self.s = None
self.showMsg("Starting")
self.b = Builder(self.__class__.config, self.builddir, self.buildlog)
if not skip_build:
self.showMsg("Building")
self.b.build()
self.showMsg("Building done")
self.s = System(self.runlog)
def tearDown(self):
self.showMsg("Cleaning up")
if self.s:
self.s.stop()
if self.b and os.getenv("KEEP_BUILD"):
self.b.delete()
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
super(Test, cls).setUpClass()
cls.dbPath = "testDb.sqlite"
if os.path.exists(cls.dbPath):
os.remove(cls.dbPath)
def setUp(self):
unittest.TestCase.setUp(self)
agentFactory = PoleAgentFactory()
environmentFactory = PoleEnvironmentFactory()
trainerFactory = PoleTrainerFactory()
buildParameterFactory = PoleBuildParameterFactory()
store = Store(self.dbPath)
logger = MyLogger(console_print=True)
self.builder = Builder(trainerFactory, agentFactory,
environmentFactory, store, logger)
self.buildParameters = []
for k1 in range(2):
nIntervalSave = 3
nEpoch = 5
self.buildParameters.append(
PoleBuildParameter(int(nIntervalSave),
int(nEpoch),
label="test" + str(k1)))
for agentClass in ("agent002", "agent003", "agent004"):
self.buildParameters.append(
PoleBuildParameter(int(nIntervalSave),
int(nEpoch),
agentClass=agentClass,
label="test " + agentClass))
self.loader = Loader(agentFactory, buildParameterFactory,
environmentFactory, store)
@classmethod
def tearDownClass(cls):
super(Test, cls).tearDownClass()
cls.dbPath = "testDb.sqlite"
if os.path.exists(cls.dbPath):
os.remove(cls.dbPath)
def test001(self):
for buildParameter in self.buildParameters:
assert isinstance(buildParameter, PoleBuildParameter)
self.builder.build(buildParameter)
assert isinstance(self.loader, Loader)
for agent, buildParameter, epoch in self.loader.load("test%", None):
assert isinstance(agent, PoleAgent)
assert isinstance(buildParameter, PoleBuildParameter)
def main():
args = parse_args()
V = Vars()
writer = Writer(args.build_dir, args.verbose)
b = Builder(args.folder, writer)
if args.config is not None:
V.load_config_files(args.folder, args.config)
V.load_cli_args(args.arg)
if args.file is not None:
b.build_files(args.file, V)
else:
b.build(V)
def run():
parser = create_parser()
args = parser.parse_args()
prepare_run(args)
from configs import Components
from builder import Builder
builder = Builder()
builder.build()
print(builder.train_dataloader.get_batch_size())
trainer = Components.trainer(**builder.get_trainer_arguments())
del builder
trainer.run()
def makePopulationlist():
popobj = Builder('population.csv', 4, 'NAME')
populationlist = popobj.build()
for item in populationlist:
popobj.skiplist.insert(item)
return popobj.skiplist
def makeGrantlist():
grantobj = Builder('researchgrants.csv', 0, 'Awardee')
grantlist = grantobj.build()
for item in grantlist:
grantobj.skiplist.insert(item)
return grantobj.skiplist
def makePresidentialOrderlist():
ordersobj = Builder('presidentialdocuments.csv', 1, 'title')
orderslist = ordersobj.build()
for item in orderslist:
ordersobj.skiplist.insert(item)
return ordersobj.skiplist
def main():
parser = argparse.ArgumentParser(description='pyginate - static web site generator')
parser.add_argument('action', help='Action to perform', choices=['build', 'deploy', 'process'])
parser.add_argument('-d', '--dir', help='Web site base directory', default=os.getcwd())
parser.add_argument('-c', '--config_file_name', help='Configuration file name', default='pyginator.json')
parser.add_argument('-s', '--processing_script', help='Procesing script to apply', default='')
parser.add_argument('-dr', '--dry_run', action='store_true', help='Do not apply any changes, just report')
args = parser.parse_args()
conf_file = os.path.join(args.dir, args.config_file_name)
configuration = Configuration(args.dir, json.load(open(conf_file)))
if args.action == 'build':
builder = Builder(configuration)
builder.build()
elif args.action == 'deploy':
deployer = Deployer(configuration)
deployer.deploy()
elif args.action == 'process':
if args.dry_run:
configuration.dry_run = True
processor = Processor(configuration, args.processing_script)
processor.process()
def create_model():
train_filename = request.json[TRAINING_FILENAME]
test_filename = request.json[TEST_FILENAME]
classifiers_name = request.json[CLASSIFIERS_NAME]
request_errors = analyse_request_errors(request_validator, train_filename,
test_filename, classifiers_name)
if request_errors is not None:
return request_errors
database_url_training = Database.collection_database_url(
database_url,
database_name,
train_filename,
database_replica_set,
)
database_url_test = Database.collection_database_url(
database_url,
database_name,
test_filename,
database_replica_set,
)
builder = Builder(database, metadata_creator, spark_session)
builder.build(request.json[MODELING_CODE_NAME], classifiers_name,
train_filename, test_filename, database_url_training,
database_url_test)
return (
jsonify({
MESSAGE_RESULT:
create_prediction_files_uri(classifiers_name, test_filename)
}),
HTTP_STATUS_CODE_SUCCESS_CREATED,
)
def web_main(dc, pn, gui=None, spr=None, plan=SIMPLE, solver=solver):
#from kwarwp_factory import Sprite
gui = GUI(dc['panel'], dc['data'], gui)
_builder = Builder()
place = _builder.build(pn, gui, _builder.build_inventory(FS=Sprite), plan,
solver)
dc['for'].addEventListener("click", place.actor.go_forward)
dc['lef'].addEventListener("click", place.actor.go_left)
dc['rig'].addEventListener("click", place.actor.go_right)
dc['aft'].addEventListener("click", place.actor.go_backward)
dc['tri'].addEventListener("click", place.actor.go_push)
dc['exi'].addEventListener("click", place.actor.go_pull)
dc['cir'].addEventListener("click", place.actor.go_take)
dc['squ'].addEventListener("click", place.actor.go_give)
dc['start'].addEventListener("click", place.actor.go_step)
return place
class BuilderTest(unittest.TestCase):
def setUp(self):
self.image = np.full((300, 400, 4), 255, dtype=np.uint8)
self.image[:, 190:210, :] = [255, 0, 0, 127]
height, width, _ = self.image.shape
mask = np.zeros((height, width, 1), dtype=bool)
mask[130:180, 170:220] = True
self.mask_result = [{
"rois":
np.array([[130, 170, 180, 220]], dtype=np.int32),
"class_ids":
np.array([0], dtype=np.int32),
"scores":
np.array([0.99], dtype=np.float32),
"masks":
mask
}]
self.builder = Builder()
def test_builder(self):
result = self.builder.build(self.image.copy(), self.mask_result)[0]
result_image = result.generate_image()
result_backgrount = result.instances[0].generate_image()
result_segment = result.instances[1].generate_image()
expect_background = np.full((300, 400, 4), 255, dtype=np.uint8)
expect_background[:, 190:210, :] = [255, 0, 0, 127]
expect_background[130:180, 170:220] = [0, 0, 0, 0]
segment_image = np.full((50, 50, 4), 255, dtype=np.uint8)
segment_image[:, 20:40, :] = [255, 0, 0, 127]
self.assertEqual(2, len(result))
self.assertEqual((300, 400), result.size())
self.assertTrue(
np.allclose(expect_background, result_backgrount, atol=5))
self.assertTrue(np.allclose(segment_image, result_segment, atol=5))
self.assertTrue(np.allclose(self.image, result_image, atol=5))
def main():
if (len(sys.argv) < 2):
print("Error: please provide a specification file as argument")
sys.exit(1)
spec = UpstreamSpecification(sys.argv[1])
sourcePath = path.join("sources", spec.getName())
buildPath = path.join("builds",spec.getName())
repo = GitUpstremSource(spec.getName(), spec.getUrl(), sourcePath, spec.getBranches())
repo.update()
tags = repo.listVersion(spec.getTags())
builds = []
reports = []
for index in range(0,len(tags)):
tag = tags[index]
versionPath = repo.extractVersion(tag, buildPath)
build = Builder(spec.getRecipe(tag), tag, spec.getSOfiles(tag), versionPath)
builds.append(build)
if (not build.build()):
print("Error building: " + tag, ", see: " + path.join(versionPath, "build.log"), file=sys.stderr)
if (index > 0):
report = CompatReport(spec.getName(), builds[index-1], builds[index])
if (not report.generateReport()):
print ("Error comparing: " + builds[index-1].tag + " -> " + builds[index].tag, file=sys.stderr)
else:
print ("Compared " + builds[index-1].tag + " -> " + builds[index].tag)
reports.append(report)
reports = reversed(reports)
env = Environment(loader=PackageLoader("git-abireport", "template"))
template = env.get_template('report.html')
with open(path.join("compat_reports",spec.getName() +'_compat_report.html'), 'w') as reportfile:
now = datetime.datetime.now()
print(template.render(name=spec.getName(), url=spec.getUrl(), reports=reports, update=now.strftime("%Y-%m-%d %H:%M:%S")), file=reportfile)
path="data/samples/ConsoleApp01",
targets=[target])
return project
def testMyApp():
myAppTarget = Target("MyApp", path="MyApp", items=["MyApp.cpp"])
myLib01 = Target("MyLib01",
path="MyLib01",
items=["MyLib01.hpp", "MyLib01.cpp"])
myLib02 = Target("MyLib02",
path="MyLib02",
items=["MyLib02.hpp", "MyLib02.cpp"])
project = Project("MyApp",
path="data/samples/MyApp",
targets=[myAppTarget, myLib01, myLib02])
return project
if __name__ == "__main__":
project = testMyApp()
toolchain = ToolchainGCC(
"D:/mingw-w64/x86_64-6.2.0-posix-seh-rt_v5-rev1/mingw64/bin")
builder = Builder(toolchain)
builder.build(project)
def main(pn, gui, spr=None, plan=SIMPLE, solver=solver):
_builder = Builder()
return _builder.build(pn, gui, _builder.build_inventory(FS=spr), plan,
solver)
pattern_data = pickle.load(pattern_data_file)
scaler_file = open(config['position_scaler'], 'rb')
scaler = pickle.load(scaler_file)
def progress_callback(completed, total):
percentage = int(completed / float(total) * 100)
sys.stdout.write(f'Progress: {percentage}% [{completed} / {total}]\r')
sys.stdout.flush()
block_model = load_model(args.block_model)
pos_model = load_model(args.pos_model)
builder = Builder(block_model,
pos_model,
config['lookback'],
None,
pattern_data,
scaler,
temperature=args.temperature)
track = builder.build(args.length,
verbose=False,
save=False,
progress_callback=progress_callback,
map_size=(32, 32, 32))
print(track)
save_gbx({'track_data': track}, 'data/Template.Challenge.Gbx', args.output)
print(f'Track saved to {args.output}.')
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
super(Test, cls).setUpClass()
WaeAgent.checkPointPath = "./testCheckPoint"
cls.dbPath = "testDb.sqlite"
if os.path.exists(cls.dbPath):
os.remove(cls.dbPath)
cls.trainLogFolderPath = "./testTrainLogFolderPath"
if os.path.exists(cls.trainLogFolderPath):
os.remove(cls.trainLogFolderPath)
def setUp(self):
unittest.TestCase.setUp(self)
agentFactory = WaeAgentFactory()
environmentFactory = WaeEnvironmentFactory()
trainerFactory = WaeTrainerFactory()
buildParameterFactory = WaeBuildParameterFactory()
store = Store(self.dbPath, self.trainLogFolderPath)
logger = MyLogger(console_print=True)
self.builder = Builder(trainerFactory, agentFactory,
environmentFactory, store, logger)
self.buildParameters = []
for k1 in range(2):
nIntervalSave = 10
nEpoch = 20
nLayer = int(np.random.choice((1, 2)))
self.buildParameters.append(
WaeBuildParameter(int(nIntervalSave),
int(nEpoch),
label="test" + str(k1),
nLayer=nLayer,
eps_given_sinkhorn=0.1,
tol_sinkhorn=0.1))
self.loader = Loader(agentFactory, buildParameterFactory,
environmentFactory, store)
@classmethod
def tearDownClass(cls):
super(Test, cls).tearDownClass()
if os.path.exists(cls.dbPath):
os.remove(cls.dbPath)
if os.path.exists(WaeAgent.checkPointPath):
shutil.rmtree(WaeAgent.checkPointPath)
if os.path.exists(cls.trainLogFolderPath):
shutil.rmtree(cls.trainLogFolderPath)
def test001(self):
for buildParameter in self.buildParameters:
assert isinstance(buildParameter, WaeBuildParameter)
self.builder.build(buildParameter)
assert isinstance(self.loader, Loader)
for agent, buildParameter, epoch in self.loader.load("test%", None):
assert isinstance(agent, WaeAgent)
assert isinstance(buildParameter, WaeBuildParameter)
class ObserverHandler(FileSystemEventHandler):
"""
Watch for file changes in the src directory and update preview
directory using Builder class.
"""
def __init__(self, src_dir, dest_dir):
# Init super
super(ObserverHandler, self).__init__()
# Cache values
self.src_dir = src_dir
self.dest_dir = dest_dir
# New builder & local syncer
self.builder = Builder(self.src_dir, self.dest_dir, LocalSyncer())
self.builder.build()
def dispatch(self, event):
# Modified to not dispatch create
if not isinstance(event, DirModifiedEvent):
self.on_any_event(event)
# Dispatch to individual listeners
_method_map = {
'modified': self.on_modified,
'moved': self.on_moved,
'deleted': self.on_deleted,
}
_method_map[event.event_type](event)
def on_any_event(self, event):
# Cache common paths
abs_path = event.src_path
rel_path = abs_path.replace(self.src_dir, '')
# Break path into parts and gether info about parts
parts = rel_path.strip('/').split('/')
parts_len = len(parts)
# Build individual parts of method based on what
# file/dir was changed:
def build_message():
# /message/name
if (parts_len == 2):
self.builder.build_single(abs_path)
# /message/name/file
# /message/name/images
elif (parts_len == 3):
if (parts[2] == 'images'):
msg_dir = os.path.dirname(abs_path)
self.builder.mirror_imgs(msg_dir)
else:
self.builder.write_template(abs_path)
# /message/name/images/file
elif (parts_len == 4):
img_dir = os.path.dirname(abs_path)
msg_dir = os.path.dirname(img_dir)
self.builder.mirror_imgs(msg_dir)
# If file was deleted remove, else build
if not os.path.exists(event.src_path):
self.builder.remove(event.src_path)
else:
if parts[0] == 'masters':
# If an asset in the masters dir was altered
# we must rebuild everything
self.builder.build()
else:
# Else we just build the part of the message
# that was changed
build_message()
class LiveBuildWindow(Gtk.Window):
def __init__(self, block_model, pos_model, lookback, pattern_data, scaler):
Gtk.Window.__init__(self, title='Live Build')
self.timeout_ids = []
self.rot_images = []
self.lookback = lookback
self.builder = Builder(block_model,
pos_model,
self.lookback,
None,
pattern_data,
scaler,
reset=False)
self.track = []
board = Gtk.Grid()
evbox = Gtk.EventBox()
evbox.add_events(256)
evbox.connect('button-press-event', self.on_button_press)
evbox.add(board)
self.images = [[None for x in range(32)] for y in range(32)]
self.overlays = [[None for x in range(32)] for y in range(32)]
for i in range(32):
for j in range(32):
overlay = Gtk.Overlay()
overlay.add_events(256)
img = Gtk.Image()
img.add_events(256)
img.set_pixel_size(IMG_SIZE)
img.set_property('icon-size', IMG_SIZE)
img.connect('button_press_event', self.on_button_press)
self.images[i][j] = img
overlay.add(img)
self.overlays[i][j] = overlay
board.attach(overlay, i, j, 1, 1)
sep = Gtk.Separator.new(Gtk.Orientation.VERTICAL)
accept_button = Gtk.Button.new_with_label('Accept')
accept_button.get_style_context().add_class('suggested-action')
accept_button.set_valign(Gtk.Align.START)
accept_button.connect('clicked', self.on_accept)
discard_button = Gtk.Button.new_with_label('Discard')
discard_button.get_style_context().add_class('destructive-action')
discard_button.connect('clicked', self.on_discard)
clear_button = Gtk.Button.new_with_label('Clear')
clear_button.connect('clicked', self.on_clear)
track_label = Gtk.Label()
sidebar = Gtk.Box.new(Gtk.Orientation.VERTICAL, 12)
sidebar.set_valign(Gtk.Align.CENTER)
sidebar.set_vexpand(True)
sidebar.set_hexpand(True)
sidebar.set_margin_left(12)
sidebar.set_margin_right(12)
sidebar.set_margin_bottom(12)
sidebar.set_margin_top(12)
sidebar.add(track_label)
sidebar.add(accept_button)
sidebar.add(discard_button)
sidebar.add(clear_button)
grid = Gtk.Grid()
grid.attach(evbox, 0, 0, 1, 1)
grid.attach(sep, 1, 0, 1, 1)
grid.attach(sidebar, 2, 0, 1, 1)
self.add(grid)
self.connect('destroy', self.on_destroy)
def on_button_press(self, w, event):
x = int(event.x / IMG_SIZE)
z = int(event.y / IMG_SIZE)
self.images[x][z].set_opacity(0.3)
def on_clear(self, button):
self.builder.gmap = None
self.track = []
self.build()
def on_accept(self, button):
self.track = self.builder.build(len(self.track) + 1,
put_finish=False,
failsafe=False)
self.build()
def on_discard(self, button):
self.builder.gmap.pop()
self.track = self.builder.build(len(self.track),
put_finish=False,
failsafe=False)
self.build()
def on_destroy(self, window):
Gtk.main_quit()
def add_block(self, block):
try:
name = bl.EDITOR_IDS[block[0]]
except KeyError:
return
x = block[1]
if x < 0:
x = -x
z = block[3]
if z < 0:
z = -z
if x > 31:
x = 31
if z > 31:
z = 31
r = block[4]
rot_pix = GdkPixbuf.Pixbuf.new_from_file_at_size(
'blocks-images/arr.jpg', 12, 12)
if r == 1:
rot_pix = rot_pix.rotate_simple(GdkPixbuf.PixbufRotation.CLOCKWISE)
elif r == 2:
rot_pix = rot_pix.rotate_simple(
GdkPixbuf.PixbufRotation.UPSIDEDOWN)
elif r == 3:
rot_pix = rot_pix.rotate_simple(
GdkPixbuf.PixbufRotation.COUNTERCLOCKWISE)
rot_img = Gtk.Image.new_from_pixbuf(rot_pix)
rot_img.set_halign(Gtk.Align.END)
rot_img.set_valign(Gtk.Align.END)
self.rot_images.append(rot_img)
self.overlays[31 - x][31 - z].add_overlay(rot_img)
if os.path.isfile('blocks-images/{}.jpg'.format(name)):
pix = GdkPixbuf.Pixbuf.new_from_file_at_size(
'blocks-images/{}.jpg'.format(name), IMG_SIZE, IMG_SIZE)
self.images[31 - x][31 - z].set_from_pixbuf(pix)
else:
pix = GdkPixbuf.Pixbuf.new_from_file_at_size(
'blocks-images/empty.jpg', IMG_SIZE, IMG_SIZE)
self.images[31 - x][31 - z].set_from_pixbuf(pix)
self.show_all()
def build(self):
for tid in self.timeout_ids:
GLib.Source.remove(tid)
self.timeout_ids = []
for row in self.images:
for img in row:
img.set_from_pixbuf(None)
img.set_pixel_size(IMG_SIZE)
img.set_property('icon-size', IMG_SIZE)
for rot_img in self.rot_images:
rot_img.destroy()
i = 1
for block in self.track:
self.add_block(block)
i += 1
def ship(self):
builder = Builder(self.src_dir, self.dest_dir, AwsSyncer(self.storage))
builder.build()
class GenerateThread(QThread):
progress_sig = pyqtSignal(int)
status_sig = pyqtSignal(str, bool)
def __init__(self):
super(GenerateThread, self).__init__()
self.progress_bar = None
self.map_name = None
self.length = 0
self.variety = 0
self.config = None
self.train_data = None
self.pattern_data = None
self.scaler = None
self.stopped = False
self.builder = None
self.save_fname = None
def progress_callback(self, completed, total):
self.progress_sig.emit(int(completed / float(total) * 100))
def run(self):
self.stopped = False
self.status_sig.emit('Initializing...', True)
from builder import Builder
from config import load_config
from savegbx import save_gbx
from keras.models import load_model
data_path = get_resource_path('data')
config = load_config(os.path.join(data_path, 'config.json'))
if not self.scaler:
self.status_sig.emit('Loading data...', True)
with open(os.path.join(data_path, config['position_scaler']),
'rb') as scaler_file:
self.scaler = pickle.load(scaler_file)
if self.stopped:
return
if not self.pattern_data:
with open(os.path.join(data_path, config['pattern_data']),
'rb') as pattern_file:
self.pattern_data = pickle.load(pattern_file)
if self.stopped:
return
models_path = get_resource_path('models')
if not self.builder:
self.status_sig.emit('Loading models...', True)
block_model = load_model(
os.path.join(models_path, 'block_model_300_300.h5'))
pos_model = load_model(
os.path.join(models_path, 'position_model_512_512_256.h5'))
self.builder = Builder(block_model,
pos_model,
config['lookback'],
None,
self.pattern_data,
self.scaler,
temperature=self.variety)
if self.stopped:
return
self.status_sig.emit('Building...', False)
track = self.builder.build(self.length,
verbose=False,
progress_callback=self.progress_callback)
if track and self.save_fname:
save_gbx({
'track_data': track,
'map_name': self.map_name
}, os.path.join(data_path, 'Template.Challenge.Gbx'),
self.save_fname)
self.status_sig.emit('Done.', False)
def stop(self):
self.stopped = True
if self.builder:
self.builder.stop()
self.status_sig.emit('Stopped.', False)
class Converter(object):
libraries = [calculator.library, functions.library, html.library]
elemlibraries = [elements.library]
filetype = 'html'
def __init__(self, manager=FileManager, context={}, config={},
compress=False, debug=False, optimize=False):
self.context = Context(true=True, false=False)
self.context.update(context)
self.config = config
self.manager = manager() if callable(manager) else manager
self.compress = compress
self.builder = Builder(debug, optimize)
def eval(self, element):
if element is None:
return ''
if not isinstance(element, Node):
return element
try:
return element.evaluate(self)
except FallThrough as e:
return e.result
def accepts(self, name, tag):
function = self.function(name)
return tag in self.function(name).receivers
def function(self, name):
for library in reversed(self.libraries):
try:
return library.get(name)
except KeyError:
continue
raise ConversionError('Could not find function %s' % name,
'Libraries searched: %s' % list(reversed(self.libraries)))
def element(self, name):
for library in reversed(self.elemlibraries):
try:
return library.get(name)
except KeyError:
continue
return elements.Element
def configuration(self, name):
if name in self.config:
return self.config
import cm.config
return getattr(cm.config, name, None)
def join(self, lines, compress=False):
if compress or self.compress:
return ''.join(str(line).strip() for line in lines)
return '\n'.join(map(str, lines))
def build(self, filename):
file = self.manager.input_file(filename)
name = self.manager.relname(file)
return self.builder.build(file.read(), name)
def render(self, filename, context=None):
self.context.update(context or {})
result = self.eval(self.build(filename))
self.context.pop()
return result
def convert(self, filename, outname=None, context=None):
file = self.manager.output_file(outname or filename)
file.write(self.render(filename, context))
return file.name
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
super(Test, cls).setUpClass()
WaeAgent.checkPointPath = "./testCheckPoint"
cls.dbPath = "testDb.sqlite"
if os.path.exists(cls.dbPath):
os.remove(cls.dbPath)
def setUp(self):
unittest.TestCase.setUp(self)
agentFactory = ConcAgentFactory()
environmentFactory = ConcEnvironmentFactory()
trainerFactory = WaeTrainerFactory()
buildParameterFactory = ConcBuildParameterFactory()
store = Store(self.dbPath)
logger = MyLogger(console_print=True)
self.builder = Builder(trainerFactory, agentFactory, environmentFactory, store, logger)
nIntervalSave = 1
nEpoch = 2
self.buildParameters = []
for k1 in range(2):
self.buildParameters.append(ConcBuildParameter(int(nIntervalSave), int(nEpoch), label="test" + str(k1)))
for k1 in range(2):
self.buildParameters.append(ConcBuildParameter(int(nIntervalSave), int(nEpoch)
, label="test case study 02a " + str(k1)
, nXi = 3
, target_casestudy = "cs02a"
))
for k1 in range(2):
self.buildParameters.append(ConcBuildParameter(int(nIntervalSave), int(nEpoch)
, label="test case study 03a " + str(k1)
, nXi = 3
, target_casestudy = "cs03a"
))
for k1 in range(2):
self.buildParameters.append(ConcBuildParameter(int(nIntervalSave), int(nEpoch)
, label="test case study 03b " + str(k1)
, nXi = 3
, target_casestudy = "cs03b"
))
for k1 in range(2):
self.buildParameters.append(ConcBuildParameter(int(nIntervalSave), int(nEpoch)
, label="test case study 03c " + str(k1)
, nXi = 3
, target_casestudy = "cs03c"
))
self.loader = Loader(agentFactory, buildParameterFactory, environmentFactory, store)
@classmethod
def tearDownClass(cls):
super(Test, cls).tearDownClass()
if os.path.exists(cls.dbPath):
os.remove(cls.dbPath)
if os.path.exists(WaeAgent.checkPointPath):
shutil.rmtree(WaeAgent.checkPointPath)
def test001(self):
for buildParameter in self.buildParameters:
assert isinstance(buildParameter, ConcBuildParameter)
self.builder.build(buildParameter)
assert isinstance(self.loader, Loader)
for agent, buildParameter, epoch in self.loader.load("test%", None):
assert isinstance(agent, WaeAgent)
assert isinstance(buildParameter, ConcBuildParameter)
from os import path
import os
import traceback
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='Prometheus - a Markdown-based HTML presentation generator'
)
parser.add_argument('-i', '--input', type=str, required=True)
# parser.add_argument('-o', '--out', type=str, required=True)
args = parser.parse_args()
input_file_path = path.abspath(args.input)
input_file_name = path.basename(input_file_path)
output_file_path = path.join(os.path.dirname(__file__), 'build',
input_file_name.replace('.md', '.html'))
# print(input_file_name)
# exit()
print(f'Building {output_file_path}...')
try:
b = Builder(input_file_path, output_file_path)
b.build()
os.system('notify-send "Build successful"')
print(f'Build successful')
except Exception as e:
os.system(f'notify-send -u critical "{e}"')
traceback.print_exc()
