예제 #1
0
  def start(self):
    os.system("clear")
    while True:
      print green("How can I help you, %s?" % self.user)
      print yellow("1. Transfer some money\n"
                   " 2. Pay\n"
                   " 3. Retrieve\n"
                   " 4. Show balance\n"
                   " 5. Logout\n")

      option = int(raw_input(blue("I want to: ")))
      if option == 1 or option == 2:
        to = raw_input(red("to: "))
        money = raw_input(red("sum: "))
        try:
          print self.bank.transfer_from(self.user, to, money)
        except ValueError as ve:
          print red(ve)
      elif option == 3:
        money = raw_input(red("sum: "))
        try:
          if self.bank.transfer_from(self.user, self.name, money):
            print green("Operation finished with success!\n")
          else:
            print red("Something went wrong...try again later\n")
        except ValueError as ve:
          print red(ve)
      elif option == 4:
        print self.bank.show_balance(self.user)
      elif option == 5:
        self.user = None
        return
예제 #2
0
def show_diff(old, new):
    for k, v in new.iteritems():
        if k in old.keys() and v == old[k]:
            continue
        if k in old.keys() and v != old[k]:
            red(" - ['{}'] = {}".format(k, old[k]))
        green(" + ['{}'] = {}".format(k, v))
예제 #3
0
  def open(self):
    os.system("clear")
    print blue("Welcome to %s" % green(self.name))
    print blue("========================")
    while True:
      print red("How may I help you?")
      print yellow("1. Buy a ticket\n"
                   " 2. Book a ticket by phone\n"
                   " 3. Book a ticket\n"
                   " 4. Cancel booking\n"
                   " 5. See how many money do you have\n"
                   " 6. Goodbye!\n")

      option = raw_input(green("I want to: "))

      if option == "1":
        self.buy_ticket()

      if option == "2":
        self.book_ticket_by_phone()

      if option == "3":
        self.book_ticket()

      if option == "4":
        self.cancel_booking()

      if option == "5":
        self.money()

      if option == "6":
        break
def _status(self, final=False):
    if not final:
        new = (green(len(self._completed)),
           white(len(self._running)),
           yellow(len(self._queued)),
           green('finished'),
           white('running'),
           yellow('queued'))
        if hasattr(self, 'last_status') and new == self.last_status:
            return
        self.last_status = (green(len(self._completed)),
            white(len(self._running)),
            yellow(len(self._queued)),
            green('finished'),
            white('running'),
            yellow('queued'))
        print WHIPE, "[%s/%s/%s] %s, %s, %s" % new
    else:
        print "\n[ %s OK / %s ERROR ] in %s seconds" % (
                green(self._num_of_jobs - self._errors, True),
                red(self._errors),
                time.time() - self._time_start)
        if self._errors:
            print red("Failures:", True)
            for job in self._completed:
                if job.exitcode != 0:
                    print red(job.name)
    sys.stdout.flush()
예제 #5
0
 def _check_for_crash(self):
     status = self._get_status()
     if status != "LIVE":
         print(status)
         sys.exit(utils.red('ESPv2 crash'))
         return
     print utils.green('No crashes detected.')
 def run_all_tests(self):
   for _ in range(FLAGS.runs):
     self._run_fuzz_tests()
   if self._unexpected_errors > 0:
     sys.exit(utils.red('Fuzz test failed.'))
   else:
     print utils.green('Fuzz test passed.')
예제 #7
0
def show_diff(old, new):
    for k, v in new.iteritems():
        if k in old.keys() and v == old[k]:
            continue
        if k in old.keys() and v != old[k]:
            red(" - ['{}'] = {}".format(k, old[k]))
        green(" + ['{}'] = {}".format(k, v))
예제 #8
0
    def run_all_tests(self):
        shelf1 = {'name': 'shelves/1', 'theme': 'Fiction'}
        shelf2 = {'name': 'shelves/2', 'theme': 'Fantasy'}
        book13 = {
            'name': 'shelves/1/books/3',
            'author': 'Neal Stephenson',
            'title': 'REAMDE'
        }
        book24 = {
            'name': 'shelves/2/books/4',
            'author': 'George R.R. Martin',
            'title': 'A Game of Thrones'
        }

        self.verify_shelf(shelf1)
        self.verify_shelf(shelf2)
        self.verify_list_shelves([shelf1, shelf2])

        self.verify_list_books(shelf1['name'], [book13])
        self.verify_list_books(shelf2['name'], [book24])

        self.verify_book(book13)
        self.verify_book(book24)

        self.verify_jwt_locations()
        self.verify_allow_cors_passthrough()

        if self._failed_tests:
            sys.exit(
                utils.red('%d tests passed, %d tests failed.' %
                          (self._passed_tests, self._failed_tests)))
        else:
            print utils.green('All %d tests passed' % self._passed_tests)
예제 #9
0
    def run_all_tests(self):
        self.verify_key_restriction();

        if self._failed_tests:
            sys.exit(utils.red('%d tests passed, %d tests failed.' % (
                self._passed_tests, self._failed_tests)))
        else:
            print utils.green('All %d tests passed' % self._passed_tests)
예제 #10
0
    def run_all_tests(self):

        self.verify_quota_control()

        if self._failed_tests:
            sys.exit(
                utils.red('%d tests passed, %d tests failed.' %
                          (self._passed_tests, self._failed_tests)))
        else:
            print utils.green('All %d tests passed' % self._passed_tests)
예제 #11
0
def main():
    parser = argparse.ArgumentParser(
        description=
        'Program that takes as an argument the json -->.txt<-- file and makes a root file out of it, which can be used with the main framework.'
    )
    parser.add_argument('--input',
                        '-i',
                        required=True,
                        type=str,
                        help='Name of the json converted to a .txt file')
    parser.add_argument('--output',
                        '-o',
                        type=str,
                        help='Name of the target .root file')

    args = parser.parse_args()
    infilename = os.path.abspath(args.input)
    if not infilename.endswith('.txt'):
        raise ValueError('Infilename does not end with .txt')
    outfilename = os.path.abspath(
        args.output) if args.output is not None else '.root'.join(
            infilename.rsplit('.txt', 1))

    with open(infilename, 'r') as f:
        dict_in_json = safe_load(f)

    outfile = TFile(outfilename, 'RECREATE')
    outtree = TTree("LumiTree", "LumiTree")
    t_run = array('i', [0])
    t_lb_low = array('i', [0])
    t_lb_high = array('i', [0])

    outtree.Branch("run", t_run, 'run number/i')
    outtree.Branch("lb_low", t_lb_low,
                   'lumi block low number (including this one)/i')
    outtree.Branch("lb_high", t_lb_high,
                   'lumi block high number (including this one)/i')
    runs = dict_in_json.keys()
    for run in dict_in_json:
        parts = dict_in_json[run]
        # print parts
        for lumiblocks in parts:
            t_run[0] = int(run)
            t_lb_low[0] = int(lumiblocks[0])
            t_lb_high[0] = int(lumiblocks[1])
            outtree.Fill()
            # for lb in range(lumiblocks[0], lumiblocks[1]+1):
            #     t_run[0] = int(run)
            #     t_lb[0]  = int(lb)
            #     outtree.Fill()
            # print 'filled: (%i, %i)' % (int(run), int(lb))

    outfile.Write()
    outfile.Close()
    print green('--> Successfully created lumifile \'%s\'' % (outfilename))
