def main(): #TODO: grab date from the database to get settings on startup global logFile Log.initialize() setupBoard() time.sleep(5) db = DbConnection() #CycleIrrigation(3, "by barn","random notes", 12, 5, 10, "2020-03-09T19:44:18", "2020-03-09T06:44:18") #TODO: test data #Irrigation(3, "barn irrigation", "random notes", 16, [1, 4, 5],{"2020-03-08T01:54:57":3600,"2020-04-08T01:52:51":10}) #TODO: test data Device.turnMainStateOn() socket = SocketCom() thread = threading.Thread(target=socket.start) thread.start() while True: if Device.isAllOn(): for device in Device.deviceList: device.run() else: Device.turnAllOff() cleanup() Log.close()
def main_train(): env = gym.make('CartPole-v1') params = initialize_parameters(env) logger = Log("log.log", params) agent = train_agent(env, params, logger, True) # save=True to save model test_agent(agent, env, params, logger, 200) # test model over 200 episodes logger.close()
def load(self, log_name, add_tags=[]): """ adds a log file to the journal object currently in memory this can be called multiple times with different filenames to merge those files/entries into the journal >>> from journal import * >>> j = Journal() >>> j.load("sample_log.txt") >>> len(j.entries) 1 return True if the file was able to be loaded False if it was not a journal/Log file """ found_entries = 0 if not str(log_name) in self.loaded: self.loaded.append(str(log_name)) #TODO: #should also handle adding entry to self._sources?? #or will that happen in update_entries #would it be better for sources and loaded to be associated #on an update? #that way if entries are added outside of a load #the sources would still get updated. l = Log() l.from_file(str(log_name)) entries = l.to_entries(add_tags) #print "%s entries loaded from file" % len(entries) #print "%s entries in self before merging in entries" % len(self) self.update_many(entries) #print "%s entries in self after merging in entries" % len(self) #if l.has_entries: found_entries = len(entries) l.close() return found_entries
def save(self, filename=None, order='original', include_path=False): """ >>> from entry import Entry >>> e = Entry("test entry") >>> j.add_entry(e) >>> j.to_file("sample_log2.txt") >>> k = Journal() >>> k.load("sample_log2.txt") >>> len(k.entries) 2 """ if filename: self.path = str(filename) if hasattr(self, "path") and self.path: l = Log(self.path) else: print "No name to save Journal to" exit() #l.from_journal(self, holder, entry) l.from_entries(self.sort(order=order), include_path=include_path) l.to_file() l.close()
class User(basic.Int16StringReceiver): """ This protocol handles user-side stuffs """ def connectionMade(self): """ Called when a user is made. This initilizes some stuff basic stuff, but the rest is done after ID. """ #self.old = self.dataReceived #self.dataReceived = lambda data: out.write(data) and self.old(data) self.state = 0 self.name = None self.data_dict = None #data_dict is the json.loads'd information sent to us by the client self.dtrecv = self.dataReceived # self.dataReceived = lambda data: pprint(data) and self.dtrecv(data) def stringReceived(self, string): if self.state is 0 and not self.data_dict: #If are not running and have no data try: self.data_dict = json.loads(string) except ValueError: out.write('Someone sent "%s" instead of an respectable ID' % string) self.transport.write("Bad IDing, you fool!\n") self.transport.loseConnection() return None self.ip = self.data_dict["ip"] try: self.name = self.server.IPs[self.ip] self.start_prog() except KeyError: #if this IP has no registered name self.transport.write("What do you wish to be called? [no spaces] ") elif self.state is 0 and self.data_dict: #if we are not running and have data name = self.sanitize(string) if not name == string: #If it was changed name = "Cracker" out.write("User at", self.data_dict["ip"], "tried to name himself", string) self.name = name self.start_prog() elif self.state is 1 and self.prog.state is 1: #If running line = ' '.join(self.sanitize(string).split()) #normalize spacing and remove potentially malicious charecters self.log.write("User:"******"\n") def send(self, msg): self.transport.write(msg) #This conveniece message can be changed later instead of changing #each write def start_prog(self): self.name = str(self.makename("".join(self.name.split()))) #to prevent unicode names, repeated names, and names with spaces self.log = Log() self.log.open(self.name) self.server.add(self.data_dict['ip'], self.name) self.server.named_users[self.name] = self prog = Prog(self) self.server.reactor.spawnProcess(prog, self.server.PRG, [], path = self.server.CWD ) self.server.progs.append(prog) self.prog = prog out.write(self.name, "had connected. Users:", len(self.server.users)) self.transport.write("Hello, %s.\n" % self.name) self.prog.transport.write(self.name + "\n") if self.name.lower().startswith("sex"): def boobs(reactor): self.transport.write("BOOBS") reactor.callLater(0, boobs, reactor) self.server.reactor.callLater(0, boobs, self.server.reactor) self.state = 1 def connectionLost(self, reason): """ Called when a user quits. If we are running, shuts down everything that we opened. """ self.server.users.remove(self) users = len(self.server.users) if self.state: #If it is a true state, like one or two try: del self.server.named_users[self.name] except KeyError: out.write(self.name, "connected twice, or somehow removed his " "name from the system..") out.write(self.name, 'has quit. Users:', users) self.log.close() if self.prog.state is not 2: #if it's not dead already self.prog.transport.signalProcess('KILL') self.prog.state = 2 else: #if we've not started yet out.write("Someone without ID quit. Users:", users) self.state = 2 #dead def sanitize(self, s): """ Returns s with any offending charecters removed. Specificly, non-(alnum|space|{}:"') """ def healthy(char): if char.isalnum() or char.isspace() or char in '{}:"\'': return True else: return False return filter(healthy, s) def makename(self, name): if name in self.server.named_users: name += "1" while name in self.server.named_users: name[-1] = str(int(name[-1]) + 1) return name def __repr__(self): return "<user {}, state {}>".format(self.name, self.state)
class ReGo: def __init__(self): """ Constructor of the class ReGo """ # known commands self.knownCmds = [ 'protocol_version' , 'name' , 'version' , 'known_command' , 'list_commands' ,'quit' , 'boardsize' , 'clear_board' , 'komi' , 'play' , 'genmove' ] # open log self.log = Log() self.log.open() # board self.board = Board(19,self.log) # score self.score = 0.0 # players self.bPlayer = Player('b',self.board,self.log) self.wPlayer = Player('w',self.board,self.log) def __decodeLine__(self,line): """ Decodes an input line read from stdin """ vals = line.split(' ') return (vals[0],vals[1:]) def __decodeColor__(self,colorStr): """ Decodes a color string """ if colorStr.upper() in ('B','BLACK'): return 'b' elif colorStr.upper() in ('W','WHITE'): return 'w' else: raise SyntaxError('illegal color') def __decodePosition__(self,posStr): """ Decodes a position string """ try: posLetter = posStr[0].upper() posNumber = int(posStr[1:]) except Exception: raise SyntaxError('invalid position') else: return posLetter,posNumber def __handleError__(self): """ Checks for the exception raised and returns the error string. It logs also the exception stack-trace in case of an unexpected error. """ e_type, e, tb = sys.exc_info() # syntax error if e_type == SyntaxError: output_line = '? syntax error: '+e.message+'\n\n' # consistency error elif e_type == ConsistencyError: output_line = '? consistency error: '+e.message+'\n\n' # unexpected error else: output_line = '? unexpected error\n\n' self.log.logException(e_type, e, tb ) return output_line def protocol_version(self,args): """ Prints GTP protocol version """ return '2' def name(self,args): """ Prints the name of this GO engine """ return 'Rego' def version(self,args): """ Prints the version of this GO engine """ return '0.1' def know_command(self,args): """ Returns true if the command specified is known, false otherwise """ if not args[0]: raise SyntaxError('invalid command name') if args[0] in self.knownCmds: return 'true' else: return 'false' def list_commands(self,args): """ Lists known commands """ return ' '.join(self.knownCmds) def boardsize(self,args): """ Set the new board size to the number specified by the argument """ try: size = int(args[0]) except Exception: raise SyntaxError('board size is not an integer') else: self.board = Board(int(args[0]),self.log) return '' def clear_board(self,args): """ Clears the board """ self.board.clear() self.bPlayer = Player('b',self.board,self.log) self.wPlayer = Player('w',self.board,self.log) return '' def komi(self,args): """ Sets the new komi to the float value specified as argument """ try: komi = float(args[0]) except Exception: raise SyntaxError('komi is not a float') else: self.score = float(args[0]) return '' def play(self,args): """ Updates the board according to the move specified as argument """ color = self.__decodeColor__(args[0]) posLetter,posNumber = self.__decodePosition__(args[1]) m = Move(color=color,posLetter=posLetter,posNumber=posNumber) self.board.update(m) self.bPlayer.updateListLegal(m.getListFormat(),self.board.getKilled()) self.wPlayer.updateListLegal(m.getListFormat(),self.board.getKilled()) self.log.logDebug(self.board.showBoard()) return '' def genmove(self,args): """ Generate a new move for the player specified as argument """ move = MonteCarlo(self.log,self.board, self.__decodeColor__(args[0]), self.bPlayer, self.wPlayer) self.board.update(move) self.bPlayer.updateListLegal(move.getListFormat(),self.board.getKilled()) self.wPlayer.updateListLegal(move.getListFormat(),self.board.getKilled()) self.log.logDebug(self.board.showBoard()) return move.encode() def execute(self): """ Main method: reads a command from stdin and writes the output to stdout """ # read first input line = raw_input() self.log.logInput(line) cmd, args = self.__decodeLine__(line) # main loop while not cmd == 'quit': if cmd in self.knownCmds: method = getattr(self,cmd) try: output = method(args) except Exception: output_line = self.__handleError__() else: output_line = '= '+output+'\n\n' else: output_line = '? unknown command\n\n' # write back the output line to stdout sys.stdout.write(output_line) sys.stdout.flush() # log the output self.log.logOutput(output_line) # read the next input line = raw_input() self.log.logInput(line) cmd, args = self.__decodeLine__(line) self.log.close()
#Creating a blank document word.child_window(title="Documento em branco", auto_id="AIOStartDocument", control_type="Hyperlink").type_keys('{ENTER}') #Typing and personalizing the document word.type_keys('Estou{SPACE}') word.child_window(title="Sublinhado", control_type="Button").click() word.child_window(title="Página 1", auto_id="UIA_AutomationId_Word_Page_1", control_type="Custom").type_keys('testando') word.child_window(title="Sublinhado", control_type="Button").click() word.child_window(title="Página 1", auto_id="UIA_AutomationId_Word_Page_1", control_type="Custom").type_keys('{SPACE}o{SPACE}Word.') #Saving the document word.child_window(title="Salvar", control_type="Button").click() word.child_window(title="Área de Trabalho", control_type="Button").click() #Encontrando a janela Salvar Como #word.child_window(title="Nome do arquivo:", auto_id="1001", control_type="Edit").set_text(dateExecution) word.child_window(title="Salvar", auto_id="1", control_type="Button").click() #word.close() Log.print('>>>The execution FINISHES HERE!\n\n') Log.close() exit()
parser.parse('invoices-line-items') if do_merge: merger = Merger(log) merger.merge_invoice_delta() return True if __name__ == "__main__": task = sys.argv[1] log = Log(echo=False) if task == 'test': test(log) log.close() exit() if task == 'refresh_token': log.echo = True refresh(log) log.echo = False log.close() exit() prelim() if task == 'process_data': process_single(log, do_fetch=True, do_parse=True) process_multiple(log, do_fetch=True, do_parse=True, do_merge=True) else:
class Sploit(object): ''' ''' DEFAULT_FRAGMENT_SIZE = 460 def __init__(self, tool_name, tool_version): self.tool_name = tool_name self.tool_version = tool_version self.terminateFlingOnException = False self.env = argparse.Namespace() self.params = argparse.Namespace() self.key_data = None self.vinfo = None self.log = Log(self.tool_name, self.tool_version) self.log.open() self._init_parser() def __del__(self): self.log.close() self.log = None @property def description(self): ''' ''' return '%s (version %s)' % (self.tool_name, self.tool_version) def _init_parser(self): ''' ''' self.parser = argparse.ArgumentParser(description = self.description) self.subcommands = [] self.setup_parser() subcommands = self.subcommands del self.subcommands if subcommands: subparsers = self.parser.add_subparsers() for subcommand in subcommands: subparser = subparsers.add_parser(subcommand.name) subparser.set_defaults(subcommand = subcommand) subcommand.setup_parser(subparser) @public def add_subcommand(self, subcommand): ''' ''' self.subcommands.append(subcommand) @internal @overridable("Overrides must call base implementation first") def setup_parser(self): ''' ''' self.add_logging_params(self.parser) @internal def create_socket(self, ip = None, port = None, timeout = None): ''' ''' if self.params.redir: exsock = FragmentingPseudoSocket(self.params.dst['ip'], self.params.dst['port'], **self.params.redir) exsock.fragment_size = self.params.fragment_size or self.DEFAULT_FRAGMENT_SIZE exsock.raw_send = self.params.raw_send else: exsock = PseudoSocket(self.params.dst['ip'], self.params.dst['port']) exsock.timeout = self.params.timeout exsock.verbose = self.params.verbose exsock.log = self.log return exsock @overridable("Overrides must call base implementation first") def pre_parse(self, args): ''' ''' self.params.args = args self.env.progname = args[0] self.env.progbase = os.path.basename(args[0]) self.env.progpath = os.path.realpath(os.path.dirname(args[0])) def _parse(self, args): ''' ''' self.pre_parse(args) self.parser.parse_args(args[1:], self.params) try: self.post_parse() except argparse.ArgumentError, e: self.parser.error(str(e))