def acquisition(items, **kwargs):
import emoji
from prompt_toolkit import print_formatted_text
from prompt_toolkit.patch_stdout import patch_stdout
from prompt_toolkit.shortcuts.progress_bar import ProgressBar
def progress(bar):
acq = bar.data
acq.start()
for result in bar:
result.Release()
cameras, configs, opts, acqs = zip(*items)
movie_camera = emoji.EMOJI_ALIAS_UNICODE[":movie_camera:"]
title = f"{movie_camera} Acquiring on " + ", ".join(str(c) for c in cameras)
pbar = ProgressBar(title=title)
chrono = Chronometer()
pool = concurrent.futures.ThreadPoolExecutor(max_workers=len(cameras))
try:
with contextlib.ExitStack() as stack:
[stack.enter_context(camera) for camera in cameras]
[stack.enter_context(acq) for acq in acqs]
stack.enter_context(pbar)
bars = [
pbar(acq, label=f'{acq.camera}: ', total=acq.nb_frames)
for acq in acqs
]
stack.enter_context(chrono)
for result in pool.map(progress, bars):
pass
finally:
print_formatted_text(f"Elapsed time: {chrono.elapsed:.6f}s")
def read_data(n=415):
with Chronometer() as cr:
k = 1
imageDTOs = []
with open("input/truth.txt", "r") as reader:
length = int(reader.readline())
if n < length:
length = n
for _ in range(length):
n = reader.readline()
n = n.split(",")
m = int(n[1])
n = int(n[0])
matrix = []
for line in range(n):
matrix_line = []
line = reader.readline()
line = line.split(",")
for j in range(m):
matrix_line.append(int(line[j]))
matrix.append(matrix_line)
truth = reader.readline()
truth = truth[:-1]
imageDTOs.append(ImageDTO(matrix, truth))
if k % 5 == 0:
print("#" + str(k))
k += 1
print('Reading done..\nElapsed time: {:.3f} seconds\nTotal length: {}'.
format(float(cr), len(imageDTOs)))
return imageDTOs
def camera_acquisition(ctx, trigger, nb_frames, exposure, latency, roi, binning, pixel_format):
"""do an acquisition on the selected camera"""
import emoji
from prompt_toolkit import print_formatted_text
from prompt_toolkit.patch_stdout import patch_stdout
from prompt_toolkit.shortcuts.progress_bar import ProgressBar
camera = ctx.obj["camera"]
config = ctx.obj["config"]
trigger = trigger.lower()
config.trigger_source = trigger
total_time = nb_frames * (exposure + latency)
if roi is not None:
roi = [int(i) for i in roi.split(",")]
assert len(roi) == 4
movie_camera = emoji.emojize(":movie_camera:")
title = f"{movie_camera} Acquiring {nb_frames} frames"
if nb_frames:
total_time = nb_frames * (exposure + latency)
title += f" (Total acq. time: {total_time:.3f}s)"
acq = Acquisition(
camera, nb_frames, exposure, latency,
roi=roi, trigger=trigger, binning=binning, pixel_format=pixel_format
)
prog_bar = ProgressBar(title=title)
chrono = Chronometer()
try:
with camera, acq, prog_bar:
bar = prog_bar(label=f"{camera}: ", total=nb_frames)
acq.start()
with Chronometer() as chrono:
frame_nb = 0
while frame_nb < nb_frames or not nb_frames:
if trigger == "software":
pause(
"Press any key to trigger acquisition "
f"{frame_nb+1} of {nb_frames}... "
)
result = next(acq)
result.Release()
frame_nb += 1
bar.items_completed = frame_nb
prog_bar.invalidate()
finally:
print_formatted_text(f"Elapsed time: {chrono.elapsed:.6f}s")
def __init__(self, s, lmbda, mu, nq):
self.lmbda = lmbda
self.nq = nq
self.n = nq
self.mu = mu
self.s = s
self.ei = 0
self.chronometer = Chronometer()
self.queue = QueueTP(self.lmbda, self.nq, self.chronometer)
self.servers = []
# self.statistic = Statistics(lmbda, mu, s, nq, nq)
for i in range(0, s):
self.servers.append(Server(self.mu, self.queue, self.chronometer))
def sendFromOptions(self):
with Chronometer() as t:
self.conectar() #se não tiver -g ou -n então dá erro!
logging.warn('conectar() demorou {:.3f} seconds!'.format(float(t)))
if self.getContatoBol:
print(self.getContato())
logging.warn(
'print( self.getContato() ) demorou {:.3f} seconds!'.
format(float(t)))
if self.msg.c_name:
self.enviarMensagem(c_name=self.msg.c_name,
message=self.msg.message)
self.lockScreen(False)
logging.warn('sendFromOptions() demorou {:.3f} seconds!'.format(
float(t)))
def read_data_img(resize=-1):
with Chronometer() as cr:
mias = []
ddsm = []
# t = threading.Thread(target=read_mias_data, args=(mias, resize,))
t2 = threading.Thread(target=read_ddsm_data, args=(
ddsm,
resize,
))
t2.start()
# t.start()
# t.join()
t2.join()
imageDTOs = mias + ddsm
print('Reading done..\nElapsed time: {:.3f} seconds\nTotal length: {}'.
format(float(cr), len(imageDTOs)))
write_data(imageDTOs)
return imageDTOs
def test_integration():
t = Chronometer()
t.start()
a = t.elapsed
time.sleep(0.002)
b = t.elapsed
assert b > a
t.stop()
c = t.elapsed
time.sleep(0.002)
d = t.elapsed
assert (d - c) < 0.000001
def hydrate(ids, path, filename):
"""
Hydrate tweets in order to update the data
"""
T = twarc.Twarc()
last_t = 0
with Chronometer() as t:
count = 0
hydrated_tweets = []
for tweet in T.hydrate(iter(ids)):
assert tweet['id_str']
count += 1
hydrated_tweets.append(tweet)
if (int(float(t)) % 10 == 0 and int(float(t)) != last_t):
print("Hydrated tweets:", len(hydrated_tweets))
last_t = int(float(t))
with jsonlines.open(path + filename, mode='w') as writer:
for obj in hydrated_tweets:
writer.write(obj)
return count, hydrated_tweets
def upload_users():
"""
Uploads all the generated users profile to api/ucarpooling/users/
"""
try:
con = sqlite3.connect(settings.DATABASE)
con.row_factory = sqlite3.Row
cursorObj = con.cursor()
"""Building the query for retrieving all the users and their assigned profiles"""
querystring = Query \
.from_(Table(settings.DATABASE_TABLE_ALUMNI)) \
.join(Table(settings.DATABASE_TABLE_ELOQUENCE)) \
.on_field('uuid') \
.join(Table(settings.DATABASE_TABLE_SMOKER)) \
.on_field('uuid') \
.join(Table(settings.DATABASE_TABLE_MUSIC)) \
.on_field('uuid') \
.select('*')\
.limit(settings.LIMIT_USERS)
"""Executing the query"""
rows = cursorObj.execute(querystring.get_sql()).fetchall()
"""Iteraring for each row in the database for alumni"""
with Chronometer() as time_uploading:
for alumni in rows:
"""Building the body in a json-like format for the boy of the POST request"""
body = {
"email": f"{alumni[settings.FIELDNAME_UUID.lower()]}@mail.com",
"password": "******",
"first_name": str(alumni[settings.FIELDNAME_UUID.lower()]),
"last_name": str(alumni[settings.FIELDNAME_UUID.lower()]),
"ucarpoolingprofile": {
"sex": alumni[settings.FIELDNAME_SEX.lower()],
"smoker": True if alumni[settings.FIELDNAME_SMOKER.lower()] == 'Si' else False,
"musicTaste": alumni[settings.FIELDNAME_MUSIC_TASTE.lower()].split(", "),
"eloquenceLevel": get_eloquence_level(alumni[settings.FIELDNAME_ELOQUENCE.lower()])
}
}
"POST the alumni data to the API"
response = requests.post(
url=settings.USER_URL,
json=body,
headers={
"Authorization": f'Token {settings.UCARPOOLING_APP_TOKEN}' # Token of the Ucarpooling app
}
)
if response.status_code == 201:
helper.success_message(f'Uploaded successfully alumni {alumni[settings.FIELDNAME_UUID.lower()]}')
get_token(con, cursorObj, alumni)
else:
helper.error_message(f'Error uploading alumni {alumni[settings.FIELDNAME_UUID.lower()]} '
f'---- status code: {response.status_code}: {response.reason}')
"""Uploading ended"""
helper.info_message('=================UPLOADING ENDED=====================')
helper.detail_message('Uploading runtime: {:.3f} seconds'.format(float(time_uploading)))
except Error:
print(Error)
finally:
"""Closing the database connection"""
con.close()
from balanced_binary_search_tree import Tree
import random as rdn
from chronometer import Chronometer
if __name__ == "__main__":
tree_control = Tree()
with Chronometer() as time:
i = 0
count = 50
#tree_control.insert_node([50,40,35,30,25,47,43,41,44,55,60,57,65])
with Chronometer() as t:
while i < count:
info = rdn.randint(1,100)
tree_control.insert_node(info)
if i == count/2:
temp = info
i = i + 1
print('To insert spend {:.5f} seconds'.format(float(t)))
with Chronometer() as t:
print('\nin order: ', end='')
tree_control.in_order()
print('\n\nTo print spend {:.5f} seconds'.format(float(t)))
print('\nTree Info: ')
print(' root -> ', tree_control.root.info)
print(' Left height -> ', tree_control.root.left_height)
def __init__(self):
# Inherits from the QWidget class
super().__init__()
#Setting font
self.setFont(QFont('Helvetica',25))
# Get path to the script
self.__dirtrs = os.path.dirname(os.path.abspath(__file__))
#Connection to the Rover model
self.__rover_model = ConnectionToModel()
#timer
self.__rover_timer = QtCore.QTimer(self)
self.__rover_timer.timeout.connect(self.updateRover)
self.__satellites = None
###### RIGHT PART OF THE WIDGET ######
# Start Button
self.__start_b = QPushButton('Start', self)
self.__start_b.setCheckable(True)
self.__start_b.setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.MinimumExpanding)
self.__start_b.toggled.connect(self.startRover)
# Config Button
self.__config_b = QPushButton('Config', self)
self.__config_b.setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.MinimumExpanding)
self.__config_b.clicked.connect(self.openConfig)
# Setting right part layout
right_layout = QHBoxLayout()
right_layout.addWidget(self.__start_b)
right_layout.addWidget(self.__config_b)
###### LEFT PART OF THE WIDGET ######
# Rover image
fig = QPixmap(self.__dirtrs +'/img/rover.png')
self.__icon = QLabel(self)
self.__icon.setPixmap(fig)
# Chrono
self.__chrono_rover = Chronometer()
# Setting left part layout
left_layout = QVBoxLayout()
left_layout.addWidget(self.__icon)
left_layout.addWidget(self.__chrono_rover)
###### LOWER PART OF THE WIDGET ######
# Position indicators
Sol_=QLabel('Sol:')
Sol_.setAlignment(QtCore.Qt.AlignRight)
Lat_=QLabel('Lat:')
Lat_.setAlignment(QtCore.Qt.AlignRight)
Lon_=QLabel('Lon:')
Lon_.setAlignment(QtCore.Qt.AlignRight)
Alt_=QLabel('Height:')
Alt_.setAlignment(QtCore.Qt.AlignRight)
# Calculated Position to be modified by updateRover()
self.__lSol=QLabel('')
self.__lLat=QLabel('')
self.__lLon=QLabel('')
self.__lHeight=QLabel('')
# Stream indicators
status = QLabel('Stream Status:')
status.setAlignment(QtCore.Qt.AlignLeft)
self.__stream_status = QLabel('Not Started')
self.__stream_status.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Minimum)
# Setting lower part layout
lower_layout = QHBoxLayout()
lower_layout.addWidget(Sol_)
lower_layout.addWidget(self.__lSol)
lower_layout.addWidget(Lat_)
lower_layout.addWidget(self.__lLat)
lower_layout.addWidget(Lon_)
lower_layout.addWidget(self.__lLon)
lower_layout.addWidget(Alt_)
lower_layout.addWidget(self.__lHeight)
lower_layout2 = QHBoxLayout()
lower_layout2.addWidget(status)
lower_layout2.addWidget(self.__stream_status)
##### SETTING THE GLOBAL LAYOUT ######
rover_layout1 = QHBoxLayout()
rover_layout1.addLayout(left_layout)
rover_layout1.addLayout(right_layout)
rover_layout = QVBoxLayout()
rover_layout.addLayout(rover_layout1)
rover_layout.addLayout(lower_layout)
rover_layout.addLayout(lower_layout2)
self.setLayout(rover_layout)
import time
from chronometer import Chronometer
a = Chronometer()
a.start()
time.sleep(1)
a.stop()
a.start()
time.sleep(2)
a.stop()
print(a)
print("time should be around 3 seconds")
def main():
long_running_task = lambda: time.sleep(1.)
with Chronometer() as t:
long_running_task() # that will take a few seconds.
print('Phew, that took me {:.3f} seconds!'.format(float(t)))
from sklearn import metrics from sklearn.cluster import DBSCAN import matplotlib.pyplot as plotter from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import train_test_split DEFAULT_STATION_BAUDRATE: int = 9600 # Baudrate Padrão para Comunicação Serial ou Bluetooth com os Slaves das Estações. DEFAULT_SUPERVISOR_BAUDRATE: int = 4800 # Baudrate Padrão para Comunicação Serial ou Bluetooth com o Slave Supervisor. DEFAULT_STATION_PORT: str = "/dev/ttyS6" # Porta Padrão para Comunicação Serial ou Bluetooth com os Slaves das Estações. DEFAULT_SUPERVISOR_PORT: str = "/dev/ttyS3" # Porta Padrão para Comunicação Serial ou Bluetooth com o Slave Supervisor. DATASET_FILE_PATH: str = "dataset.txt" # Arquivo nos quais estão contidos os dados para feed no Algoritmo DBSCAN. ERRORSET_FILE_PATH: str = "errorset.csv" # Arquivo de armazenamento dos erros encontrados para feed no modelo de classificação Decision Tree. timerStation: Chronometer = Chronometer( ) # Cronômetro para o Tempo gasto em cada Estação. stationThread: Thread = None # Thread que executa a Await-For-Response do Arduino das Estações. controlThread: Thread = None # Thread que controla a Await-For-Response para parada, enquanto a `stationThread` está ocupada com o DBSCAN. eventRoutine: bool = False # Flag para input de comandos. isRunning: bool = False # Indica o estado de execução do parâmetro para os laços das Threads. isControlActive: bool = False # Indica o estado da Thread de Controle. stationPort: Serial = None # Entrada de Comunicação Serial da Estação. supervisorPort: Serial = None # Entrada de Comunicação Serial do Supervisor. # Limit = Average + STD * Threshold -> Limite para Suspeitar Anomalia. threshold: float = 1 # Threshold - Parâmetro que multiplica o corte de desvio médio. avg: float = 4 # Average - Média dos valores de tempo do Dataset.
def simulator():
"""
Simulates the use of the Ucarpooling app
"""
"""Variables for statistics in the simulation"""
max_time = 0
total_time = 0
total_errors = 0
"""Get the set of people that will request a carpooling partner"""
rows = get_requesters()
helper.info_message(
f'==============STARTING SIMULATION=====================')
"""Iteraring for each row in the database for alumni"""
with Chronometer() as time_simulation:
total_row_count = len(rows)
row_counter = 0
helper.info_message(f'{total_row_count} records to check matching')
for alumni in rows:
print('=========================================')
row_counter += 1
helper.info_message(f'Progress: {row_counter}/{total_row_count}')
alumni_token = alumni['token']
alumni_id = alumni[settings.FIELDNAME_UUID.lower()]
alumni_ucarpooling_id = alumni['ucarpoolingprofile_id']
alumni_useritinerary_id = alumni['useritinerary_id']
"GET the matches for the alumni"
with Chronometer() as time_matching:
response = requests.get(
url=get_matcher_url(alumni_useritinerary_id),
headers={"Authorization": f'Token {alumni_token}'})
"""Time statistics for the matcher of the back-end"""
match_time = float(time_matching)
helper.detail_message('Match for {} took {:.3f} seconds'.format(
alumni_id, match_time))
total_time += match_time
max_time = match_time if max_time < match_time else max_time
if response.status_code == 200:
body_response = response.json()
partners = get_carpooling_partner(body_response)
if partners:
create_carpool(alumni_ucarpooling_id, partners,
alumni_useritinerary_id)
else:
helper.warning_message(
f'{alumni_id} had matches but did not travel with poolers'
)
else:
"""The server did not respond a good result"""
total_errors += 1
if response.status_code == 420:
helper.warning_message(
f'{alumni_id} is already in a carpool')
elif response.status_code == 204:
helper.no_matches_message(
f'{alumni_id} did not have any matches')
create_carpool(alumni_ucarpooling_id, [],
alumni_useritinerary_id)
else:
helper.error_message(
f'Error getting matches for alumni {alumni_id} '
f'---- status code: {response.status_code}: {response.reason}'
)
"""The simulation ended"""
helper.info_message(
'=================SIMULATION ENDED=====================')
helper.detail_message(f'There was a total of {total_errors} errors')
helper.detail_message(f'Max total match time: {max_time} seconds')
helper.detail_message('Simulation runtime: {:.3f} seconds'.format(
float(time_simulation)))
def upload_users_itinerary():
"""
Uploads all the generated users profile to api/ucarpooling/users/
"""
alumni_auth = Table(settings.DATABASE_TABLE_AUTH)
try:
con = sqlite3.connect(settings.DATABASE)
con.row_factory = sqlite3.Row
cursorObj = con.cursor()
"""Building the query for retrieving all the users and their assigned profiles"""
querystring = Query \
.from_(Table(settings.DATABASE_TABLE_ALUMNI)) \
.join(Table(settings.DATABASE_TABLE_ITINERARY)) \
.on_field('uuid') \
.join(Table(settings.DATABASE_TABLE_CARS)) \
.on_field('uuid') \
.select('*')\
.limit(settings.LIMIT_USERS)
# print(querystring.get_sql())
"""Executing the query"""
rows = cursorObj.execute(querystring.get_sql()).fetchall()
with Chronometer() as time_uploading:
"""Iteraring for each row in the database for alumni"""
for alumni in rows:
"""Building the body in a json-like format for the boy of the POST request"""
origen = f'{alumni[settings.FIELDNAME_LATITUDE.lower()]},{alumni[settings.FIELDNAME_LONGITUDE.lower()]}'
toa = f'{date.today()}T{alumni[settings.FIELDNAME_TOA.lower()]}Z'
body = {
"isDriver": True if alumni[settings.FIELDNAME_TRANSPORT.lower()] == 'Car' else False,
"origin": origen,
"destination": "-25.324491,-57.635437", # Uca latitude and longitude
"timeOfArrival": toa
}
"""Getting the token of the alumni for the POST header"""
querystring = Query\
.from_(alumni_auth)\
.select(alumni_auth.token)\
.where(alumni_auth.uuid == alumni[settings.FIELDNAME_UUID.lower()])
cursorObj.execute(querystring.get_sql())
alumni_token = (cursorObj.fetchone())['token']
"""POST request for the itinerary"""
response = requests.post(
url=settings.USER_ITINERARY_URL,
json=body,
headers={
"Authorization": f'Token {alumni_token}' # Token og the Ucarpooling app
}
)
if response.status_code == 201:
helper.success_message(f'Uploaded successfully itinerary for alumni {alumni[settings.FIELDNAME_UUID.lower()]}')
body_response = response.json()
store_useritinerary_id(con, cursorObj, body_response['id'], alumni[settings.FIELDNAME_UUID.lower()])
else:
helper.error_message(f'Error uploading itinerary for alumni {alumni[settings.FIELDNAME_UUID.lower()]} '
f'---- status code: {response.status_code}: {response.reason}')
"""Uploading ended"""
helper.info_message('=================UPLOADING ENDED=====================')
helper.detail_message('Uploading runtime: {:.3f} seconds'.format(float(time_uploading)))
except Error:
print(Error)
finally:
"""Closing the database connection"""
con.close()
from time import sleep
from chronometer import Chronometer
counter = 0
def long_running_task_that_can_fail():
global counter
counter += 1
sleep(2.)
return counter > 3
with Chronometer() as t:
while not long_running_task_that_can_fail():
print('Failed after {:.3f} seconds!'.format(t.reset()))
print('Success after {:.3f} seconds!'.format(float(t)))
def __init__(self):
# Inherits from the QWidget class
super().__init__()
#Setting font
self.setFont(QFont('Helvetica', 25))
# Get path to the script
self.__dirtrs = os.path.dirname(os.path.abspath(__file__))
#Connection to the Base model
self.__base_model = ConnectionToModel()
#timer
self.__base_timer = QtCore.QTimer(self)
self.__base_timer.timeout.connect(self.updateBase)
###### RIGHT PART OF THE WIDGET ######
# Start Button
self.__start_b = QPushButton('Start', self)
self.__start_b.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.__start_b.setCheckable(True)
self.__start_b.toggled.connect(self.startBase)
# Config Button
self.__config_b = QPushButton('Config', self)
self.__config_b.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.__config_b.clicked.connect(self.openConfig)
# horizontal layout for the buttons
right_layout = QHBoxLayout()
right_layout.addWidget(self.__start_b)
right_layout.addWidget(self.__config_b)
###### LEFT PART OF THE WIDGET ######
# Base image
fig = QPixmap(self.__dirtrs + '/img/base.png')
self.__icon = QLabel(self)
self.__icon.setPixmap(fig)
# Chrono
self.__chrono_base = Chronometer()
# Setting left part layout
left_layout = QVBoxLayout()
left_layout.addWidget(self.__icon)
left_layout.addWidget(self.__chrono_base)
####### LOWER PART OF THE WIDGET ######
status = QLabel('Stream Status:')
status.setAlignment(QtCore.Qt.AlignLeft)
self.__status_base = QLabel('Not Started')
self.__status_base.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Minimum)
lower_layout = QHBoxLayout()
lower_layout.addWidget(status)
lower_layout.addWidget(self.__status_base)
##### SETTING THE GLOBAL LAYOUT ######
base_layout = QHBoxLayout()
base_layout.addLayout(left_layout)
base_layout.addLayout(right_layout)
base_layout2 = QVBoxLayout()
base_layout2.addLayout(base_layout)
base_layout2.addLayout(lower_layout)
self.setLayout(base_layout2)
def chronometer(time_gun):
return Chronometer(time_gun)
