def __init__(self, fieldSize, screenSize=(400, 400), mainFieldHeight=380): #TODO NUR height übergeben pygame.init() self.screen = pygame.display.set_mode(screenSize) pygame.display.set_caption("Conway's Game of Life") self.mainField = Screen(fieldSize) self.fieldSize = fW, fH = fieldSize self.screenSize = w, h = screenSize self.field = None self.loadedTemplate = None mainScreenSize = mW, mH = int(mainFieldHeight * fW / fH), mainFieldHeight margin = int((h - mH) / 2) self.mainScreenRect = (w - mW - margin, margin, mW, mH) self.selectionField = SelectionField((100, mainFieldHeight)) self.selectionFieldRect = (margin, margin, *self.selectionField.size) self.selectionField.add_template( Template('Test', figures.pentadecathlon)) self.selectionField.add_template( Template('Test', figures.glider_diagonal_se)) self.selectionField.add_template(Template('Test', figures.stick))
def testConstants(self): n = [0] def counter(): n[0] += 1 return n[0] - 1 constants = { "author": "Andy 'Da Man' Wardley", "single": "foo'bar", "double": 'foo"bar', "joint": ", ", "col": { "back": "#ffffff", "text": "#000000" }, "counter": counter } namespace = Constants(constants) self.assertEqual('"Andy \'Da Man\' Wardley"', namespace.ident(["constants", 0, "'author'", 0])) self.assertEqual('"foo\'bar"', namespace.ident(["constants", 0, "'single'", 0])) self.assertEqual("'foo\"bar'", namespace.ident(["constants", 0, "'double'", 0])) self.assertEqual( "'#ffffff'", namespace.ident(["constants", 0, "'col'", 0, "'back'", 0])) self.assertEqual( "'#000000'", namespace.ident(["constants", 0, "'col'", 0, "'text'", 0])) factory = Directive({"NAMESPACE": {"const": namespace}}) parser1 = Parser({"FACTORY": factory}) parser2 = Parser({"NAMESPACE": {"const": namespace}}) for parser in parser1, parser2: parsed = parser.parse('hello [% const.author %]\n' '[% "back is $const.col.back" %]' ' and text is {% const.col.text %]\n' 'but a col is still a [% col.user %]\n') text = parsed["BLOCK"] self.assertNotEqual(-1, text.find('"Andy \'Da Man\' Wardley"')) self.assertNotEqual(-1, text.find("'back is ', '#ffffff'")) self.assertNotEqual(-1, text.find("stash.get(['col', 0, 'user', 0])")) tt1 = Template({"NAMESPACE": {"const": namespace}}) const2 = { "author": "abw", "joint": " is the new ", "col": { "back": "orange", "text": "black" }, "fave": "back" } tt2 = Template({"CONSTANTS": const2}) tt3 = Template({"CONSTANTS": const2, "CONSTANTS_NAMESPACE": "const"}) engines = (("tt1", tt1), ("tt2", tt2), ("tt3", tt3)) vars = {"col": {"user": "******", "luza": "blue"}, "constants": constants} self.Expect(DATA, engines, vars)
class Gibson(Operation): name = 'Gibson Assembly' input_template = Template(type='DNA', shape='linear') output_template = Template(type='DNA', shape='circular', concentration='low')
def render(self): # render wrapper for handleEvent and callback functions out = os.path.join(self.outputdir, "ai.c") tempfile = os.path.join(self.templatedir, "wrappai.c") template = open(tempfile, "r") stream = Template(template.read()).render({ 'clbfuncs': self.clbfuncs, 'events': self.events, 'commands': self.commands, 'templatedir': self.templatedir, 'converter': converter, 'options': self.options }) template.close() outfile = open(out, "w") outfile.write(stream) outfile.close() # render interface out = os.path.join(self.outputdir, "PyAI", "interface.py") tempfile = os.path.join(self.templatedir, "aiInterface.py") template = open(tempfile, "r") stream = Template(template.read()).render({ 'classes': self.classes, 'commands': self.commandfuncs, 'cmd_types': self.command_types, 'evt_types': self.event_types, 'options': self.options }) outfile = open(out, "w") outfile.write(stream) outfile.close()
def Expect(self, data, tproc=None, vars=None): vars = vars or {} data = re.sub(r"(?m)^#.*\n", "", data) match = re.search(r"\s*--\s*start\s*--\s*", data) if match: data = data[match.end():] match = re.search(r"\s*--\s*stop\s*--\s*", data) if match: data = data[:match.start()] tests = re.split(r"(?mi)^\s*--\s*test\s*--\s*", data) if not tests[0]: tests.pop(0) ttprocs = None if isinstance(tproc, dict): tproc = Template(tproc) elif isinstance(tproc, (tuple, list)): ttprocs = dict(tproc) tproc = tproc[0][1] elif not isinstance(tproc, Template): tproc = Template() for count, test in enumerate(tests): match = re.search(r"(?mi)^\s*-- name:? (.*?) --\s*\n", test) if match: name = match.group(1) test = test[:match.start()] + test[match.end():] else: name = "template text %d" % (count + 1) match = re.search(r"(?mi)^\s*--\s*expect\s*--\s*\n", test) if match: input, expect = test[:match.start()], test[match.end():] else: input, expect = test, "" match = re.match(r"(?mi)^\s*--\s*use\s+(\S+)\s*--\s*\n", input) if match: ttname = match.group(1) ttlookup = ttprocs.get(ttname) if ttlookup: tproc = ttlookup else: self.fail("no such template object to use: %s\n" % ttname) input = input[:match.start()] + input[match.end():] try: out = tproc.processString(input, vars) except Exception as e: self.fail("Test #%d: %s process FAILED: %s\n%s" % ( int(count + 1), name, subtext(input), e)) match = re.match(r"(?i)\s*--+\s*process\s*--+\s*\n", expect) if match: expect = expect[match.end():] try: expect = tproc.processString(expect, vars) except TemplateException as e: self.fail("Test #%d: Template process failed (expect): %s" % ( count + 1, e)) out = out.rstrip("\n") stripped = expect.rstrip("\n") self.assertEqual(stripped, out, "Test #%d:\n%s\n%r != %r" % (count + 1, test, stripped, out))
class Zymoprep(Operation): name = 'Zymoprep' input_template = Template(type='Yeast', concentration='high') output_template = Template(type='DNA', shape='circular', concentration='low')
class Ligate(Operation): name = 'Ligate' input_template = Template(type='DNA', shape='linear') output_template = Template(type='DNA', shape='circular', concentration='low')
class Quikchange(Operation): name = 'Quikchange' input_template = Template(type='DNA', shape='circular') output_template = Template(type='DNA', shape='circular', concentration='low')
class Electroporation(Operation): name = 'Electroporation' input_template = Template(type='DNA', shape='circular', concentration='high') output_template = Template(type='Yeast', concentration='low')
def testStash(self): count = [20] def boz(): count[0] += 10 return count[0] def biz(*args): return args and args[0] or "<undef>" data = { "foo": 10, "bar": { "baz": 20 }, "baz": lambda: { "boz": boz, "biz": biz }, "obj": AnObject(name="an object"), "hashobj": HashObject(planet="World") } stash = Stash(data) self.assertEqual(10, stash.get("foo").value()) self.assertEqual(20, stash.get(["bar", 0, "baz", 0]).value()) self.assertEqual(20, stash.get("bar.baz").value()) self.assertEqual(20, stash.get("bar(10).baz").value()) self.assertEqual(30, stash.get("baz.boz").value()) self.assertEqual(40, stash.get("baz.boz").value()) self.assertEqual("<undef>", stash.get("baz.biz").value()) self.assertEqual("<undef>", stash.get("baz(50).biz").value()) # args are ignored stash.set("bar.buz", 100) self.assertEqual(100, stash.get("bar.buz").value()) ttlist = (("default", Template()), ("warn", Template({"DEBUG": constants.DEBUG_UNDEF, "DEBUG_FORMAT": ""}))) self.Expect(DATA, ttlist, data)
class Miniprep(Operation): name = 'Miniprep' input_template = Template(type='E.Coli', concentration='high') output_template = Template(type='DNA', shape='circular', concentration='high')
def testContext(self): tt = Template({ 'INCLUDE_PATH': 'test/src:test/lib', 'TRIM': True, 'POST_CHOMP': 1 }) ttpython = Template({ 'INCLUDE_PATH': 'test/src:test/lib', 'TRIM': True, 'POST_CHOMP': 1, 'EVAL_PYTHON': True }) ctx = tt.service().context() self.failUnless(ctx) self.assertEquals(ctx, tt.context()) self.failUnless(ctx.trim()) self.failUnless(not ctx.eval_python()) ctx = ttpython.service().context() self.failUnless(ctx) self.failUnless(ctx.trim()) self.failUnless(ctx.eval_python()) # template() # Test that we can fetch a template via template() tmpl = ctx.template('header') self.failUnless(tmpl) self.failUnless(isinstance(tmpl, Document)) # Test that non-existence of a template is reported error = None try: tmpl = ctx.template('no_such_template') except Exception, e: error = e
def testService(self): config = { "INCLUDE_PATH": "test/src:test/lib", "PRE_PROCESS": ["config", "header"], "POST_PROCESS": "footer", "BLOCKS": { "demo": lambda *_: "This is a demo", "astext": "Another template block, a is '[% a %]'" }, "ERROR": { "barf": "barfed", "default": "error" }, } tt1 = Template(config) config["AUTO_RESET"] = 0 tt2 = Template(config) config["ERROR"] = "barfed" tt3 = Template(config) config["PRE_PROCESS"] = "before" config["POST_PROCESS"] = "after" config["PROCESS"] = "process" config["WRAPPER"] = "outer" tt4 = Template(config) config["WRAPPER"] = ["outer", "inner"] tt5 = Template(config) replace = {"title": "Joe Random Title"} self.Expect(DATA, (("tt1", tt1), ("tt2", tt2), ("tt3", tt3), ("wrapper", tt4), ("nested", tt5)), replace)
def testTags(self): params = { "a": "alpha", "b": "bravo", "c": "charlie", "d": "delta", "e": "echo" } tt = (("basic", Template({ "INTERPOLATE": 1 })), ("htags", Template({ "TAG_STYLE": "html" })), ("stags", Template({ "START_TAG": r"\[\*", "END_TAG": r"\*\]" }))) self.Expect(DATA, tt, params)
def testVarsV1(self): params = self.make_params() tt = (("default", Template({ "INTERPOLATE": 1, "ANYCASE": 1, "V1DOLLAR": 1 })), ("notcase", Template({ "INTERPOLATE": 1, "V1DOLLAR": 0 }))) self.Expect(DATA_V1, tt, params)
def testBlocks(self): dir = os.getcwd() + "/test/lib" tt1 = Template({ 'INCLUDE_PATH': ['test/lib'], 'ABSOLUTE': True }) tt2 = Template({ 'INCLUDE_PATH': ['test/lib'], 'EXPOSE_BLOCKS': True, 'ABSOLUTE': True }) vars = { 'a': 'alpha', 'b': 'bravo', 'dir': dir } self.Expect(DATA, (('off', tt1), ('on', tt2)), vars)
def testText(self): tt = (("basic", Template()), ("interp", Template({ "INTERPOLATE": 1 }))) vars = self._callsign() v2 = { "ref": lambda obj: "%s[%s]" % (obj, obj.__class__.__name__), "sfoo": Stringy("foo"), "sbar": Stringy("bar") } vars.update(v2) self.Expect(DATA, tt, vars)
def response(self, msg, **kwargs): ## msg is parsed and your handled data.Actually,it is a dict. ## Your could specify a type by assign.ex response(type='music').I list all legal types. ''' ex: response(message,type='yourType') optional kwargs: type='legal_types',content='yourContent',handler=foo,count=1 ps:when type is news,the count kwarg is nessceary support types: text,image,voice,video,music,news ''' msg['receiver'], msg['sender'] = msg['sender'], msg['receiver'] legal_types = ['text', 'music', 'image', 'voice', 'video', 'news'] ## get some kwargs ## # key word content ---- which force type to textand return a static string if kwargs.get('type'): type = kwargs.get('type') else: type = msg['type'] if type == 'music': if not msg['hq_musurl']: msg['hq_musurl'] = msg['musurl'] # charge receiver and sender if kwargs.get('content'): msg['type'] = type = 'text' msg['content'] = to_unicode(kwargs.get('content')) if not type in legal_types: raise Exception( "Illgal type!You could only choose one type from legal_types!") # key word handler ---- which is a function object,accept a dict and return a modified dict else: msg['type'] = type if kwargs.get('handler'): msg = kwargs.get('handler')(msg) ## more kwargs ## if not type == 'news': template = to_unicode(getattr(Template(), type)) else: count = kwargs.get('count') if count: temp = Template() template = to_unicode(temp.news(count)) else: raise Exception( 'When type is set to news,the count kwarg is necessary!') logging.info(template.format(**msg)) try: retdata = template.format(**msg) except: raise Exception( "You did't pass enough args or pass wrong args,please check args which template needed.Read template.py maybe inspire your mind" ) return retdata
def testDirectives(self): ttobjs = (('tt', Template()), ('pre', Template({'PRE_CHOMP': 1})), ('post', Template({'POST_CHOMP': 1})), ('trim', Template({ 'INCLUDE_PATH': 'test/lib', 'TRIM': 1 }))) self.Expect(DATA, ttobjs, self._callsign())
def testStop(self): ttblocks = { "header": lambda *_: "This is the header\n", "footer": lambda *_: "This is the footer\n", "halt1": halt } ttvars = { "halt": halt } ttbare = Template({ "BLOCKS": ttblocks }) ttwrap = Template({"PRE_PROCESS": "header", "POST_PROCESS": "footer", "BLOCKS": ttblocks }) self.Expect(DATA, (("bare", ttbare), ("wrapped", ttwrap)), ttvars)
def compile(self, header, body, footer): header, body, footer = (Template(header), Template(body), Template(footer)) compiled = '' for post in self.posts: compiled += body.compile({ 'title': post.title, 'date': post.pretty_date, 'content': self.indent(post.content) }) return (header.compile() + compiled + footer.compile())
def testEvalPython(self): tt_no_python = Template({"INTERPOLATE": 1, "POST_CHOMP": 1, "EVAL_PYTHON": 0, "INCLUDE_PATH": "test/lib"}) tt_do_python = Template({"INTERPOLATE": 1, "POST_CHOMP": 1, "EVAL_PYTHON": 1, "INCLUDE_PATH": "test/lib"}) ttprocs = (("no_python", tt_no_python), ("do_python", tt_do_python)) self.Expect(DATA, ttprocs, self._callsign())
def testProcess(self): config = { "INCLUDE_PATH": "test/src:test/lib", "PROCESS": "content", "TRIM": 1 } tt1 = Template(config) config["PRE_PROCESS"] = "config" config["PROCESS"] = "header:content" config["POST_PROCESS"] = "footer" config["TRIM"] = 0 tt2 = Template(config) config["PRE_PROCESS"] = "config:header.tt2" config["PROCESS"] = "" tt3 = Template(config) replace = { "title": "Joe Random Title" } self.Expect(DATA, (("tt1", tt1), ("tt2", tt2), ("tt3", tt3)), replace)
def main(): try: manager = InfHoneydMan() windows = Template("windows") windows.set_personality("Microsoft Windows NT 4.0 SP3") windows.set_uptime(1728650) windows.set_ethernet("dell") windows.set_tcp_default("closed") windows.add_tcp_port(80, "/home/honeyd/honeyd/Honeyd-master/scripts/web.sh") windows.add_tcp_port(22, "/home/honeyd/honeyd/Honeyd-master/scripts/test.sh") windows.add_tcp_port(23, "/home/honeyd/honeyd/Honeyd-master/scripts/router-telnet.pl") windows.add_udp_port(53, "open") windows.add_udp_port(137, "open") windows.add_udp_port(161, "open") windows.add_udp_port(162, "filtered") ubuntu = Template("ubuntu") ubuntu.set_personality("Linux 2.6.15 (Ubuntu)") ubuntu.set_ethernet("dell") ubuntu.set_tcp_default("closed") ubuntu.add_tcp_port(80, "/home/honeyd/honeyd/Honeyd-master/scripts/web.sh") ubuntu.add_tcp_port(22, "/home/honeyd/honeyd/Honeyd-master/scripts/test.sh") ubuntu.add_tcp_port(23, "/home/honeyd/honeyd/Honeyd-master/scripts/router-telnet.pl") ubuntu.add_udp_port(54, "open") ubuntu.add_udp_port(138, "open") ubuntu.add_udp_port(163, "open") ubuntu.add_udp_port(164, "filtered") manager.add_template(windows) manager.add_template(ubuntu) templates = manager.template_list.values() for ii in range(1, 11): for jj in range(0, 10): addr_4 = ii*10 + jj vhost = "192.168.193." + str(addr_4) t_i = random.randint(1, 2) manager.add_honeypot(vhost, templates[t_i]) print ii manager.update_config() time.sleep(5) # manager.add_honeypot("192.168.193.97", windows) # manager.add_honeypot("192.168.193.98", ubuntu) # manager.list_honeypots() # manager.update_config() except KeyboardInterrupt: LOG.info("MAIN ERROR: keyboard interrupt, now quit") sys.exit(0)
def main(): max_iterations = 10 operations = op.get_default_operations() network = Network() network.add_node(Template(no_input=True)) for iteration in xrange(max_iterations): #print 'Current nodes:',network.all_nodes #print 'Current edges:',network.all_edges #print 'Iteration {}'.format(iteration) additions = 0 # determines if nothing is growing for operation in operations: new_edges = build_edge(operation, network.all_nodes, network.all_edges) if not new_edges: continue if network.add_edges(new_edges, operation.name): additions = 1 if additions == 0: break network.display_flowchart()
def testCompile(self): ttcfg = { "POST_CHOMP": 1, "INCLUDE_PATH": "test/src", "COMPILE_EXT": ".ttc" } # Check that compiled template files exist. compiled = "test/src/foo.ttc" self.assert_(os.path.exists(compiled)) self.assert_(os.path.exists("test/src/complex.ttc")) # Ensure template metadata is saved in compiled file. output = Template(ttcfg).process("baz", {"showname": 1}) self.assertNotEqual(-1, output.find("name: baz")) # We're going to hack on the foo.ttc file to change some key text. # This way we can tell that the template was loaded from the compiled # version and not the source. fh = open(compiled, "r+") stat = os.fstat(fh.fileno()) foo = fh.read() fh.seek(0) fh.write(foo.replace("the foo file", "the hacked foo file")) fh.close() os.utime(compiled, (stat.st_atime, stat.st_mtime)) self.Expect(DATA, ttcfg)
def test_variable(self): rendered = Template(''' hello, {{ name }} ''').render(name='flango') self.assertEqual(rendered, ''' hello, flango ''')
def testPostChomp(self): tmpl = Template({'POST_CHOMP': 1, 'BLOCKS': blocks}) self.AssertExpectedOutput(tmpl, "foo", vars, "\n3.14") self.AssertExpectedOutput(tmpl, "bar", vars, "2.718") self.AssertExpectedOutput(tmpl, "baz", vars, "\n1.618\n") self.AssertExpectedOutput(tmpl, "ding", vars, "!Hello!") self.AssertExpectedOutput(tmpl, "dong", vars, "! World !")
def testPreChomp(self): tmpl = Template({"PRE_CHOMP": 1, "BLOCKS": blocks}) self.AssertExpectedOutput(tmpl, "foo", vars, "3.14\n") self.AssertExpectedOutput(tmpl, "bar", vars, "2.718") self.AssertExpectedOutput(tmpl, "baz", vars, "\n1.618\n") self.AssertExpectedOutput(tmpl, "ding", vars, "!Hello!") self.AssertExpectedOutput(tmpl, "dong", vars, "! World !")
def print_jsfile(titles, fp): var = { 'escape_simple': lambda s: cgi.escape(s, True), 'titles': titles, 'server': server, } fp.write(Template().display('suggest_js', var))