예제 #12
0
  def run(self):
    if self.is_negative:
      if self._from != 10:
        self.log.error(red("I dont know how to convert negative numbers if"
                           " there are not in decimal base"))
        return False
      else:
        number = self.transform_negative()
    else:
      number = self.transform_positive()

    print green("Your number is %s" % red(number))
예제 #13
0
 def process_tick_top(self, tick, last_row):
     volok = (last_row['V'] < last_row['VMA20'])
     priceok = (last_row['H'] > last_row['BBU'])
     self.log('%s(%.2f < %.2f) %s(%s > %s)' %
              (green('volok') if volok else red('volko'),
               last_row['V'], last_row['VMA20'],
               green('priceok') if priceok else red('priceko'),
               last_row['H'], last_row['BBU']))
     if priceok:
         if volok:
             self.sell(tick)
         else:
             self.set_stop(tick, last_row['BBM'])
예제 #14
0
 def login(self):
   print "\n\n"
   username = raw_input(green("username: "******"password: "******"db/clients.txt", "r") as f:
     clients = f.read()
     credentials = "%s:%s" % (username, sha1(password).hexdigest())
     if credentials in clients:
       print green("Welcome!")
       self.user = username
       self.start()
     else:
       print red("Wrong credentials!")
예제 #15
0
 def process_tick_middle(self, tick, last_row):
     volok = (last_row['V'] > last_row['VMA20'])
     priceok = (tick['H'] > last_row['BBM'])
     self.log('%s(%.2f > %.2f) %s(%s > %s)' %
              (green('volok') if volok else red('volko'),
               last_row['V'], last_row['VMA20'],
               green('priceok') if priceok else red('priceko'),
               tick['H'], last_row['BBM']))
     if priceok:
         if volok:
             self.status = 'top'
             self.set_stop(tick, self.entry)
         else:
             self.sell(tick)
예제 #16
0
def show_unencrypted_diff(diff_part, password_file=None):
    intense(get_head(diff_part).strip())
    old, new = decrypt_diff(diff_part, password_file)
    diff = difflib.unified_diff(old.split('\n'), new.split('\n'), lineterm='')
    # ... we'll take the git filenames from git's diff output rather than
    # ... difflib
    for line in islice(diff, 2, None):
        if line.startswith('-'):
            red(line)
        elif line.startswith('+'):
            green(line)
        elif line.startswith('@@'):
            cyan(line)
        else:
            print line
예제 #17
0
def handle(socket, address):
    print green("Client connected")

    while True:
        data = socket.recv(2048)
        if not data:
            print red("Client disconnected")
            return

        message = parser(data)
        if message is None:
            return

        if message[0] == "transfer":
            transfer(message[1], socket)
예제 #18
0
 def job_status(job):
     status = blue("STOPPED")
     if not job.is_enabled():
         status = red("DISABLED")
     if job.is_running():
         status = green("RUNNING")
     return status
예제 #19
0
파일: base.py 프로젝트: bcattle/cheesegrate
    def transform_model(self, model_klass, filename=None, factories=None):
        self.factories = factories

        if filename:
            self.filename = filename
        else:
            self.filename = self.get_filename_for_klass(model_klass)
        # If the filename exists, prompt to overwrite
        if not self.overwrite:
            if os.path.isfile(self.filename):
                char = raw_input('File "%s" exists. Overwrite? [Y]/n: ' %
                                 self.filename)
                if char != 'Y' and char != '':
                    sys.exit(0)
        self.file = open(self.filename, 'w')

        # Generate the output
        self.pre_transform(1)
        # Generate python values for the class
        obj = self.python_obj_for_klass(model_klass)
        # Run the transformation, returns string output
        transformed = self.transform_obj(obj)
        self.file.write(transformed)
        self.post_transform(1)
        self.file.write('\n')
        self.file.close()
        self.post_process()
        print '%s generated %s' % (green('--'), self.filename)
예제 #20
0
 def debug(self, action_name, bindings_string):
     """Test execution of the rule associated with the action name, given the binding string."""
     rule = self.rule_by_action_name(action_name=action_name)
     if not rule:
         raise Exception(
             f"Couldn't find rule with action name '{action_name}'")
     bindings = {}
     for binding in bindings_string.replace(', ', ',').split(','):
         role_name, entity_name = binding.split('=')
         entity = self.entity_by_name(entity_name=entity_name)
         if not entity:
             raise Exception(f"Couldn't find entity named '{entity_name}'")
         bindings[role_name] = entity
     config.VERBOSITY = 3
     print(
         utils.green(f"\n\nTesting rule ${action_name} with debugging on."))
     if self._triggers(rule=rule, bindings=bindings):
         print("  All preconditions hold!")
         print(f"  Testing rule probability ({rule.probability})")
         if random.random() < rule.probability:
             print("  Triggered rule!")
             print(
                 "    But I'm not executing it, because this is for debugging only."
             )
             self._bind_optional_roles(rule=rule, bindings=bindings)
         else:
             print(f"  Did not trigger rule (probability not met)")
         return
예제 #21
0
  def open(self):
    os.system("clear")
    print blue("Welcome to ") + yellow(self.bank.name)
    print blue("========================\n\n")

    while True:
      print green("Please choose one of the action:")
      print red("1. Register\n"
                " 2. Login\n\n")
      option = int(raw_input(yellow("I want to: ")))
      if option == 1:
        self.register()
      elif option == 2:
        self.login()
      else:
        print red("I dont't understand you! Please repeat")
예제 #22
0
파일: base.py 프로젝트: bcattle/cheesegrate
    def transform_model_array(self,
                              model_klass,
                              n,
                              filename=None,
                              factories=None):
        self.factories = factories

        if filename:
            self.filename = filename
        else:
            self.filename = self.get_plural_filename_for_klass(model_klass)
        self.file = open(self.filename)

        # Generate the output
        self.pre_transform(n)
        for i in range(n):
            # Set a counter variable we can use if we need to
            self.model_index = i
            # Generate python values for the class
            obj = self.python_obj_for_klass(model_klass)
            # Run the transformation, returns string output
            transformed = self.transform_obj(obj)
            if i < n - 1:
                transformed += ',\n'
            self.file.write(transformed)
        self.post_transform(n)
        self.file.write('\n')
        self.file.close()
        self.post_process()
        print '%s generated %s' % (green('--'), self.filename)
예제 #23
0
파일: base.py 프로젝트: bcattle/cheesegrate
    def transform_model(self, model_klass, filename=None, factories=None):
        self.factories = factories

        if filename:
            self.filename = filename
        else:
            self.filename = self.get_filename_for_klass(model_klass)
        # If the filename exists, prompt to overwrite
        if not self.overwrite:
            if os.path.isfile(self.filename):
                char = raw_input('File "%s" exists. Overwrite? [Y]/n: ' % self.filename)
                if char != 'Y' and char != '':
                    sys.exit(0)
        self.file = open(self.filename, 'w')

        # Generate the output
        self.pre_transform(1)
        # Generate python values for the class
        obj = self.python_obj_for_klass(model_klass)
        # Run the transformation, returns string output
        transformed = self.transform_obj(obj)
        self.file.write(transformed)
        self.post_transform(1)
        self.file.write('\n')
        self.file.close()
        self.post_process()
        print '%s generated %s' % (green('--'), self.filename)
예제 #24
0
파일: base.py 프로젝트: bcattle/cheesegrate
    def transform_model_array(self, model_klass, n, filename=None, factories=None):
        self.factories = factories

        if filename:
            self.filename = filename
        else:
            self.filename = self.get_plural_filename_for_klass(model_klass)
        self.file = open(self.filename)

        # Generate the output
        self.pre_transform(n)
        for i in range(n):
            # Set a counter variable we can use if we need to
            self.model_index = i
            # Generate python values for the class
            obj = self.python_obj_for_klass(model_klass)
            # Run the transformation, returns string output
            transformed = self.transform_obj(obj)
            if i < n - 1:
                transformed += ',\n'
            self.file.write(transformed)
        self.post_transform(n)
        self.file.write('\n')
        self.file.close()
        self.post_process()
        print '%s generated %s' % (green('--'), self.filename)
예제 #25
0
 def save_job_to_file(self, ext="yaml"):
     try: os.makedirs(self.options["output_dir"])
     except: pass
     file = os.path.join(self.options["output_dir"], self.job["job_name"] + "." + ext)
     with open(file, 'w') as f:
         f.write(self.job_template.render(self.job))
     print(green("File saved to %s" % file))
예제 #26
0
파일: __init__.py 프로젝트: nfoonf/fabsetup
 def INIT():
     '''Init repo `fabsetup_custom` with custom tasks and config.'''
     # decorator @needs_repo_fabsetup_custom makes the job
     print(green('Initialization finished\n'))
     print('List available tasks: ' + blue('fab -l'))
     print(' '.join([
         'Show details of a task: `fab -d <task>`, eg.:',
         blue('fab -d setup_webserver'),]))
예제 #27
0
 def process_tick_rsi(self, tick, last_row):
     rsiok = (last_row['RSI'] > 70)
     self.log('%s(%.1f > %f)' %
              (green('rsiok') if rsiok else red('rsiko'),
               last_row['RSI'], 70))
     if rsiok:
         self.sell(tick)
     else:
         self.set_stop(last_row['ATR_STP'])
예제 #28
0
    def print(self, n=-1, highlight_rows=None):
        if highlight_rows is None:
            highlight_rows = []
        elif type(highlight_rows) == int:
            highlight_rows = [highlight_rows]

        if len(self.rows) == 0:
            print(green(join(self.head, "    ")))
            print("(empty)")
            print()
        else:
            def get_col_width(lst):
                return max(list(map(lambda x: len(str(x)), lst)))

            col_width_list = list(map(lambda col: get_col_width(self[col]), self.head))

            delta_list = []
            for i in range(len(self.head)):
                delta = col_width_list[i] - len(self.head[i])
                delta_list.append(delta)

            head = ""
            for index, col_name in enumerate(self.head):
                head += col_name
                head += " " * max(delta_list[index] + 2, 2)
            print(green(head))

            i = 0
            for r in self.rows:
                if i == n:
                    break
                else:
                    i += 1
                _row = ""
                for j in range(len(self.head)):
                    head_len = len(self.head[j] + " " * max(delta_list[j] + 2, 2))
                    space_num = head_len - len(str(r[j]))
                    _row += str(r[j]) + " " * space_num
                if i - 1 in highlight_rows:
                    print(yellow(_row))
                else:
                    print(_row)
            print()
        return self
예제 #29
0
  def register(self):
    print "\n\n"
    username = raw_input(green("username: "******"password: "******"db/clients.txt", "ab+") as f:
      clients = f.read()
      if "%s:" % username in clients:
        print red("Username already taken")
        return

      f.write("%s:%s\n" % (username, sha1(password).hexdigest()))
      initial_deposit = raw_input(green("Initial deposit: "))
      with open("clients/%s" % sha1(username).hexdigest(), "w") as g:
        g.write(initial_deposit)

    print green("Succesfully register!")
    self.user = username
    self.start()
예제 #30
0
 def job_list(self):
     print(blue('Fetching job list for %s...' % self.url))
     table_data = [['Name', 'Status', 'Url']]
     for job_name, job_instance in self.server.get_jobs():
         table_data.append([
             job_instance.name,
             green('RUNNING') if job_instance.is_running() else
             blue('STOPPED'), job_instance.url
         ])
     format_data(table_data)
     print("Jobs found: ", len(self.server.get_jobs_list()))
예제 #31
0
 def counts(self):
   if self.jsonify:
     utils.to_json(self.stats["counts"])
   else:
     header, rows = ["#", "Total", "TryHackMe", "HackTheBox", "VulnHub", "OSCPlike"], []
     rows.append("___".join([x for x in [
       "%s" % (utils.green("Total")),
       "%s/%s (%s)" % (utils.green(self.stats["counts"]["ownedtotal"]), utils.green(self.stats["counts"]["totaltotal"]), utils.green("%.2f%%" % (self.stats["counts"]["pertotal"]))),
       "%s/%s (%s)" % (utils.green(self.stats["counts"]["ownedthm"]), utils.green(self.stats["counts"]["totalthm"]), utils.green("%.2f%%" % (self.stats["counts"]["perthm"]))),
       "%s/%s (%s)" % (utils.green(self.stats["counts"]["ownedhtb"]), utils.green(self.stats["counts"]["totalhtb"]), utils.green("%.2f%%" % (self.stats["counts"]["perhtb"]))),
       "%s/%s (%s)" % (utils.green(self.stats["counts"]["ownedvh"]), utils.green(self.stats["counts"]["totalvh"]), utils.green("%.2f%%" % (self.stats["counts"]["pervh"]))),
       "%s/%s (%s)" % (utils.red(self.stats["counts"]["ownedoscplike"]), utils.red(self.stats["counts"]["totaloscplike"]), utils.red("%.2f%%" % (self.stats["counts"]["peroscplike"]))),
     ]]))
     rows.append("___".join([str(x) for x in [
       utils.yellow("Windows"),
       "%s/%s (%s)" % (utils.yellow(self.stats["counts"]["ownedwindows"]), utils.yellow(self.stats["counts"]["totalwindows"]), utils.yellow("%.2f%%" % (self.stats["counts"]["perwindows"]))),
       "%s/%s (%s)" % (utils.yellow(self.stats["counts"]["ownedthmwindows"]), utils.yellow(self.stats["counts"]["thmwindows"]), utils.yellow("%.2f%%" % (self.stats["counts"]["perthmwindows"]))),
       "%s/%s (%s)" % (utils.yellow(self.stats["counts"]["ownedhtbwindows"]), utils.yellow(self.stats["counts"]["htbwindows"]), utils.yellow("%.2f%%" % (self.stats["counts"]["perhtbwindows"]))),
       "%s/%s (%s)" % (utils.yellow(self.stats["counts"]["ownedvhwindows"]), utils.yellow(self.stats["counts"]["vhwindows"]), utils.yellow("%.2f%%" % (self.stats["counts"]["pervhwindows"]))),
       "%s/%s (%s)" % (utils.yellow(self.stats["counts"]["ownedoscplikewindows"]), utils.yellow(self.stats["counts"]["oscplikewindows"]), utils.yellow("%.2f%%" % (self.stats["counts"]["peroscplikewindows"]))),
     ]]))
     rows.append("___".join([str(x) for x in [
       utils.magenta("*nix"),
       "%s/%s (%s)" % (utils.magenta(self.stats["counts"]["ownednix"]), utils.magenta(self.stats["counts"]["totalnix"]), utils.magenta("%.2f%%" % (self.stats["counts"]["pernix"]))),
       "%s/%s (%s)" % (utils.magenta(self.stats["counts"]["ownedthmnix"]), utils.magenta(self.stats["counts"]["thmnix"]), utils.magenta("%.2f%%" % (self.stats["counts"]["perthmnix"]))),
       "%s/%s (%s)" % (utils.magenta(self.stats["counts"]["ownedhtbnix"]), utils.magenta(self.stats["counts"]["htbnix"]), utils.magenta("%.2f%%" % (self.stats["counts"]["perhtbnix"]))),
       "%s/%s (%s)" % (utils.magenta(self.stats["counts"]["ownedvhnix"]), utils.magenta(self.stats["counts"]["vhnix"]), utils.magenta("%.2f%%" % (self.stats["counts"]["pervhnix"]))),
       "%s/%s (%s)" % (utils.magenta(self.stats["counts"]["ownedoscplikenix"]), utils.magenta(self.stats["counts"]["oscplikenix"]), utils.magenta("%.2f%%" % (self.stats["counts"]["peroscplikenix"]))),
     ]]))
     rows.append("___".join([str(x) for x in [
       utils.red("OSCPlike"),
       "%s/%s (%s)" % (utils.red(self.stats["counts"]["ownedoscplike"]), utils.red(self.stats["counts"]["totaloscplike"]), utils.red("%.2f%%" % (self.stats["counts"]["peroscplike"]))),
       "%s/%s (%s)" % (utils.red(self.stats["counts"]["ownedthmoscplike"]), utils.red(self.stats["counts"]["thmoscplike"]), utils.red("%.2f%%" % (self.stats["counts"]["perthmoscplike"]))),
       "%s/%s (%s)" % (utils.red(self.stats["counts"]["ownedhtboscplike"]), utils.red(self.stats["counts"]["htboscplike"]), utils.red("%.2f%%" % (self.stats["counts"]["perhtboscplike"]))),
       "%s/%s (%s)" % (utils.red(self.stats["counts"]["ownedvhoscplike"]), utils.red(self.stats["counts"]["vhoscplike"]), utils.red("%.2f%%" % (self.stats["counts"]["pervhoscplike"]))),
       utils.red(""),
     ]]))
     aligndict = {
       "#": "r",
       "Total": "l",
       "TryHackMe": "l",
       "HackTheBox": "l",
       "VulnHub": "l",
       "OSCPlike": "l",
     }
     utils.to_table(header, rows, delim="___", aligndict=aligndict)
예제 #32
0
 def process_tick_searching(self, tick, last_row):
     volok = (last_row['V'] < last_row['VMA20'])
     priceok = (tick['L'] < (last_row['BBL'] *
                             self.selling_pressure(last_row)))
     bbok = (last_row['BBW'] > self.percent)
     self.log('%s(%.2f < %.2f) %s(%s < %s) %s(%.2f > %.2f)' %
              (green('volok') if volok else red('volko'),
               last_row['V'], last_row['VMA20'],
               green('priceok') if priceok else red('priceko'),
               btc2str(tick['L']), btc2str(last_row['BBL']),
               green('bbok') if bbok else red('bbko'),
               last_row['BBW'], self.percent))
     if volok and priceok and bbok:
         self.status = 'buying'
         self.entry = last_row['L']
         self.quantity = self.amount / self.entry
         self.send_order(self.exch.buy_limit,
                         self.pair, self.quantity,
                         self.entry)
         self.log('buying %f @ %s' %
                  (self.quantity, btc2str(self.entry)))
예제 #33
0
def print_diff(dbdict, data, removes=True):

    "Print a (hopefully) human readable list of changes."

    # TODO: needs work, especially on multiline properties,
    # empty properties (should probably never be allowed but still)
    # and probably more corner cases. Also the output format could
    # use some tweaking.

    try:
        from collections import defaultdict
        import jsonpatch
        from jsonpointer import resolve_pointer, JsonPointerException

        ops = defaultdict(int)

        diff = jsonpatch.make_patch(dbdict, data)
        for d in diff:
            try:
                ptr = " > ".join(decode_pointer(d["path"]))
                if d["op"] == "replace":
                    print yellow("REPLACE:")
                    print yellow(ptr)
                    db_value = resolve_pointer(dbdict, d["path"])
                    print red(dump_value(db_value))
                    print green(dump_value(d["value"]))
                    ops["replace"] += 1
                if d["op"] == "add":
                    print green("ADD:")
                    print green(ptr)
                    if d["value"]:
                        print green(dump_value(d["value"]))
                    ops["add"] += 1
                if removes and d["op"] == "remove":
                    print red("REMOVE:")
                    print red(ptr)
                    value = resolve_pointer(dbdict, d["path"])
                    if value:
                        print red(dump_value(value))
                    ops["remove"] += 1
            except JsonPointerException as e:
                print " - Error parsing diff - report this!: %s" % e
        # # The following output is a bit misleading, removing for now
        # print "Total: %d operations (%d replace, %d add, %d remove)" % (
        #     sum(ops.values()), ops["replace"], ops["add"], ops["remove"])
        return diff
    except ImportError:
        print >> sys.stderr, ("'jsonpatch' module not available - "
                              "no diff printouts for you! (Try -d instead.)")
예제 #34
0
    def do_switch_region(self, region):
        """ Switch to a different region """
        from botosh import available_contexts

        if not self._ready:
            print error("boto has not been configured with sufficient credentials. "
                        "Please configure boto first")

        if not region:
            print error('No region provided.')

        if self.context is None:
            print error('No context provided. Please `set_context` to one of: %s' % green(', '.join(available_contexts.keys())))
        else:
            if self.context.region == region:
                return
            regions = self.context._valid_regions
            if region not in regions:
                print error('Invalid region `%s`. Please `switch_region` to one of: %s' %
                            (region, green(', '.join(regions))))
            else:
                self.context.conn = self.context.region_switcher(region)
예제 #35
0
    def get_str(self, models_by_name=None, print_name=True):
        s = ''
        if print_name:
            s = '%s : %s \t<%s>' % (red(self.name.ljust(20)), green(self.superclass.ljust(15)),
                                    blue(self.filename))
        for field in self.fields:
            s += '\n%s' % field.__repr__()

        if self.superclass != 'MTLModel' and models_by_name:
            # Also print the fields of the superclass
            s += '\n%s' % models_by_name[self.superclass].get_str(models_by_name=models_by_name,
                                                                  print_name=False)
        return s
예제 #36
0
 def send_to_lava(self):
     try:
         dev = self.get_device_status()
         if dev["status"] == "offline":
             print(red("Device seems offline, not sending the job"))
             return
     except Exception as e:
         print(red(repr(e)))
         print(red("Not sending the job"))
         return
     print("Sending to LAVA")
     job_str = self.job_template.render(self.job)
     ret = utils.get_connection(**self.options).scheduler.submit_job(job_str)
     try:
         for r in ret:
             print(green("Job send (id: %s)" % r))
             print("Potential working URL: ", "%s/scheduler/job/%s" %
                     (self.options['web_ui_address'], r))
     except:
         print(green("Job send (id: %s)" % ret))
         print("Potential working URL: ", "%s/scheduler/job/%s" %
                 (self.options['web_ui_address'], ret))
예제 #37
0
async def download_episode(session: ClientSession, name: str, link: str,
                           path: str, total_bar: tqdm, pool: asyncio.Queue):
    """Download the episode to local storage"""
    file_target = f'{path}/{name}.mp4'

    try:
        async with get_connection(
                pool):  # Limit ourself to max concurrent downloads
            if os.path.isfile(file_target):
                raise FileExistsError(f'{name} already exists in the folder')
            req_method = session.post if Servers.MP4UPLOAD in link else session.get
            async with req_method(link) as resp:
                if resp.status != 200:
                    raise RuntimeError(
                        f'Got a bad response from the server for {name}: {resp.status}'
                    )

                file_size = int(resp.headers.get('content-length'))

                with tqdm(desc=name,
                          total=file_size,
                          unit='B',
                          unit_scale=True,
                          unit_divisor=1024,
                          leave=False,
                          ncols=BAR_WIDTH) as progress_bar:

                    async with aiofiles.open(f'{path}/{name}',
                                             mode='wb') as file:
                        async for chunk, _ in ChunkTupleAsyncStreamIterator(
                                resp.content):
                            await file.write(chunk)
                            progress_bar.update(len(chunk))

                    # Mark success and wait a bit before removing the bar
                    progress_bar.set_postfix_str(green('✔️'))
                    await asyncio.sleep(5)
    except Exception as e:
        tqdm.write(red(f'Failed to download {name} : {e} ❌'))
        if DEBUG:
            tqdm.write(
                red(''.join(
                    traceback.format_exception(None, e, e.__traceback__))))
        try:
            os.remove(f'{path}/{name}')
        except FileNotFoundError:
            pass
        return False
    finally:
        total_bar.update(1)
    return True
예제 #38
0
파일: handlers.py 프로젝트: iAqu/pytinypng
    def on_post_item(self, response, **kwargs):
        input_file = kwargs.get('input_file', '')
        source = kwargs.get('source', '')

        filename = self.format_filename(input_file.replace(source, ''))
        if response.success:
            self._optimized += 1
            self._input_bytes += response.input_size
            self._output_bytes += response.output_size
            print("%s %16s %37s" % (filename, green("OK"),
                                    response.output_ratio))
        else:
            self._failed += 1
            print("%s %18s %30s" % (filename, red("FAIL"), "-"))
예제 #39
0
    def get_str(self, models_by_name=None, print_name=True):
        s = ''
        if print_name:
            s = '%s : %s \t<%s>' % (red(
                self.name.ljust(20)), green(
                    self.superclass.ljust(15)), blue(self.filename))
        for field in self.fields:
            s += '\n%s' % field.__repr__()

        if self.superclass != 'MTLModel' and models_by_name:
            # Also print the fields of the superclass
            s += '\n%s' % models_by_name[self.superclass].get_str(
                models_by_name=models_by_name, print_name=False)
        return s
예제 #40
0
 def process_tick_searching(self, tick, last_row):
     RSI_THRESHOLD = 30
     CORPSE_THRESHOLD = 0.2
     rsiok = (last_row['RSI'] <= RSI_THRESHOLD)
     priceok = (tick['L'] < last_row['BBL'])
     bbok = (last_row['BBW'] >= self.percent)
     volok = (last_row['V'] < last_row['VMA20'])
     if last_row['H'] == last_row['C']:
         candle_corpse = 1
     else:
         candle_corpse = ((last_row['H'] - min(last_row['C'],
                                               last_row['O'])) /
                          (last_row['H'] - last_row['L']))
     candleok = (candle_corpse <= CORPSE_THRESHOLD) or volok
     self.log('%s(%s <= %s) %s(%.1f < %f) %s(%.2f >= %.2f) '
              '%s(%.2f <= %.2f or %s %.2f < %.2f)' %
              (green('priceok') if priceok else red('priceko'),
               btc2str(tick['L']), btc2str(last_row['BBL']),
               green('rsiok') if rsiok else red('rsiko'),
               last_row['RSI'], RSI_THRESHOLD,
               green('bbok') if bbok else red('bbko'),
               last_row['BBW'], self.percent,
               green('candleok') if candleok else red('candleko'),
               candle_corpse, CORPSE_THRESHOLD,
               green('volok') if volok else red('volko'),
               last_row['V'], last_row['VMA20']))
     if rsiok and priceok and bbok and candleok:
         self.status = 'buying'
         self.entry = last_row['L']
         self.quantity = self.amount / self.entry
         self.send_order(self.exch.buy_limit,
                         self.pair, self.quantity,
                         self.entry)
         self.log('buying %f @ %s' %
                  (self.quantity, btc2str(self.entry)))
         self.middle = last_row['BBM']
         self.top = last_row['BBU']
예제 #41
0
    def do_listen(self, *args):
        """Start a server on localhost to listen connections on given port."""
        host = self._input(utils.yellow('[+] Enter the host IP > '))
        port = self._input(utils.yellow('[+] Enter the port > '))

        # Create a socket object from factory to accepts connections.
        self.__socket = SocketFactory.server(listen=host, port=port)

        # Inform user that server has started.
        print(utils.green('[*] Started a remote server on {}:{}'.format(host, port)))

        # Start to accept the incoming connections.
        self.connection_acceptor.start()

        # Set the server has started.
        self.server_started = True
예제 #42
0
 def add(self, predicate, bindings):
     """Add a new fact into the working memory."""
     try:
         fact = ' '.join(e if type(e) is str else bindings[e.name].name
                         for e in predicate.template)
     except KeyError:  # The predicate references an optional role that wasn't bound
         return
     if not fact.strip():
         return
     self.facts.add(fact)
     try:
         self._facts_by_first_character[fact[0]].add(fact)
     except KeyError:
         self._facts_by_first_character[fact[0]] = {fact}
     if config.VERBOSITY >= 2:
         print(utils.green(f"  {fact}"))
예제 #43
0
 def process_tick_nine(self, tick):
     if tick['T'].hour == 9:
         if tick['C'] >= self.midnight_price * 1.05:
             self.status = 'buying'
             self.entry = tick['C']
             self.quantity = self.amount / self.entry
             self.send_order(self.exch.buy_limit,
                             self.pair, self.quantity,
                             self.entry)
             self.log('%s %f @ %s' %
                      (green('buying'), self.quantity, btc2str(self.entry)))
         else:
             self.log('%s: %s >= %s. retrying tomorrow. %.3f' %
                      (red('no up trend'),
                       btc2str(tick['C']),
                       btc2str(self.midnight_price * 1.05),
                       self.amount))
             self.status = 'midnight'
예제 #44
0
    def do_set_context(self, context):
        """ Set/Switch to a different context """
        from botosh import available_contexts
        available_contexts_str = green(', '.join(available_contexts.keys()))

        if not self._ready:
            print error("boto has not been configured with sufficient credentials. "
                        "Please configure boto first")
        if not context or not self._ready:
            print error('No context provided. Please `set_context` to one of: %s' % available_contexts_str)
        elif context in available_contexts:
            if context not in _context_cache:
                old_region = self.context.region if self.context else None
                new_context = available_contexts[context]()
                _context_cache[context] = new_context
                new_context.context = new_context
                if old_region and old_region in new_context._valid_regions:
                    new_context.conn = new_context.region_switcher(old_region)
            _context_cache[context].cmdloop()
        else:
            print error('Invalid context `%s`. Please `set_context` to one of: %s' % (context, available_contexts_str))
예제 #45
0
파일: main.py 프로젝트: Ronserruya/Kissy
async def run(anime_url: str) -> None:
    print("Trying to bypass cloudfront protection...")
    headers, cookies = bypass_cloudfront()

    async with ClientSession(headers=headers, cookies=cookies) as session:
        # Verify the cloudfront cookies work
        async with session.get(KISSANIME_URL) as resp:
            if resp.status != 200:
                print('Failed to bypass cloudfront ' + red('❌'))
                exit(1)
            print("Passed cloudfront " + green('✔️'))

            anime_url = anime_url.strip()  # Strip following whitespaces

            async with session.get(anime_url) as resp:
                page = await resp.text()

            soup = BeautifulSoup(page, features="html.parser")
            anime_title = soup.find(class_='bigChar').text.strip().replace(
                ' ', '_')
            print(f'Anime title: {anime_title.replace("_"," ")}')
            try:
                episode_links = get_episode_links(soup, 1, 12)
            except Exception as e:
                print(red("Couldn't get episode links ❌"))
                exit(1)

            if len(episode_links) == 0:
                print(red("Found 0 episodes to download ❌"))
                exit(1)

            print(f'Found {len(episode_links)} episodes to download')

            with tqdm(
                    desc='Collecting download links',
                    total=len(episode_links),
                    bar_format=
                    '{desc}: {percentage:3.0f}%|{bar}|{n_fmt}/{total_fmt} {postfix}',
                    ncols=BAR_WIDTH) as progressbar:

                try:
                    tasks = [
                        asyncio.create_task(
                            get_download_link(session, name, link,
                                              VideoQuality.P480, progressbar))
                        for name, link in episode_links.items()
                    ]
                    download_links = await asyncio.gather(
                        *tasks, return_exceptions=True)
                    links_found = sum([
                        1 for i in download_links
                        if not isinstance(i, Exception)
                    ])
                    if links_found == 0:
                        raise RuntimeError("Found no download links"
                                           )  # Goes to the except block
                except:
                    progressbar.set_postfix_str(red('❌'))
                    tqdm.write(red('Failed to collect download links ❌'))
                    exit(1)
                else:
                    progressbar.set_postfix_str(green('✔️'))

                # Prepare connection pool
                pool = asyncio.Queue()
                max_parallel_downloads = 10
                [await pool.put(i) for i in range(max_parallel_downloads)]

            try:
                os.mkdir(anime_title)
            except FileExistsError:
                pass

            with tqdm(
                    desc='Downloading episodes',
                    total=len(download_links),
                    bar_format='{desc}: |{bar}|{n_fmt}/{total_fmt} {postfix}',
                    ncols=BAR_WIDTH,
                    leave=False) as progressbar:

                tasks = [
                    asyncio.create_task(
                        download_episode(session, ep.name, ep.link,
                                         anime_title, progressbar, pool))
                    for ep in download_links if not isinstance(ep, Exception)
                ]
                results = await asyncio.gather(*tasks)
                progressbar.set_postfix_str(green('✔️'))
                await asyncio.sleep(3)

            total_downloaded = sum([1 for res in results if res])
            print(
                f'\n\nDone, downloaded {total_downloaded}/{len(episode_links)}'
                + green('✔️'))
    sys.stderr.write(utils.yellow(
        "stackoverflow is not configured; skipping...\n"
    ))
    exit(0)

# authenticate. if this gives problems exceeding request limits,
# you'll need to obtain an API key
# https://github.com/lucjon/Py-StackExchange/tree/updating-2.0#api-keys
so = stackexchange.Site(stackexchange.StackOverflow)
so.impose_throttling = True

user = so.user(config_parser.get('stackoverflow', 'user_id'))
timeline = user.timeline.fetch()
# timeline = user.timeline.fetch( # i think this is the format
#     fromdate=datetime.datetime.now(),
#     todate=datetime.datetime.now()-datetime.timedelta(days=365),
# )
writer = csv.writer(sys.stdout)
writer.writerow(['datetime', 'event'])
for event in timeline:
    date = datetime.datetime.fromtimestamp(event.json_ob.creation_date)
    detail = event.timeline_type
    if detail is None:
        detail = event.json_ob.post_type
    writer.writerow([date, detail])
    sys.stdout.flush()

sys.stderr.write(utils.green(
    "stackoverflow complete for user %s!\n" % user.display_name
))
예제 #47
0
def makeCard(template, cardname, outdir=None, verbose=False, **params):
    """Replace placeholders in template with values."""
    assert os.path.isfile(template), error("Input card '%s' does not exist!"%template)

    # CARD NAME
    if outdir:
      cardname = os.path.join(outdir,os.path.basename(cardname))
    #cardname = makeCardName(template,cardlabel,outdir,**params)

    def makeParamValue(key,value):
      """Local help function to replace placeholders in parameter values."""
      if not isinstance(value,str) or '$' not in value:
        return str(value)
      if '$SAMPLE' in value and 'SAMPLE' not in params:
        params['SAMPLE'] = getSampleName(template)
      return makeCardLabel(value,**params)

    # FIX BWCUTOFF for high lambda LQ samples
    lambd = float(params.get('LAMBDA',0))
    mass  = float(params.get('MASS',0))
    # if 'LQ' in template and 'BWCUTOFF' not in params and lambd>=1.5 and mass>0:
    #   params['BWCUTOFF'] = computeBWCutoff(template,mass,lambd)
    #   print ">>> computed bwcutoff=%s for mass=%s, lambda=%s"%(params['BWCUTOFF'],mass,lambd)

    # PRINT
    ###print ">>> "+'-'*85
    ###print ">>> template    = %s"%template
    ###print ">>> cardname    = '%s'"%cardname
    ###print ">>> params      = %s"%params
    ###print ">>> "+'-'*85

    # REPLACE
    if verbose:
      print ">>> replacing in '%s'..."%(green(template))
    else:
      print ">>> writing '%s'..."%(green(os.path.basename(cardname)))
    lines = [ ]
    with open(template,'r') as file:
      for i, line in enumerate(file.readlines(),1):
        linenum = "L%d:"%i
        if '$' in line:
          for key in parampattern.findall(line):
            if key in params:
              value   = makeParamValue(key,params[key])
              pattern = '$'+key
              line    = line.replace(pattern,value)
              print ">>>   %-4s replacing '%s' -> '%s'"%(linenum,pattern,value)
            else:
              print ">>>   %-4s Found no given value for '$%s'"%(linenum,key)
          for pattern, key, value in defaultpattern.findall(line):
              value = makeParamValue(key,params.get(key,value))
              line  = defaultpattern.sub(value,line)
              print ">>>   %-4s replacing '%s' -> '%s'"%(linenum,pattern,value)+("" if value in params else " (default)")
        lines.append(line)

    # WRITE
    with open(cardname,'w') as file:
      for line in lines:
        file.write(line)
    if verbose:
      print '>>> written file "%s"'%(green(cardname))
      print ">>> "+'-'*85
예제 #48
0
# third party
from github import Github

# local
import utils

# authenticate to the API
config_parser = utils.get_config_parser()
if not config_parser.has_section('github'):
    sys.stderr.write(utils.yellow(
        "github is not configured; skipping...\n"
    ))
    exit(0)
api = Github(
    config_parser.get("github", "username"),
    config_parser.get("github", "password"),
)

# get all of the events for the authenticated user
writer = csv.writer(sys.stdout)
writer.writerow(['datetime', 'event'])
user = api.get_user(config_parser.get("github", "username"))
for event in user.get_events():
    writer.writerow([event.created_at, event.type])
    sys.stdout.flush()

sys.stderr.write(utils.green(
    "github complete!\n"
))
예제 #49
0
    def run(self, platform, precision=None, devices=None,
            use_dispersion_correction=True):
        """
        Runs the test on the given platform with the given precision model.

        Parameters
        ----------
        platform : str
            Name of the OpenMM platform to use (CPU, Reference, CUDA, or OpenCL)

        precision : str
            Precision model to use for CUDA or OpenCL (single, double, or mixed)

        devices : int or tuple of ints
            Which GPUs to run on (a tuple will run in parallel)
        """
        if not platform in ('CPU', 'Reference', 'CUDA', 'OpenCL'):
            raise ValueError('Platform %s not recognized.' % platform)
        # Define our platform and our platform properties
        plat = mm.Platform.getPlatformByName(platform)
        properties = None
        if platform == 'CUDA':
            if not precision in ('mixed', 'double', 'single'):
                raise ValueError('You must set the precision to single, '
                                 'double, or mixed for the CUDA platform.')
            properties = dict(CudaPrecision=precision)
            if devices is not None:
                properties['CudaDeviceIndex'] = str(devices)
        elif platform == 'OpenCL':
            if not precision in ('mixed', 'double', 'single'):
                raise ValueError('You must set the precision to single, '
                                 'double, or mixed for the CUDA platform.')
            properties = dict(OpenCLPrecision=precision)
            if devices is not None:
                properties['OpenCLDeviceIndex'] = str(devices)

        # Create a new system with no charges so we can compare vdW and EEL
        # energies to Amber
        parmcopy = copy(self.parm)
        for i in range(len(parmcopy.parm_data['CHARGE'])):
            parmcopy.parm_data['CHARGE'][i] = 0.0
        system = parmcopy.createSystem(nonbondedCutoff=8.0*u.angstroms,
                                       nonbondedMethod=app.PME)
        system.setDefaultPeriodicBoxVectors(*self.parm.box_vectors)

        # Test serialization
        xmlsys = mm.XmlSerializer.deserialize(
                        mm.XmlSerializer.serialize(self.system)
        )

        # Loop through all systems and turn on or off the dispersion correction
        print 'Trying to set PME parameters...',
        succeeded = None
        for sysmod in (self.system, self.systemapp, system, xmlsys):
            for force in sysmod.getForces():
                if isinstance(force, mm.NonbondedForce):
                    force.setUseDispersionCorrection(use_dispersion_correction)
                    # See if we can set the PME parameters
                    try:
                        force.setPMEParameters(3.285326106/u.nanometers,
                                               60, 64, 60)
                        succeeded = True
                    except AttributeError:
                        # This version of OpenMM does not support setting PME
                        # parameters
                        succeeded = False
        if succeeded:
            print 'Changed.'
        elif succeeded is None:
            print 'No NonbondedForce detected.'
        else:
            print 'OpenMM is too old. Could not change PME parameters.'
        # Define some integrators
        dummyint1 = mm.VerletIntegrator(1.0e-6*u.picoseconds)
        dummyint2 = mm.VerletIntegrator(1.0e-6*u.picoseconds)
        dummyint3 = mm.VerletIntegrator(1.0e-6*u.picoseconds)
        dummyint4 = mm.VerletIntegrator(1.0e-6*u.picoseconds)
        # Define the contexts
        if properties is None:
            context1 = mm.Context(self.system, dummyint1, plat)
            context2 = mm.Context(system, dummyint2, plat)
            context3 = mm.Context(self.systemapp, dummyint3, plat)
            context4 = mm.Context(xmlsys, dummyint4, plat)
        else:
            context1 = mm.Context(self.system, dummyint1, plat, properties)
            context2 = mm.Context(system, dummyint2, plat, properties)
            context3 = mm.Context(self.systemapp, dummyint3, plat,
                                  properties)
            context4 = mm.Context(xmlsys, dummyint4, plat, properties)
        # Set the context positions
        context1.setPositions(self.parm.positions)
        context2.setPositions(self.parm.positions)
        context3.setPositions(self.crdapp.getPositions())
        context4.setPositions(self.parm.positions)
        # Get the energies
        eunit = u.kilocalories_per_mole
        state = context1.getState(getEnergy=True, getForces=True,
                                  enforcePeriodicBox=True)
        funit = eunit / u.angstrom
        forces = state.getForces().value_in_unit(funit)
        tote = state.getPotentialEnergy().value_in_unit(eunit)
        state = context3.getState(getEnergy=True, enforcePeriodicBox=True)
        toteapp = state.getPotentialEnergy().value_in_unit(eunit)
        state = context4.getState(getEnergy=True, enforcePeriodicBox=True)
        xmltote = state.getPotentialEnergy().value_in_unit(eunit)
        # Now get the decomposed energies from both the system and the
        # deserialized system to check that serialization and deserialization
        # behave as expected with these force objects and force groups
        state = context1.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.BOND_FORCE_GROUP)
        bonde = state.getPotentialEnergy().value_in_unit(eunit)
        state = context4.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.BOND_FORCE_GROUP)
        xmlbonde = state.getPotentialEnergy().value_in_unit(eunit)

        state = context1.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.ANGLE_FORCE_GROUP)
        anglee = state.getPotentialEnergy().value_in_unit(eunit)
        state = context4.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.ANGLE_FORCE_GROUP)
        xmlanglee = state.getPotentialEnergy().value_in_unit(eunit)

        state = context1.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.DIHEDRAL_FORCE_GROUP)
        dihede = state.getPotentialEnergy().value_in_unit(eunit)
        state = context4.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.DIHEDRAL_FORCE_GROUP)
        xmldihede = state.getPotentialEnergy().value_in_unit(eunit)

        state = context1.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.NONBONDED_FORCE_GROUP)
        nonbe = state.getPotentialEnergy().value_in_unit(eunit)
        state = context4.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.NONBONDED_FORCE_GROUP)
        xmlnonbe = state.getPotentialEnergy().value_in_unit(eunit)

        state = context2.getState(getEnergy=True, enforcePeriodicBox=True,
                                  groups=2**self.parm.NONBONDED_FORCE_GROUP)
        vdwe = state.getPotentialEnergy().value_in_unit(eunit)

        eele = nonbe - vdwe
        # Now get the sander forces and compare them
        traj = netcdf_file(get_fn('sander_pme.nc'), 'r')
        sander_forces = traj.variables['forces'][0]
        maxdif = [abs(ofrc-sfrc)
                  for ofrc, sfrc in zip(forces[0], sander_forces[0])]
        maxrel = [abs(ofrc-sfrc)/sfrc
                  for ofrc, sfrc in zip(forces[0], sander_forces[0])]
        avgdif = [0, 0, 0]
        avgrel = [0, 0, 0]
        n = 0
        for ofrcs, sfrcs in zip(forces, sander_forces):
            for i, sfrc in enumerate(sfrcs):
                ofrc = ofrcs[i]
                dif = abs(ofrc-sfrc)
                rel = dif/sfrc
                maxdif[i] = max(maxdif[i], dif)
                maxrel[i] = max(maxrel[i], rel)
                avgdif[i] += dif
                avgrel[i] += rel
            n += 1
        avgdif = [x/n for x in avgdif]
        avgrel = [x/n for x in avgrel]
        # The sander energies are:
