def download_images(self):
"""Download images from the gatherer
"""
print('Downloading images...')
try:
cursor = self.connection.cursor()
cursor.execute("SELECT MultiverseID FROM Cards")
cards = cursor.fetchall()
if (len(cards)):
pbar = ProgressBar(widgets=[
Percentage(), ': ',
Counter(), '/' + str(len(cards)) + ' ',
Bar(), ' ',
ETA()
])
for card in pbar(cards):
MultiverseID = card[0]
path = self.IMAGE_FILE % MultiverseID
if (not os.path.isfile(path)):
urllib.urlretrieve(self.IMAGE_URL % MultiverseID, path)
os.system("convert " + path +
" -background black -flatten " + path)
except sqlite3.Error, e:
self.connection.rollback()
print("Error %s:" % e.args[0])
sys.exit(1)
def inpaint(self, picture: Picture) -> Picture:
picture = picture.copy()
# Initialisation de la barre de progression
number_of_pixels_to_process = len(picture.pixels[picture.pixels == self.value_missing_pixel]) // 3
progress_bar_widgets = ["Inpainting: processed ", Counter(), "/{} pixels [".format(number_of_pixels_to_process),
Percentage(), "], ", Timer(), ", ", ETA()]
progress_bar = ProgressBar(widgets=progress_bar_widgets,
minval=0,
maxval=number_of_pixels_to_process)
progress_bar.start()
# On récupère le dictionnaire
dictionary = picture.get_dictionnaire(self.patch_size, self.step, max_missing_pixel=0)
while self.value_missing_pixel in picture.pixels:
# On récupère le prochain patch à traiter
next_pixel = self._get_next_patch(picture, self.patch_size, self.value_out_of_bounds,
self.value_missing_pixel)
# On reconstruit le patch selectionné
next_patch = picture.get_patch(*next_pixel, self.patch_size)
self.fit(dictionary, next_patch)
for x, y in iter_patch_empty(picture.pixels, *next_pixel, self.patch_size):
next_pixel_value = self.predict(x - next_pixel[0] + (self.patch_size // 2),
y - next_pixel[1] + (self.patch_size // 2),
dictionary)
picture.pixels[x, y] = next_pixel_value
progress_bar.update(progress_bar.value + 1)
progress_bar.finish()
return picture
def compute_route_permutations(self, src_env, target_env, cleanup=False):
if not self.dep_graph:
raise Exception('Need gen depend graph first')
LOGGER.info("Compute route from %s to %s", src_env, target_env)
# TODO encapsulation the ProgressBar in utils
widgets = [
'Processed: ',
Counter(),
' of %d (' % len(self.dep_graph),
Timer(), ')'
]
pbar = ProgressBar(widgets=widgets, maxval=len(self.dep_graph)).start()
graph = self._v_graph if self._use_map else self.dep_graph
src_node = self._nodes_map.index(src_env) if self._use_map else src_env
tgt_node = self._nodes_map.index(
target_env) if self._use_map else target_env
if cleanup:
routes = route_permutations(graph,
tgt_node,
src_node,
pb=pbar,
allow_dep=self._allow_dep)
else:
routes = route_permutations(graph,
src_node,
tgt_node,
pb=pbar,
allow_dep=self._allow_dep)
pbar.finish()
ret_routes = []
for route in routes:
ret_routes.extend(itertools.product(*route))
return ret_routes
def main(show_progress, *args, **kwargs):
# Set up progress bar.
if show_progress:
progress_bar = ProgressBar(maxval=len(PACKAGES),
widgets=[
'Progress: ',
Percentage(), ' ',
Bar(marker=RotatingMarker()), ' ',
ETA(), ' Fetched posts for ',
Counter(), ' / ' + str(len(PACKAGES)) +
' packages.'
])
progress_bar.start()
# Fetch statistics for posts related to each tag
for package_count, package in enumerate(PACKAGES, start=1):
records = (Tag.select().join(
PostTag, on=(Tag.id == PostTag.tag_id)).join(
Post, on=(Post.id == PostTag.post_id)).where(
Tag.tag_name == package).select(
Tag.tag_name, Post.title, Post.creation_date,
Post.answer_count, Post.comment_count,
Post.favorite_count, Post.score,
Post.view_count).dicts())
yield records
if show_progress:
progress_bar.update(package_count)
if show_progress:
progress_bar.finish()
raise StopIteration
def gen_depend_map(self, test_funcs, drop_env=None, start_node=None):
dep_graph = {}
if not start_node:
start_node = Env()
dep_graph.setdefault(start_node, {})
nodes = [start_node]
widgets = ['Processed: ', Counter(), ' nodes (', Timer(), ')']
LOGGER.info("Start gen depend map...")
pbar = ProgressBar(widgets=widgets, max_value=100000)
pbar.start()
while nodes:
node = nodes.pop()
for func in test_funcs:
new_node = node.gen_transfer_env(func)
if new_node is None:
continue
if drop_env and len(new_node) > drop_env:
continue
if new_node not in dep_graph.keys():
dep_graph.setdefault(new_node, {})
nodes.append(new_node)
data = dep_graph[node]
data.setdefault(new_node, set())
data[new_node].add(func)
pbar.update(len(dep_graph))
LOGGER.debug(pretty(dep_graph))
LOGGER.info('Depend map is %d x %d size', len(dep_graph),
len(dep_graph))
self.dep_graph = dep_graph
if self._use_map:
self.build_graph_map()
def example10():
widgets = ['Processed: ', Counter(), ' lines (', Timer(), ')']
pbar = ProgressBar(widgets=widgets)
for i in range(15):
time.sleep(0.1)
pbar.update(i + 1)
pbar.finish()
def __initialize_progress_bar(self, total_rows):
try:
from progressbar import ProgressBar, Counter, Percentage, Bar
widgets = ['Processed: ', Counter(), ' ', Percentage(), ' ', Bar()]
return ProgressBar(widgets=widgets, maxval=total_rows).start()
except ImportError:
raise CommandError('No progressbar package found! Please, install it to track progress')
def __init__(self, *args, **kwargs):
start_time = "Start: " + dt.now().strftime("%H:%M:%S")
bar = Bar(left = "[", right = "]", marker = ":", fill = ".")
counter = Counter("%d/" + str(kwargs["maxval"]))
kwargs["widgets"] = [start_time, " ", ETA(), " ", counter, " ", \
Percentage(), " ", bar]
ProgressBar.__init__(self, *args, **kwargs)
def infinite_progress(name=None, status=False):
widgets = defaut_widgets(name, status)
widgets.extend(Counter(), " ", AnimatedMarker())
progress = MyProgressBar(widgets=widgets)
progress.status = status
return progress
def main():
args = parser()
make_directory(args.dir)
p = ProgressBar(0, args.num, widgets=[
CurrentTime(), ':','(', Counter(), ' of {}) '.format(args.num), Bar(), ' ', ETA(),
])
cap = cv2.VideoCapture(0)
ready = 59
while ready > 0:
ret, frame = cap.read()
cv2.putText(frame, str(int(ready/10)), (200, 300), cv2.FONT_HERSHEY_COMPLEX, 10, (0, 0, 255))
cv2.imshow('camera capture', frame)
ready -= 1
k = cv2.waitKey(100)
cv2.destroyAllWindows()
count = 0
while True:
ret, frame = cap.read()
cv2.imshow('camera capture', frame)
frame = cv2.resize(frame, (args.size, args.size))
cv2.imwrite('./' + args.dir + '/' + get_unique_name() + '.jpg', frame)
p.update(count)
count += 1
if(count >= args.num):
break
k = cv2.waitKey(30)
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
def run(self):
"""Reads data from CNPJ list and write results to output directory."""
self._assure_output_dir(self.output)
companies = self.read()
print '%s CNPJs found' % len(companies)
pbar = ProgressBar(
widgets=[Counter(), ' ',
Percentage(), ' ',
Bar(), ' ',
Timer()],
maxval=len(companies)).start()
resolved = 0
runner = Runner(companies, self.days, self.token)
try:
for data in runner:
self.write(data)
resolved = resolved + 1
pbar.update(resolved)
except KeyboardInterrupt:
print '\naborted: waiting current requests to finish.'
runner.stop()
return
pbar.finish()
def __init__(self, interface_type, count=None, description=None):
self.interface_type = interface_type
self.current_value = 0
if self.interface_type == Config.UI_CLI:
widgets = []
if description is not None:
widgets.append('{}: '.format(description))
if count is not None:
widgets.append(Percentage())
widgets.append(' ')
widgets.append(Bar())
else:
widgets.append(Counter())
widgets.append(' ')
widgets.append(AnimatedMarker(markers='.oO@* '))
if count is not None:
self.progressBar = ProgressBar(widgets=widgets,
max_value=count)
else:
self.progressBar = ProgressBar(
max_value=progressbar.UnknownLength, widgets=widgets)
else:
PROGRESS_LOGGER.error('interface type not handled: {}'.format(
self.interface_type))
raise Exception('interface type not handled: {}'.format(
self.interface_type))
def EvaluateGenomeList_Serial(genome_list, evaluator):
fitnesses = []
curtime = time.time()
if prbar_installed:
widg = ['Individuals: ', Counter(), ' of ' + str(len(genome_list)),
' ', ETA(), ' ', AnimatedMarker()]
progress = ProgressBar(maxval=len(genome_list), widgets=widg).start()
count = 0
for g in genome_list:
f = evaluator(g)
fitnesses.append(f)
if prbar_installed:
progress.update(count)
else:
print 'Individuals: (%s/%s)' % (count, len(genome_list))
count += 1
if prbar_installed:
progress.finish()
elapsed = time.time() - curtime
print 'seconds elapsed: %s' % elapsed
return (fitnesses, elapsed)
def cleanup(displayCnt=True):
cnt = 0
_ = []
widgets = ['Deleting ', Counter(), ' ', Percentage(),\
' ', Bar(),\
' ', Timer(),\
' ', AdaptiveETA()]
with ProgressBar(widgets=widgets, maxval= __len__()\
if displayCnt else UnknownLength\
, redirect_stdout=True) as bar:
for key in listUniprotKey():
cnt += 1
_.append(key)
if cnt % 50 == 0:
try:
remove(_)
except KeyError:
print("Missing keys to delete")
_ = []
bar.update(cnt)
if _:
try:
remove(_)
except KeyError:
print("Missing keys to delete")
bar.update(cnt)
def progressbar(caption,maxval=None):
"""
progress(title,maxval=None)
Summary: progress bar wrapper
Arguments:
- caption: progress bar caption
- maxval: maximum value
Keyword Arguments:
None
Output:
- progress bar instance (pbar.update(i) to step, pbar.finish() to close)
"""
capstr = caption + ': ' if caption else ''
if maxval is not None:
widgets = [capstr, Percentage(), ' ', Bar('='), ' ', ETA()]
else:
maxval = UnknownLength
widgets = [capstr, Counter(), ' ', Bar('=')]
return ProgressBar(widgets=widgets, maxval=maxval)
def create_progress_bar(self):
"""
Initialize the progress bar
"""
if self.total is None:
self.total = progressbar.UnknownLength
widgets = [
DynamicStringMessage('imagename'), ' ',
Counter(), ' ',
BouncingBar(marker=u'\u2588', left=u'\u2502', right=u'\u2502'),
' ',
Timer()
]
else:
widgets = [
DynamicStringMessage('imagename'), ' ',
Percentage(), ' (',
SimpleProgress(), ')', ' ',
Bar(marker=u'\u2588', left=u'\u2502', right=u'\u2502'), ' ',
Timer()
]
self.progress_bar = progressbar.ProgressBar(max_value=self.total,
redirect_stdout=True,
redirect_stderr=True,
widgets=widgets)
self.progress_bar.start()
self.progress_bar.update(self.step, imagename=self.imagename)
def populate_postgres():
test_postgres()
clear_postgres()
conn, curr = connect_postgres()
customers = 500
receipts = customers * 5
receipt_items = 8
# reciept
with open('queries/receipt_query.txt', 'r') as f:
query = f.read()
bar = ProgressBar()
for i in bar(range(receipts)):
curr.execute(query, fake_receipts(customers))
conn.commit()
# receipt items
with open('queries/receipt_items_query.txt', 'r') as f:
query = f.read()
ttl_items = receipts * receipt_items
bar = ProgressBar(widgets=[Counter(), '/{}'.format(ttl_items), Bar()])
for i in bar(range(ttl_items)):
curr.execute(query, fake_receipt_items(receipts))
conn.commit()
# customers
with open('queries/customer_query.txt', 'r') as f:
query = f.read()
bar = ProgressBar()
for i in bar(range(customers)):
curr.execute(query, fake_customer())
conn.commit()
conn.close()
def generate_pbar(title, number_of_elements):
widgets = [
title,
Counter(),
'/%s ' % number_of_elements,
Percentage(), ' ',
Bar(left='[', right=']', fill='-'), ' ',
ETA()
]
return ProgressBar(widgets=widgets, maxval=number_of_elements).start()
def extract_snippets(patterns, tags, compute_index, lines_of_context, show_progress=False):
# Fetch all posts, filtering by those for which tags have been specified
posts = Post.select(Post.id, Post.body)
if tags is not None:
posts = (
posts
.join(PostTag, on=(Post.id == PostTag.post_id))
.join(Tag, on=(Tag.id == PostTag.tag_id))
.where(Tag.tag_name << tags)
)
# Initialize the progress bar
if show_progress:
post_count = posts.count()
progress_bar = ProgressBar(maxval=post_count, widgets=[
'Progress: ', Percentage(),
' ', Bar(marker=RotatingMarker()),
' ', ETA(),
' Processing web page ', Counter(), ' / ' + str(post_count) + '.'
])
progress_bar.start()
# Zip all patterns with a scanner that scans for it
pattern_scanner_pairs = []
for pattern in patterns:
snippet_pattern, _ = SnippetPattern.get_or_create(pattern=pattern)
extractor = PythonSnippetExtractor(pattern, lines_of_context)
scanner = NodeScanner(extractor, tags=['pre', 'code'])
pattern_scanner_pairs.append((snippet_pattern, scanner))
# For each post, extract snippets for all patterns
# Note that currently there is some repeated work: each extractor will
# try to parse all relevant nodes as Python
for post_index, post in enumerate(posts, start=1):
document = BeautifulSoup(post.body, 'html.parser')
for snippet_pattern, scanner in pattern_scanner_pairs:
snippets = scanner.scan(document)
# Store a record of each snippet that was found
for snippet in snippets:
PostSnippet.create(
post=post,
snippet=snippet,
compute_index=compute_index,
pattern=snippet_pattern,
)
if show_progress:
progress_bar.update(post_index)
if show_progress:
progress_bar.finish()
def get_new_progressbar(name, max_val=1) -> ProgressBar:
global PROGRESS_BAR_IDX
if PROGRESS_BAR_IDX == 0:
print(term.clear)
writer = Writer((0, PROGRESS_BAR_IDX))
p_bar = ProgressBar(widgets=[name + ': ', Counter(format='%(value)d out of %(max_value)d'), ' ', Percentage(), ' ', Bar(), ' ', ETA()],
fd=writer, max_value=max_val).start(max_value=max_val)
PROGRESS_BAR_IDX += 1
PROGRESS_BAR_IDX %= 50
if PROGRESS_BAR_IDX == 0:
PROGRESS_BAR_IDX += 1
return p_bar
def get_progress_bar(n):
# progress bar
pbar_widgets = [
'IMU Epochs : ',
Bar(marker='#'), 'epoch=',
Counter(), ' ',
Percentage(), ' (',
Timer(), ') ',
AdaptiveETA(), ' '
]
pbar = ProgressBar(widgets=pbar_widgets, maxval=n).start()
return pbar
def get_progressbar(self, total):
# initialize & return a progressbar to track pages processed.
# only returns when running on a tty (i.e. not redirected to a file)
if os.isatty(sys.stderr.fileno()):
return ProgressBar(widgets=[
'Pages: ',
Percentage(), ' (',
Counter(), ')',
Bar(),
ETA()
],
maxval=total).start()
