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))