# Etot   =    -69285.4160  EKtot   =         0.0000  EPtot      =    -69285.4160
# BOND   =       404.9439  ANGLE   =      1003.4499  DIHED      =      2231.7367
# 1-4 NB =       440.7084  1-4 EEL =      3818.2959  VDWAALS    =      8271.5191
# EELEC  =    -85456.0701  EHBOND  =         0.0000  RESTRAINT  =         0.0000
        sander = dict(bond=404.9439, angle=1003.4499, dihedral=2231.7367,
                      vdw=8271.5191+440.7084, eel=-85456.0701+3818.2959,
                      total=-69285.4160)
        if not use_dispersion_correction:
            # Without the long-range dispersion correction, VDWAALS = 8943.8420
            sander['total'] -= sander['vdw']
            sander['vdw'] = 8943.8420 + 440.7084
            sander['total'] += sander['vdw']
        bonddif = bonde - sander['bond']
        angledif = anglee - sander['angle']
        diheddif = dihede - sander['dihedral']
        vdwdif = vdwe - sander['vdw'] # includes 1-4 also
        eeldif = eele - sander['eel'] # Includes 1-4 also
        totaldif = tote - sander['total']
        appdif = tote - toteapp
        print 'Energy differences compared to sander/Amber (kcal/mol)'
        print '             Absolute     Relative    sander'
        print '------------------------------------------------------'
        print 'Bond     =', colorize_error(bonddif), \
              colorize_error(bonddif/sander['bond'], 1e-6), \
              '%12.4f'%sander['bond']
        print 'Angle    =', colorize_error(angledif), \
              colorize_error(angledif/sander['angle'], 1e-6), \
              '%12.4f'%sander['angle']
        print 'Dihedral =', colorize_error(diheddif), \
              colorize_error(diheddif/sander['dihedral'], 1e-6), \
              '%12.4f'%sander['dihedral']
        if use_dispersion_correction:
            # The dispersion correction in Amber neglects the repulsive part of
            # the correction, but OpenMM does not. Therefore, when we are using
            # the dispersion correction we should allow for a slightly larger
            # energy difference.
            print 'vdWaals  =', colorize_error(vdwdif, 1.0), \
                   colorize_error(vdwdif/sander['vdw'], 1e-4), \
                   '%12.4f'%sander['vdw']
        else:
            print 'vdWaals  =', colorize_error(vdwdif, 1e-2), \
                   colorize_error(vdwdif/sander['vdw'], 1e-6), \
                   '%12.4f'%sander['vdw']
        print 'Elec     =', colorize_error(eeldif, 4e0), \
               colorize_error(eeldif/sander['eel'], 1e-3), '%12.4f'%sander['eel']
        print 'Total    =', colorize_error(totaldif, 4e0), \
               colorize_error(totaldif/sander['total'], 1e-3), \
               '%12.4f'%sander['total']
        print ''
        print 'Difference b/w ParmEd and OpenMM App layer'
        print '------------------------------------------'
        print 'Total    =', colorize_error(appdif, tolerance=5e-3)
        print ''
        print 'Difference b/w sander and OpenMM forces'
        print '---------------------------------------'
        print 'Maximum deviation = [%12s, %12s, %12s]' % colorize_list(maxdif,2e0)
        print 'Maximum rel. dev. = [%12s, %12s, %12s]' % colorize_list(maxrel,2e0)
        print 'Average deviation = [%12s, %12s, %12s]' % colorize_list(avgdif,1e-1)
        print 'Average rel. dev. = [%12s, %12s, %12s]' % colorize_list(avgrel,5e-1)

        # Now test serialization
        CUTOFF = 1e-5
        CUTOFFNB = 1e-2
        print ''
        print 'Serialization tests'
        print '-------------------'
        print 'Bond........',
        if abs(xmlbonde - bonde) < CUTOFF:
            print green('OK')
        else:
            dif = xmlbonde - bonde
            print red('off by %.4e (%f%%)' % (dif, 100*dif/(bonde or xmlbonde)))
        print 'Angle.......',
        if abs(xmlanglee - anglee) < CUTOFF:
            print green('OK')
        else:
            dif = xmlanglee - anglee
            print red('off by %.4e (%f%%)' % (dif,100*dif/(anglee or xmlanglee)))
        print 'Dihedral....',
        if abs(xmldihede - dihede) < CUTOFF:
            print green('OK')
        else:
            dif = xmldihede - dihede
            print red('off by %.4e (%f%%)' % (dif,100*dif/(dihede or xmldihede)))
        print 'Nonbonded...',
        if abs(xmlnonbe - nonbe) < CUTOFFNB:
            print green('OK')
        else:
            dif = xmlnonbe - nonbe
            print red('off by %.4e (%f%%)' % (dif,100*dif/(nonbe or xmlnonbe)))
        last_nonsubrepo_repo_root = None
        for repo_root in repo_roots.splitlines():
            repo_root = repo_root.replace(vcs_dir, '')

            # check to see if this repo is actually a
            # subrepository. only need to check the last
            # nonsubrepo_repo_root because of how `find` recursively
            # traverses the directory tree
            is_subrepo = False
            if (last_nonsubrepo_repo_root 
                and repo_root.startswith(last_nonsubrepo_repo_root)):
                is_subrepo = True

            # only extract the timestamps for non-subrepositories
            if not is_subrepo:
                sys.stderr.write(utils.green(
                    'examining hg repo at %s:%s\n' % (host, repo_root)
                ))
                last_nonsubrepo_repo_root = repo_root
                with cd(repo_root):
                    timestamps = run(
                        "hg log -u %s --template '{date|isodate}\n'" % email
                    )
                    for timestamp in timestamps.splitlines():
                        t = datetime.datetime.strptime(
                            ' '.join(timestamp.split()[:2]),
                            '%Y-%m-%d %H:%M',
                        )
                        writer.writerow([t, host, repo_root])
                    sys.stdout.flush()
