def printPath(self, path): statePath = [] for i in range(len(path)): # print(path[i].getState().pprint_string()) statePath.append(path[i].getState()) util.pprint(statePath)
def roll(dice_spec: str) -> Tuple[int, Sequence[int]]: tracer = execution_context.get_opencensus_tracer() try: with tracer.span('initial_parse'): tracer.add_attribute_to_current_span("dice_spec", dice_spec) tree = get_parser().parse(dice_spec) except LarkError as e: raise RecognitionError( "Sorry, I couldn't understand your request") from e logging.debug("Initial parse tree:\n%s", pprint(tree)) try: tree = NumberTransformer().transform(tree) with tracer.span('dnd_knowledge'): tree = DnD5eKnowledge().transform(tree) tree = SimplifyTransformer().transform(tree) with tracer.span('crit_transform'): tree = CritTransformer().transform(tree) logging.debug("DnD transformed parse tree:\n%s", pprint(tree)) with tracer.span('final_eval'): transformer = EvalDice() tree = transformer.transform(tree) tree = SimplifyTransformer().transform(tree) except VisitError as e: # Get our nice exception out of lark's wrapper raise e.orig_exc return (tree.children[0], transformer.dice_results)
def connect(self): self.sock = socket.create_connection( (self.irc_config['server'], self.irc_config['port'])) self.fp = self.sock.makefile('rw', 0) pprint('Connected to %s:%d, registering as %s!%s (%s)' % (self.irc_config['server'], self.irc_config['port'], self.irc_config['nick'], self.irc_config['user'], self.irc_config['name'])) self.change_nick(self.irc_config['nick']) self.send('USER %s 8 * :%s' % (self.irc_config['user'], self.irc_config['name']))
def upload_dir(local, remote, dry_run=False, opts=None): env = environment() if 'ssh' in env: ssh = env['ssh'] rsync_opts = [ '--recursive', '--archive', '--compress', '--itemize-changes' ] if dry_run: rsync_opts.append('--dry-run') if state['verbose']: rsync_opts.append('--verbose') # trailing slash is important, see rsync documentation src = local + '/' abs_remote = os.path.join(ssh['document_root'], remote) dest = '{}@{}:{}'.format(ssh['user'], ssh['host'], abs_remote) args = rsync_opts + ([] if opts is None else opts) + [src, dest] # TODO rsync still prompts for the password with shell_env(RSYNC_PASSWORD=ssh['password']): fab.local('rsync {}'.format(' '.join(args))) else: ftp = env['ftp'] host = ftp_host(env) extra_opts = {'ftp_debug': 1 if state['verbose'] else 0} url = urlparse(ftp['url']) if url.scheme != 'ftp': fab.warn('non-ftp url scheme, may not be supported') abs_remote = os.path.join(url.path, remote) if not host.path.exists(abs_remote): fab.warn('remote path is missing: {}'.format(abs_remote)) if console.confirm('create missing directories?'): host.makedirs(abs_remote) local_target = FsTarget(local, extra_opts=extra_opts) remote_target = FtpTarget(path=abs_remote, host=url.netloc, username=ftp['user'], password=ftp['password'], extra_opts=extra_opts) opts = { 'force': False, # TODO 'delete_unmatched': False, 'verbose': 3, 'execute': True, 'dry_run': dry_run } s = UploadSynchronizer(local_target, remote_target, opts) try: s.run() except KeyboardInterrupt: fab.warn('aborted by user') finally: s.local.close() s.remote.close() stats = s.get_stats() pprint(stats)
def dispatch(self): while True: try: l = self.readline() except socket.timeout: pprint('Socket timeout (server not responding), quitting') self.quit(graceful=False) # don't send quit message except KeyboardInterrupt: self.quit(msg='I was sent SIGINT') else: self._handle_line(l)
def example1(): """ find all customers who never order anything. """ query = ses.query(Customer.name) \ .filter( Customer.id.notin_( ses.query(func.distinct(Order.customer_id)) ) ) pprint(query, engine)
def join(server, req, chan): if chan[0] not in ['#', '&']: server.send_privmsg(req['nick'], 'Please specify channel name correctly (missing #/& prefix)') return if chan in server.joined_channels: server.send_privmsg(req['nick'], 'I am already joined to %s' % chan) return if chan in server.pending_channel_joins: server.send_privmsg(req['nick'], 'I am already trying to join %s' % chan) return pprint('Joining channel %s at the request of %s' % (chan, req['nick'])) server.join_channel(chan, req['nick'])
def permutation1(): query = text(""" SELECT E.id as e_id, E.name as e_name, D.id as d_id, D.name as d_name FROM employee as E, department as D """) pprint(query, engine)
def experiment(full_data): fake_reviews = [ review_text for (rid, review_text, auth, sent) in full_data if auth == "Fake" ] true_reviews = [ review_text for (rid, review_text, auth, sent) in full_data if auth == "True" ] # print(len(fake_reviews)) # pprint(fake_reviews) pprint(true_reviews)
def solution(): """ find the cancellation rate of requests made by unbanned users between 2017-01-01 to 2017-01-03 """ subquery = ses.query(Attendance).filter(Attendance.date.between("2017-01-01", "2017-01-03")) query = ses.query( ses.query(subquery.filter(Attendance.is_attendance==True)), ) \ .group_by(Attendance.date) pprint(query, engine)
def main(): if len(sys.argv) < 2: print("[ERROR]: Album index not specified") sys.exit() gphoto.init() GoogleAlbums.load_albums() cache = GoogleAlbums.cache() album_list = cache['list'] idx = int(sys.argv[1]) album = album_list[idx] util.pprint(album)
def testPPrint(self): """ Test pretty-printing EBML files. """ schemaFile = './schemata/mide_ide.xml' schema = core.loadSchema(schemaFile) ebmlDoc = schema.load('./tests/SSX46714-doesnot.IDE', headers=True) util.pprint(ebmlDoc, out=open('./tests/IDE-Pretty.txt', 'wt')) xmlString = ET.tostring(util.toXml(ebmlDoc)) prettyXmlFile = open('./tests/IDE-Pretty.xml', 'wt') parseString(xmlString).writexml(prettyXmlFile, addindent='\t', newl='\n', encoding='utf-8')
def permutation2(): query = text(""" SELECT E.id as e_id, E.name as e_name, D1.id as d_id1, D1.name as d_name1, D2.id as d_id2, D2.name as d_name2 FROM employee as E, department as D1, department as D2 """) pprint(query, engine)
def play(self): self.gameState = State() while not self.gameState.game_over(): player1Action = self.player1.choose_action(self.gameState) self.gameState.execute(player1Action) util.pprint(self.gameState) if self.gameState.game_over(): break player2Action = self.player2.choose_action(self.gameState) self.gameState.execute(player2Action) util.pprint(self.gameState) return self.gameState.winner()
async def watchTicker(self, newOI: asyncio.Event): while True: try: if "watchTicker" in self.ccxt.has: self.ticker = await self.ccxt.watch_ticker(self.market) else: await asyncio.sleep(2) await self.fetchTicker() except ccxt.base.errors.ExchangeNotAvailable as err: pprint("%s: %s" % (self, err)) except: logging.exception("watchTicker unhandled exception") oi = self.getOI() if oi != self.oi: self.oi = oi newOI.set()
def visualise_pattern(data): pattern_id = data['pattern_id'] send('Loading pattern') role_pattern = db.load_role_pattern(pattern_id) pprint(role_pattern.spacy_dep_pattern) send('Generating DOT') node_attrs = role_pattern_vis.DEFAULT_NODE_ATTRS # for token in doc: # token._.plot.update(node_attrs) # token._.plot['label'] = '{0} [{1}]\n({2})'.format(token.orth_, token.i, token.tag_) graph, legend = role_pattern.to_pydot(legend=True) graph, legend = graph.to_string(), legend.to_string() dot_data = { 'graph': graph, 'legend': legend, } emit('visualise_pattern_success', dot_data)
def random_walk(self, state, n): currNode = Node(state) for _ in range(n - 1): nextNode = Node(deepcopy(currNode.state)) nextNode.setParent(currNode) childIndex = random.randint(0, len(nextNode.possibleChildStates) - 1) nextAction = nextNode.possibleChildStates[childIndex] nextNode.state.execute(nextAction) currNode.addChild(nextNode) currNode = nextNode states = get_root_traversal_states(currNode) util.pprint(states)
def solution1(): """ Not perfect solution. If seat id ends with odds number, then it doesn't work. """ query = ses.query(Seating) pprint(query, engine) query = text(""" SELECT seating.id - 1 as id, seating.student FROM seating WHERE seating.id % 2 = 0 UNION SELECT seating.id + 1 as id, seating.student FROM seating WHERE seating.id % 2 = 1 ORDER BY id """) pprint(query, engine)
def search(self, isBfs=True): goalNode = None currentDFSDepth = 0 iterations = 0 while self.open: node = self.open.pop(0) self.closed.append(node) if node.state.is_goal(): goalNode = node break if self.searchType == 'dfs': if currentDFSDepth <= self.maxDfsDepth: currentDFSDepth += 1 else: currentDFSDepth = 0 continue iterations += 1 for action in node.getPossibleActions(): newNode = deepcopy(node) newNode.state.execute(action) if newNode not in self.closed or newNode not in self.open: node.addChild(newNode) newNode.setParent(node) if self.searchType == 'bfs': self.open.append(newNode) elif self.searchType == 'dfs': self.open.insert(0, newNode) else: self.open.append(newNode) self.open.sort( key=lambda h: self.heuristic(h.state, h.depth)) if goalNode: states = get_root_traversal_states(goalNode) util.pprint(states) return iterations else: print('Search failed, unable to find goal state.') return None
def _handle_line(self, line): if len(line) == 0: pprint('Server closed connection, quitting') self.quit(graceful=False) # don't send quit message parts = line.split(' ') if parts[0][0] == ':': key = parts[1] else: key = parts[0] # special case for numeric messages if self._numeric_msg_patt.match(key): key = 'numeric_%s' % key callback = getattr(server_callbacks, key.lower(), None) if callback is not None: callback(self, parts, line) else: pprint(colored.red('Unhandled %s << %s' % (key, line)))
def WEAPON(self, name) -> Tree: tracer = execution_context.get_opencensus_tracer() weapon = self.find_named_object(name, WEAPONS) dice_spec = weapon["damage_dice"] with tracer.span('parse_weapon'): tracer.add_attribute_to_current_span("name", name) tracer.add_attribute_to_current_span("dice_spec", dice_spec) tree = get_parser().parse(dice_spec, start="sum") logging.debug("weapon %s has damage dice %s parsed as:\n%s", name, dice_spec, pprint(tree)) return tree
def solution1(): """ Not perfect solution. If seat id ends with odds number, then it doesn't work. """ query = ses.query(Employee) pprint(query, engine) query = ses.query(Department) pprint(query, engine) query = text(""" SELECT employee.department_id, COUNT(*) FROM employee GROUP BY employee.department_id """) query = text(""" SELECT D.id as department_id, E1.name as employee_name, E1.salary as salary1, E2.salary as salary2 FROM department D, employee E1, employee E2 """) """ WHERE D.id = E1.department_id AND E1.department_id = E2.department_id AND E1.salary <= E2.salary group by D.id, E1.name having count(distinct E2.salary) <= 3 order by D.name, E1.salary desc """ pprint(query, engine)
def example(): """ 每个movie都有若干个genre. 我们想要统计对于每个genre, 所有包含这个genre的movie, 平均有多少个genre. """ query = text(""" SELECT genre.name, result.avg_genre_count FROM ( SELECT movie_and_genre.genre_id, AVG(genre_count_each_movie.genre_count) as avg_genre_count FROM movie_and_genre JOIN ( SELECT movie_and_genre.movie_id, COUNT(*) as genre_count FROM movie_and_genre GROUP BY movie_and_genre.movie_id ) as genre_count_each_movie ON movie_and_genre.movie_id = genre_count_each_movie.movie_id GROUP BY movie_and_genre.genre_id ) as result JOIN genre ON result.genre_id = genre.id """) pprint(query, engine)
def spell_default(self, spell: Mapping[str, Any]) -> Tree: tracer = execution_context.get_opencensus_tracer() m = re.search(r"\d+d\d+( \+ \d+)?", spell["desc"]) if not m: raise ImpossibleSpellError( f"Sorry, I couldn't find the damage dice for %s" % spell["name"]) with tracer.span('parse_spell'): tracer.add_attribute_to_current_span("name", spell["name"]) tracer.add_attribute_to_current_span("dice_spec", m.group(0)) tree = get_parser().parse(m.group(0), start="sum") logging.debug("spell %s has base damage dice %s parsed as:\n%s", spell["name"], m.group(0), pprint(tree)) return tree
def spell(self, spell: Mapping[str, Any], level: int) -> Tree: tracer = execution_context.get_opencensus_tracer() spell_tree = self.spell_default(spell) if level < spell["level_int"]: raise ImpossibleSpellError( "Sorry, %s is level %d, so I can't cast it at level %d" % (spell["name"], spell["level_int"], level)) m = re.search(r"\d+d\d+( + \d+)?", spell["higher_level"]) if not m: raise ImpossibleSpellError( "Sorry, I could't determine the additional damage dice for %s" % spell["name"]) with tracer.span('parse_spell_additional'): tracer.add_attribute_to_current_span("name", spell["name"]) tracer.add_attribute_to_current_span("dice_spec", m.group(0)) higher_level_tree = get_parser().parse(m.group(0), start="sum") logging.debug( "spell %s has damage dice %s per extra level parsed as:\n%s", spell["name"], m.group(0), pprint(higher_level_tree)) for level in range(level - spell["level_int"]): spell_tree = Tree('add', [spell_tree, higher_level_tree]) logging.debug("spell %s has complete parsed as:\n%s", spell["name"], pprint(spell_tree)) return spell_tree
def solution1(): """ This solution use trick of permutation. """ query = text(""" SELECT D.name as department, E1.name as employee, E1.salary as salary FROM department D, employee E1, employee E2 WHERE D.id = E1.department_id AND E1.department_id = E2.department_id AND E1.salary <= E2.salary GROUP BY D.id, E1.name HAVING COUNT(DISTINCT E2.salary) <= 3 ORDER BY D.name, E1.salary DESC """) pprint(query, engine)
def example(): """ join Team.id column twice. """ home = aliased(Team) away = aliased(Team) query = ses.query(Team) pprint(query, engine) query = ses.query(Match) pprint(query, engine) query = ses.query( Match.id, Match.home_team_id, home.name.label("home_team"), Match.away_team_id, away.name.label("away_team"), ) \ .join(home, Match.home_team_id == home.id) \ .join(away, Match.away_team_id == away.id) pprint(query, engine) print(query)
def execute(self, action): char = self.get(action.x, action.y) self.put(action.x2, action.y2, char) self.put(action.x, action.y, Cell.EMPTY) return self def pprint_string(self): top_bottom = util.color_string('+' + ('-' * self.size) + '+', fore='blue', back='blue') side = util.color_string('|', fore='blue', back='blue') s = top_bottom + '\n' for y in range(self.size): s += side + ''.join([Cell.color(c) for c in self.row(y)]) + side + '\n' return s + top_bottom if __name__ == '__main__': cmd = util.get_arg(1) if cmd: state = State(util.get_arg(2)) if cmd == 'print': util.pprint(state) elif cmd == 'goal': print(state.is_goal()) elif cmd == 'actions': for action in state.actions(): print(action)
def dfs(self, node): util.pprint(node.getState()) self._search("dfs", node)
def a_star(self, node, heuristic): util.pprint(node.getState()) self._search("a*", node, heuristic)
#!/usr/local/bin/python3.9 # coding: UTF-8 import sys # ty from util import pprint, execute from const import PARSERS, REQUESTERS url = sys.argv[1] res = {} for key, binary in PARSERS.items(): lang, libname = key.split('.', 1) r = execute(lang, binary, url, base='bin/parser/') res[key] = r pprint(res) res = {} for key, binary in REQUESTERS.items(): lang, libname = key.split('.', 1) r = execute(lang, binary, url, base='bin/requester/') res[key] = r pprint(res)
def quit(self, graceful=True, msg='Goodbye'): if graceful: self.send('QUIT :%s' % msg) pprint('Quitting (%s)' % msg) exit(0)
employee_list = [ Employee( id=id, name=rnd.name(), salary=random.randint(50000, 80000), department_id=random.randint(1, n_department), ) for id in range(1, 1 + n_employee) ] ses.add_all(department_list) ses.add_all(employee_list) ses.commit() query = ses.query(Employee) pprint(query, engine) query = ses.query(Department) pprint(query, engine) def permutation1(): query = text(""" SELECT E.id as e_id, E.name as e_name, D.id as d_id, D.name as d_name FROM employee as E, department as D
def print_env(): pprint(environment())
def assertTreeEqual(self, a, b): self.assertEqual( a, b, "Trees are not equal\n" "Tree a:\n%s\nTree b:\n%s" % (pprint(a), pprint(b)))
url = url + suffix if args.params: params = {} for s in args.params: i = s.index('=') name = s[:i] value = s[i + 1:] params[name] = value try: init(app_only) req = build_request(url, method, params, app_only) response = urllib2.urlopen(req) if is_stream: len_str = '' while True: c = response.read(1) if c in string.digits: len_str += c if len_str and c == '\n': length = int(len_str) len_str = '' util.pprint(response.read(length)) else: util.pprint(response.read()) except urllib2.HTTPError, e: print >> sys.stderr, '%s %s' % (e.code, e.msg) print >> sys.stderr, e.fp.read() traceback.print_exc()
p = json.loads(data, object_hook=lambda d: SimpleNamespace(**d)) print(f"{p.name}, {p.aperture}") # ------------------------------------- print("# ------------------------------------") google_cache = { 'album_ids': { "albumid01": { 'title': "album id title 01", 'image_count': 21 }, "albumid02": { 'title': "album id title 02", 'image_count': 22 } }, 'summary': { 'album_count': 50, 'image_count': 49330 } } data = json.dumps(google_cache, sort_keys=True, indent=4, default=lambda o: o.__dict__) google_cache_avatar = json.loads(data, object_hook=lambda d: SimpleNamespace(**d)) # util.pprint(google_cache_avatar.album_ids.albumid01) util.pprint(google_cache_avatar)
def process_instance(context, xfinst, xform_path): inst = util.strip_namespaces(et.fromstring(xfinst)) return convert_odm(context, util.xmlfile(xfinst), load_source(xform_path=xform_path)) def load_source(xform_path=None, crf_path=None): if not xform_path and not crf_path: return None with open(xform_path or crf_path) as f: if xform_path: return et.parse(f).getroot() else: return convert_xform(f) if __name__ == "__main__": parser = OptionParser() parser.add_option("-x", "--xform", dest="xform", help="source xform", metavar="FILE") parser.add_option("-f", "--crf", dest="crf", help="source CRF", metavar="FILE") (options, args) = parser.parse_args() inst = (sys.stdin if args[0] == '-' else open(args[0])) submission = convert_odm(inst, load_source(options.xform, options.crf)) print util.dump_xml(submission['odm'], pretty=True) del submission['odm'] util.pprint(submission)
def __init__(self, server='localhost', port=6667, nick='ubot', command_prefix='!', authorized_users=set(), channels_to_join=set(), rejoin_on_kick=True): self.irc_config = { 'server': server, 'port': port, 'nick': nick, 'user': nick, 'name': 'ubot v%s' % VERSION, 'command_prefix': command_prefix, 'authorized_users': authorized_users, 'channels_to_join': channels_to_join, 'rejoin_on_kick': rejoin_on_kick, } self.init_callbacks() pprint('ubot v%s starting up' % VERSION) pprint('Authorized users of this bot are (send bot !authlist for on-network list):') for i in self.irc_config['authorized_users']: pprint(i, indent=4) pprint('Legend for colour coded text:') pprint('Bot messages (white)', indent=4) pprint(colored.cyan('Messages sent to server (cyan)'), indent=4) pprint(colored.red('Unimplemented responses (red)'), indent=4) pprint(colored.yellow('Private messages (yellow)'), indent=4)
def ibw2stdout(filename): '''Dump the contents of an *.ibw to stdout''' data = loadibw(filename) util.pprint(data)
def send(self, line): pprint(colored.cyan('>> %s' % line)) print(line, end='\r\n', file=self.fp)
def play(self): while True: state = self.current_state print(state) turn = self.player_turn #print(turn) self.result = state.game_over() result = self.result print("Game done?: ", end='') print(result) if self.result == "X": print("Player 1: " + str(sys.argv[1]) + " win the game") self.initialize_game() return elif self.result == "O": print("Player 2: " + str(sys.argv[2]) + " win the game") self.initialize_game() return else: print("Lets start!") if self.player_turn == 'X': #print("Start with X") while self.player_turn == 'X': if sys.argv[1] == 'human': import human run_action = human.HumanPlayer.choose_action(state) print(run_action) for i, action in enumerate(state.actions('X')): #print("looping") if str(i) == run_action: #print(action) state.execute(action) util.pprint(state) self.player_turn = "O" if sys.argv[1] == 'random': import agent run_action = agent.RandomPlayer.choose_action( state) print(run_action) #print(type(run_action)) for i, action in enumerate(state.actions('X')): #print("looping") if i == run_action: #print(action) state.execute(action) util.pprint(state) self.player_turn = "O" #print("O turn") #print(self.player_turn) while self.player_turn == 'O': if sys.argv[2] == 'human': import human run_action = human.HumanPlayer.choose_action(state) print(run_action) for i, action in enumerate(state.actions('O')): #print("looping") if str(i) == run_action: #print(action) state.execute(action) util.pprint(state) self.player_turn = "X" if sys.argv[2] == 'random': import agent run_action = agent.RandomPlayer.choose_action( state) print(run_action) #print(type(run_action)) for i, action in enumerate(state.actions('O')): #print("looping") if i == run_action: #print(action) state.execute(action) util.pprint(state) self.player_turn = "X"
url = url + suffix if args.params: params = {} for s in args.params: i = s.index('=') name = s[:i] value = s[i+1:] params[name] = value try: init(app_only) req = build_request(url, method, params, app_only) response = urllib2.urlopen(req) if is_stream: len_str = '' while True: c = response.read(1) if c in string.digits: len_str += c if len_str and c == '\n': length = int(len_str) len_str = '' util.pprint(response.read(length)) else: util.pprint(response.read()) except urllib2.HTTPError, e: print >>sys.stderr, '%s %s' % (e.code, e.msg) print >>sys.stderr, e.fp.read() traceback.print_exc()
async def main(): signal.signal(signal.SIGINT, bye) signal.signal(signal.SIGTERM, bye) global conf settings = S() # init ccxt exchange exchange = newExchange(conf) conf["market"] = exchange.market pprint("tracking OI levels for {}:{}".format(exchange.name, exchange.market)) newOI = asyncio.Event() asyncio.create_task(exchange.watchTicker(newOI)) await newOI.wait() newOI.clear() t0 = time.time() oi0 = exchange.getOI() pRef = exchange.getPrice() pmin = pRef pmin1 = pRef pmax = pRef pmax1 = pRef # will track global delta on custom duration (S.alertInterval) oiAlerts = OIDeltas(0, settings, S.alertInterval) oiAlertT0 = time.time() pAlert = pRef oiAlertCircles = "" # main data dicts mapping a price range with an OIDelta total = {} # stores OIDeltas for the whole program runtime session = { } # partial OIDeltas, works in the same way as total, but is reset every profileTicks i = 0 while True: try: # fetch ticker data & calculate delta oi (oi - previousOI) await newOI.wait() newOI.clear() oi = exchange.getOI() delta = oi - oi0 oi0 = oi # get ticker price, store min/max for session, and calculate price range p pReal = exchange.getPrice() pmin = min(pmin, pReal) pmin1 = min(pmin1, pReal) pmax = max(pmax, pReal) pmax1 = max(pmax1, pReal) p = priceRange(pReal) # if p != p0: # print() p0 = p # check that OIDelta exists for current price range in our data dicts, if not create them if not p in total: total[p] = OIDeltas(p, settings, settings.d1, settings.d2, 0) if not p in session: session[p] = OIDeltas(p, settings, settings.d1, settings.d2, 0) # retreive OIDeltas object for the current price range, for both dicts oidTotal = total[p] oidSession = session[p] # add current delta tasks = [ asyncio.create_task(oidTotal.add(delta)), asyncio.create_task(oidSession.add(delta)), asyncio.create_task(oiAlerts.add(delta)), ] await asyncio.gather(*tasks) # print current level pprint("{} OI: {:>16,.0f}".format(oidTotal, oi)) # increment main tick i += 1 # check if we reached alert threshold f = oiAlerts.frames[S.alertInterval] if math.fabs(f.value) >= S.alertThreshold: # circles mic-mac blue_diamond = "🔹" orange_diamond = "🔸" if f.value > 0: if orange_diamond in oiAlertCircles: oiAlertCircles = "" oiAlertCircles += blue_diamond else: if blue_diamond in oiAlertCircles: oiAlertCircles = "" oiAlertCircles += orange_diamond alertsDuration = time.time() - oiAlertT0 alertsDuration = min(alertsDuration, S.alertInterval) msg = "*{}:{}* - {:.1f} (*{:+,.1f}*)\noi: {:+,.0f} in {:.0f}s {}\nmin/max: {:.1f}/{:.1f} ({:.1f})".format( conf["exchange"], conf["market"], pReal, pReal - pAlert, f.value, alertsDuration, oiAlertCircles, pmin, pmax, pmax - pmin, ) pprint("alert reached") print(msg + "\n") if alertsDuration <= S.alertInterval: try: telegram.sendMessage(msg) except Exception as err: pprint(err) # reset alert data await oiAlerts.cancel() oiAlertT0 = time.time() f.value = 0 pAlert, pRef, pmax, pmin = pReal, pReal, pReal, pReal # check if current profile session is elapsed or not if i % S.profileTicks == 0: # current session is elapsed, S.profileTicks reached, so we print profile summary print() pprint("profile for %s:%s, last %.0f minutes:" % ( exchange.name, exchange.market, (time.time() - t0) / 60, )) t0 = time.time() totalDelta = 0 for p, oid in sorted(session.items(), reverse=True): print(" {}".format( oid.repr(last=False, ignore=(settings.d1, settings.d2)))) totalDelta += oid.frames[0].value print( "\n ticker: {} ({}) min/max: {:.1f}/{:.1f} (<> {}) oi: {}\n" .format( pReal, coloredValue(pReal - pRef, 1, threshold=50, padSize=4, decimals=1, plus=True), pmin, pmax, coloredValue(pmax - pmin, 1, threshold=100, padSize=4, decimals=1), coloredValue(totalDelta, S.interval * S.profileTicks, threshold=S.threshold), )) # reset current profile summary session session = {} pRef, pmax, pmin = pReal, pReal, pReal except: logging.exception("unhandled exception")
import context context.set_context() import util import tasks dups = tasks.find_duplicate_pics_folder_images("p:\\pics") util.pprint(dups)
# Files to use in this example schemaFile = './schemata/mide_ide.xml' ebmlFile1 = './tests/example-ebml.ide' prettyXml = './tests/example-pretty.txt' # load the schema to use with these files. This creates an object that is used # to parse EBML files. schema = core.loadSchema(schemaFile) # load the ebml file into memory ebmlDoc1 = schema.load(ebmlFile1, headers=True) # load the file through the schema # save the ebml to an easily readable format pprint(ebmlDoc1, out=open(prettyXml, 'wt')) # ======================================= # Get specific data from an EBML file # ======================================= # Files to use in this example schemaFile = './schemata/mide_ide.xml' ebmlFile1 = './tests/example-ebml.ide' # load the schema to use with these files. This creates an object that is used # to parse EBML files. schema = core.loadSchema(schemaFile) # load the ebml file into memory ebmlDoc1 = schema.load(ebmlFile1,
util.save_to_json() elif args.url: url = args.url method = args.method.upper() if not url.startswith('https://'): url = prefix + url params = _get_params(args.params) init() params['access_token'] = config.facebook_access_token if method == 'GET': url = url + '?' + urllib.urlencode(params) req = urllib2.Request(url) elif method == 'POST' or method == 'PUT': req = urllib2.Request(url) req.data = urllib.urlencode(params) req.add_header('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8') req.get_method = lambda: method else: url = url + '?' + urllib.urlencode(params) req = urllib2.Request(url) req.get_method = lambda: method response = urllib2.urlopen(req) util.pprint(response.read()) else: parser.print_help() except urllib2.HTTPError, e: print >>sys.stderr, '%s %s' % (e.code, e.msg) print >>sys.stderr, e.fp.read() traceback.print_exc()
def do_work(et, google_image_filter, album_folder_path, list_only): # Find folder album in the database LocalLibrary.load_library('raw') local_library_cache = LocalLibrary.cache_raw() images = local_library_cache['images'] albums = local_library_cache['albums'] album_paths = local_library_cache['album_paths'] album_idx = album_paths[album_folder_path] album = albums[album_idx] local_album_path = album['path'] print(f"[INFO]: Found album '{local_album_path}'") # Collect list of local album files local_files_results = [] local_album_images = album['images'] for image_idx in local_album_images: image = images[image_idx] image_name = image['name'] image_path = image['path'] local_files_results.append(image_path) sorted(local_files_results) util.pprint(local_files_results) print(f"[INFO] Local files count '{len(local_files_results)}'") # Collect a list of images from google photos # Each element in this list will be an object: # {'path': 'image path', 'caption': 'images caption...'} google_images_results = [] gphoto.init() GoogleImages.load_images() google_image_cache = GoogleImages.cache() google_images = google_image_cache['list'] for google_image in google_images: image_name = google_image['filename'] if image_name.find(google_image_filter) < 0: continue image_desc = google_image['description'] google_images_results.append((image_name, image_desc)) google_images_results = sorted(google_images_results, key=lambda record: record[0]) util.pprint(google_images_results) print(f"[INFO] Google files count '{len(google_images_results)}'") # Perform basic validations # If counts are not the same then error out if len(local_files_results) != len(google_images_results): print( f"[ERROR]: Count mismatch local: '{len(local_files_results)}', google: '{len(google_images_results)}'. Aborting" ) # Now loop through the list of folder images, get its # equivalent caption from the corresponding google image if list_only: return for image_idx, local_image_path in enumerate(local_files_results): desc = google_images_results[image_idx][1] # Get image extension and identify it as an image or video image_name = os.path.basename(local_image_path) image_ext = ImageUtils.get_file_extension(image_name) is_video = ImageUtils.is_ext_video(image_ext) # Set the caption now ImageUtils.set_caption(et, local_image_path, desc, is_video)
def main(): """ Given an image pattern find the image and does it have a parent album. Also find other related images Arguments: <patterns>: List of Image pattern """ if len(sys.argv) < 2: logging.error("Too few arguments. See help") return # Get arguments patterns = sys.argv[1:] # Load cache GoogleLibrary.load_library() cache = GoogleLibrary.cache() google_album_ids = cache['album_ids'] google_album_titles = cache['album_titles'] google_image_ids = cache['image_ids'] google_image_filenames = cache['image_filenames'] google_album_images = cache['album_images'] google_image_albums = cache['image_albums'] # Define the result # result = { # 'seed_image': { # first Images that matched the pattern # 'id': ..., # 'filename': ..., # 'creationTime' # }, # 'albums': [ # "album id": { # 'title': ...., # 'images': [ # { # 'id': ..., # 'filename': ..., # 'creationTime' # }, # .....more imahes... # ] # }, # .... more albums ... # ] # } result_albums = [] result = {'albums': result_albums} # Find images with the give patterns for google_image_id, google_image in google_image_ids.items(): google_image_filename = google_image['filename'] result_pattern = [p for p in patterns if p in google_image_filename] if result_pattern: # Add image to the result result['seed_image'] = { 'id': google_image_id, 'filename': google_image.get('filename'), 'creationTime': google_image.get('mediaMetadata').get('creationTime') } # Get list of parent albums result_image_albums = google_image_albums.get(google_image_id) if result_image_albums is not None and len( result_image_albums) > 0: # For each album id in image parent list add it to the result for result_image_album_id in result_image_albums: google_album = google_album_ids.get(result_image_album_id) image_list = [] result_album = { 'id': result_image_album_id, 'title': google_album.get('title'), 'images': image_list } result_albums.append(result_album) # Get the list of all images for this album and add to the result result_album_image_ids = google_album_images.get( result_image_album_id) for result_album_image_id in result_album_image_ids: image = google_image_ids.get(result_album_image_id) image_list.append(image.get('filename')) image_list.sort() break util.pprint(result)
def problem1(): """ find all numbers that appear at least three times consecutively. """ query = ses.query(Number.value).order_by(Number.id) number_list = [number.value for number in query] init = 0 count = 0 n_consecutive = 3 target_numbers = list() for i in number_list: if i != init: init = i count = 1 else: count += 1 if count == n_consecutive: target_numbers.append(init) # print(number_list) # print(target_numbers) # pprint(query, engine) query = ses.query(Number.value, func.lag(Number.value, 1)) pprint(query, engine)