예제 #51
0
 def do_list_contexts(self, ignored):
     """ List all available contexts """
     from botosh import available_contexts
     print "Available contexts:\n%s" % green('\n'.join(available_contexts.keys()))
    # The access tokens can be found on your applications's Details
    # page located at https://dev.twitter.com/apps (located 
    # under "Your access token")
    access_token = config_parser.get('twitter', 'access_token')
    access_token_secret = config_parser.get('twitter', 'access_token_secret')
    
    # authenticate and use the api object
    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_token_secret)

    api = tweepy.API(auth)
    return api

# If the authentication was successful, you should
# see the name of the account print out
api = authenticate(utils.get_config_parser())

# print out the tweet timestamps and some basic statistics about those
# tweets
writer = csv.writer(sys.stdout)
writer.writerow(["datetime", "retweets", "favorites"])
for status in tweepy.Cursor(api.user_timeline).items():
    writer.writerow([
        status.created_at, status.retweet_count, status.favorite_count
    ])

sys.stderr.write(utils.green(
    "twitter complete!\n"
))
예제 #53
0
    # directories. This traverses the directory tree recursively, so
    # subrepos will always be listed *after* their parent repositories
    vcs_dir = '.hg'
    with settings(hide('commands'), host_string=host):
        repo_roots = run("find %s -type d -name '%s'" % (directory, vcs_dir))

        # Extract commit history from these mercurial root directories that
        # correspond with the specified user email
        last_nonsubrepo_repo_root = None
        for repo_root in repo_roots.splitlines():
            repo_root = repo_root.replace(vcs_dir, '')

            # print some updates
            host_repo = ':'.join([host, repo_root])
            sys.stderr.write(utils.green(
                'examining hg repo at %s\n' % host_repo
            ))

            # check to see if this repo is actually a
            # subrepository. only need to check the last
            # nonsubrepo_repo_root because of how `find` recursively
            # traverses the directory tree
            is_subrepo = False
            if (last_nonsubrepo_repo_root 
                and repo_root.startswith(last_nonsubrepo_repo_root)):
                is_subrepo = True

            # only extract the timestamps for non-subrepositories
            if not is_subrepo:
                last_nonsubrepo_repo_root = repo_root
                with cd(repo_root):