def changelist_view(self, request, extra_context=None):
t = Timing('WorklogReport')
# выбранный диапазон месяцев
year = get_year_param(request)
month_list = [
date(year, 1 + i, 1) for i in range(BaseReportAdmin.COLUMNS)
]
stop_date = get_slice_param(request)
last_date = month_list[-1] + monthdelta(1)
if stop_date and stop_date > last_date:
# сброс параметра, если выбран набор данных в прошлом
stop_date = None
qs = self.get_queryset(request).filter(
startdate__range=(month_list[0], stop_date or last_date))
# загрузка и сохранение в request журнала работ за год
# (оптимизация для предотвращения необходимости повторной загрузки фрейма в фильтрах)
worklogframe = WorklogFrame().load(qs)
# ограничение набора данных только теми, по которым решал задачи пользователь
if not request.user.has_perm('jiradata.view_all'):
worklogframe = worklogframe.filter(author=request.user.username)
request.worklogframe = worklogframe
rows = worklogframe.rows()
# заполнение фильтров в базовом классе
response = super().changelist_view(request,
extra_context=extra_context)
try:
cl = response.context_data['cl']
qs = cl.queryset
except (AttributeError, KeyError):
return response
# фильтрация по выбранному сотруднику
user = get_user_param(request)
worklogframe = worklogframe.filter(author=user)
# список норм рабочего времени
month_norma = calc_month_norma(month_list, stop_date=stop_date)
seconds = t.step()
response.context_data['months'] = month_list
response.context_data['member'] = JiraUser.objects.filter(
user_name=user).first()
response.context_data['summary'], response.context_data[
'total'] = worklogframe.aggr_month_budget(month_list, month_norma)
response.context_data['norma'] = month_norma
response.context_data['slice'] = stop_date
response.context_data['year'] = year
response.context_data[
'stat'] = f'{rows} строк обработано за {seconds:.2} c'
return response
def __init__(self):
self.log = LogWrapper("TradingBot")
self.tech_log = LogWrapper("TechnicalsBot")
self.trade_pairs = Settings.get_pairs()
self.settings = Settings.load_settings()
self.api = OandaAPI()
self.timings = { p: Timing(self.api.last_complete_candle(p, GRANULARITY)) for p in self.trade_pairs }
self.log_message(f"Bot started with\n{pprint.pformat(self.settings)}")
self.log_message(f"Bot Timings\n{pprint.pformat(self.timings)}")
def parse_timings(self, time_dict:dict):
timings = []
for key in time_dict.keys():
timing = Timing(
test_uuid=self.uuid,
function_name=key,
function_id=self.find_lambda_id(key),
total_time=time_dict[key]['total_time'],
exe_time=time_dict[key]['exe_time'],
latency=time_dict[key]['latency'],
memory_limit=time_dict[key]['memory'],
log_stream_name=self.parse_log_stream_name(time_dict[key]['log_stream_name'])
)
timings.append(timing)
return timings
system.at['part_solver'].updateMeshValues(
old_system.at['electrons'], extent=2)
system.at['part_solver'].updateMeshValues(
old_system.at['photoelectrons'], extent=2)
system.at['part_solver'].updateMeshValues(old_system.at['protons'],
extent=2)
out.saveVTK(system.at['mesh'], old_system.at, system.arrangeVTK())
if system.at['ts'] % 10000 == 0:
out.saveParticlesTXT(old_system.at, system.arrangeParticlesTXT())
if system.at['ts'] % 10000 == 0:
out.particleTracker(old_system.at['ts'], old_system.at['protons'],
old_system.at['electrons'],
old_system.at['photoelectrons'])
#Updating previous state
deepcopy = Timing(copy.deepcopy)
old_system = deepcopy(system)
#Execution time of loop step and storage
t1 = time.perf_counter()
getattr(Timing, 'time_dict')['Global'] = t1 - t0
if system.at['ts'] % 10 == 0:
out.saveTimes(system.at['ts'], getattr(Timing, 'time_dict'))
Timing.reset_dict()
#Advance in timestep
system.at['ts'] += 1
except KeyboardInterrupt:
out.savePickle(old_system.at, old_system.arrangePickle())
print('Process aborted')
"""
Example usage of module timing
"""
from timing import Timing
import time
my_outer_process = Timing("My outer process")
my_inner_process = Timing("My inner process")
my_outer_process.start()
time.sleep(2)
my_inner_process.start()
time.sleep(2)
my_inner_process.stop()
time.sleep(1)
my_outer_process.stop()
#Output:
# 'My outer process' started.
# 'My inner process' started.
# 'My inner process' finished.
# ++++++++++++SUMMARY+EXECUTION+TIME+'My inner process'+++++++++++++
# Elapsed time 'My inner process':0 min, 2.000 sec
# 'My outer process' finished.
# ++++++++++++SUMMARY+EXECUTION+TIME+'My outer process'+++++++++++++
# Elapsed time 'My outer process':0 min, 5.000 sec
from imutils.video import VideoStream
import imutils
import time
import cv2
from timing import Timing
print("[INFO] loading cascade file stream...")
haarcascade_path = cv2.data.haarcascades + "/haarcascade_frontalface_default.xml"
face_cascade = cv2.CascadeClassifier(haarcascade_path)
print("[INFO] starting video stream...")
vs = VideoStream(usePiCamera=True).start()
time.sleep(2.0)
frame_count = 0
while True:
timer = Timing(f"Frame {frame_count} timing")
# grab the current frame of video and resize it to 400px wide
frame = vs.read()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
frame = cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
roi_gray = gray[y:y + h, x:x + w]
roi_color = frame[y:y + h, x:x + w]
cv2.imshow("Frame", frame)
timer.end_log()
frame_count = frame_count + 1
# if the `q` key was pressed, break from the loop
if confidence > args["confidence"]:
# compute the coordinates of the bounding box for the detection
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# draw the bounding box and display the confidence
text = "{:.2f}%".format(confidence * 100)
y = startY - 10 if startY - 10 > 10 else startY + 10
cv2.rectangle(image, (startX, startY), (endX, endY), (0, 0, 255),
2)
cv2.putText(image, text, (startX, y), cv2.FONT_HERSHEY_DUPLEX,
0.45, (0, 0, 255), 2)
# cv2.imshow("Output", image)
cv2.imwrite(f"./outC/detected_{os.path.splitext(image_path)[0]}.jpg",
image)
# cv2.imwrite(f"./outC/detected_{image_path}", image)
timer = Timing("1 image test")
detect_faces(images1)
timer.end_log()
timer = Timing("10 image test")
for i in images10:
detect_faces(i)
timer.end_log()
timer = Timing("100 image test")
for i in images:
detect_faces(i)
timer.end_log()
from light.http_light_writer import HttpLightWriter
from light.light_timing import LightStepListener
from light.priority_light_writer import PriorityLightWriterFactory
from timing import Timing
from midi.midi_output import MidiOutputBpm, MidiOutputTime
import time
import midi.midi_bindings as bindings
from midi.midi_input import *
DEFAULT_IP = "192.168.1.72"
DEFAULT_PORT = 80
DEFAULT_GPIO = 12
if __name__ == "__main__":
timing = Timing(4 * 8, 1.0 / 4.0)
midi_binding = bindings.APC_KEY_25
light_writer = HttpLightWriter(DEFAULT_IP, DEFAULT_PORT, DEFAULT_GPIO)
priority_light_writer_factory = PriorityLightWriterFactory(light_writer)
light_step_listener = LightStepListener(timing, priority_light_writer_factory.low())
output_steps = MidiOutputTime(timing, midi_binding)
output_bpm = MidiOutputBpm(timing, midi_binding)
output_bpm.start_bpm_thread()
input_steps = MidiInputSteps(timing, midi_binding)
input_steps.start_listening()
generic_midi_input = MidiGenericInputListener(midi_binding)
self.set_scene_coords_projection()
def finish_drag(self):
if not self._is_dragging:
return
self._viewport_fixed_center = self.viewport_center
self._is_dragging = False
self.set_scene_coords_projection()
def cancel_drag(self):
self._is_dragging = False
self.set_scene_coords_projection()
timing = Timing()
timing.set_value('main_opacity', 1.0)
timing.set_value('main_wireframe_color', Interface.HIDDEN_WIREFRAME_COLOR)
timing.set_value('point_border_color', Interface.HIDDEN_POINT_BORDER_COLOR)
timing.set_value('point_fill_color', Interface.HIDDEN_POINT_FILL_COLOR)
timing.set_value('target_wireframe_color', Interface.VISIBLE_TARGET_COLOR)
interface = Interface()
context = Context(config=config, interface=interface, timing=timing)
def display():
timing.update_time()
glClearColor(0.1, 0.1, 0.1, 1)
def main(plpy, args: str):
# some config parameter
# the map is passed down to the functions
config = {'src': '/benchmark/sql',
'dataset': 'tpch',
'query_types': ['bv', 'cv', 'dv', 'ev', 'fv'],
'queries': ['q1', 'q3', 'q6', 'q15', 'q20'],
'batch_size': 1000,
'max_batch_size': 10000}
# perform some basic argument parsing
args = args.split()
operation = args[0]
timing = Timing(config)
db = Database(plpy, timing)
# load the TPC-H relations
if operation == 'setup':
SetupPublic(db, config).execute()
db.commit()
# create auxiliary tables, views and functions for the given maintenance approach
elif operation == 'setup_query' and len(args) == 3:
clear_query(db, config, args[1], args[2])
setup_query(db, config, args[1], args[2])
# check for correctness of the given query
elif operation == 'compare' and len(args) == 2:
compare(db, config, args[1])
# check correctness of all available queries
elif operation == 'compare_all' and len(args) == 2:
config['batch_size'] = int(args[1])
for query in config['queries']:
compare(db, config, query)
# benchmark the given query for the obtained batch_size
elif operation == 'benchmark' and len(args) == 3:
benchmark(db, config, args[1], args[2], True)
timing.save(db)
# benchmark all queries and all maintenance approaches for the given batch size
elif operation == 'benchmark_all' and len(args) == 3:
config['batch_size'] = int(args[2])
for query_type in config['query_types']:
for query in config['queries']:
# warmup (discard first three iterations)
benchmark(db, config, query_type, query, False)
benchmark(db, config, query_type, query, False)
benchmark(db, config, query_type, query, False)
for i in range(int(args[1])):
benchmark(db, config, query_type, query, True)
# write execution times to the database
timing.save(db)
# clear everything, including TPC-H relations
elif operation == 'clear':
for query_type in config['query_types']:
for query in config['queries']:
clear_query(db, config, query_type, query)
ClearPublic(db, config).execute()
db.commit()
else:
raise RuntimeError('Missing arguments!')
# temperature from temperature_sensor import TemperatureSensor temperature_data = [] temperature = TemperatureSensor() # humidity from temperature_sensor import HumiditySensor humidity_data = [] humidity = HumiditySensor() # Timing set up time_data = [] t = Timing() # mqtt setup import paho.mqtt.client as mqtt piTopic = "IC.embedded/tEEEm/TO_PI" appTopic = "IC.embedded/tEEEm/TO_APP" # constants on piTopic SPEECH_TRIGGER = 0 TIME_SET = 1 SUNRISE = 0 AT = 1 ASK_RESULTS = 2 RECEIVED_START_ALARM = 3 RECEIVED_STOP_ALARM = 4
def run(self):
def send_controls(timing, solver):
control = Control(timing=timing, previous_solver=solver)
control.apply()
def solve_short_term_problem(timing, previous_solver, queue_st):
ambient = Ambient(timing=timing)
ambient.update()
state = State()
state.update()
predictor = Predictor(timing=timing, ambient=ambient, \
state=state, previous_solver=previous_solver, \
solver_name="predictor_bin_" \
+ str(timing.grid_position_cursor))
predictor.solve()
timing.increment_grid_position_cursor()
if timing.grid_position_cursor >= timing.N_short_term:
timing.shift_time_grid()
ambient = Ambient(timing=timing)
ambient.update()
nlpsolver_bin = NLPSolverBin( \
timing=timing, ambient=ambient, \
previous_solver=previous_solver, predictor=predictor, \
solver_name = "nlpsolver_bin_" \
+ str(timing.grid_position_cursor))
nlpsolver_bin.set_solver_max_cpu_time(time_point_to_finish=\
timing.time_points[timing.grid_position_cursor])
nlpsolver_bin.solve()
nlpsolver_bin.reduce_object_memory_size()
timing.sleep_until_time_grid_point("solve_short_term_problem", \
timing.grid_position_cursor)
queue_st.put(nlpsolver_bin)
send_controls(timing, nlpsolver_bin)
nlpsolver_bin.save_results()
def generate_initial_controls(timing, queue_st):
ambient = Ambient(timing=timing)
ambient.update()
state = State()
state.update()
simulator = Simulator( \
timing=timing, ambient=ambient, state=state)
simulator.solve()
queue_st.put(simulator)
simulator.save_results()
def solve_long_term_problem(timing, previous_solver, queue_lt):
ambient = Ambient(timing=timing)
ambient.update()
state = State()
state.update()
predictor = Predictor(timing=timing, ambient=ambient, \
state=state, previous_solver=previous_solver, \
solver_name="predictor_rel")
predictor.solve(n_steps=timing.N_short_term)
timing_next_interval = copy.deepcopy(timing)
timing_next_interval.shift_time_grid()
ambient = Ambient(timing=timing_next_interval)
ambient.update()
nlpsolver_rel = NLPSolverRel( \
timing=timing_next_interval, ambient=ambient, \
previous_solver=previous_solver, predictor=predictor, \
solver_name="nlpsolver_rel")
nlpsolver_rel.solve()
nlpsolver_rel.save_results()
binapprox = BinaryApproximation( \
timing=timing_next_interval, previous_solver=nlpsolver_rel, \
predictor=predictor, solver_name="binapprox")
binapprox.set_solver_max_cpu_time(time_point_to_finish=\
timing_next_interval.time_points[0])
binapprox.solve()
binapprox.save_results()
timing.increment_grid_position_cursor(n_steps=timing.N_short_term -
1)
timing.sleep_until_grid_position_cursor_time_grid_point(
"solve_long_term_problem")
queue_lt.put((timing_next_interval, binapprox))
timing = Timing(startup_time=time.time())
queue_lt = mp.Queue()
queue_st = mp.Queue()
p = mp.Process(target=generate_initial_controls,
args=(timing, queue_st))
p.start()
while timing.mpc_iteration_count < self._MAX_MPC_ITERATIONS:
previous_solver_st = queue_st.get()
timing.define_initial_switch_positions(previous_solver_st)
p = mp.Process(target=solve_long_term_problem, \
args=(timing, previous_solver_st, queue_lt))
p.start()
for k in range(timing.N_short_term - 1):
p = mp.Process(target=solve_short_term_problem, \
args=(timing, previous_solver_st, queue_st))
p.start()
timing.increment_grid_position_cursor()
previous_solver_st = queue_st.get()
# Retrieve results of long-term optimization
timing_next_interval, previous_solver_lt = queue_lt.get()
p = mp.Process(target=solve_short_term_problem, \
args=(timing, previous_solver_lt, queue_st))
p.start()
timing = copy.deepcopy(timing_next_interval)
timing.increment_mpc_iteration_count()
# coding=utf-8
"""
Demonstrates how to use the background scheduler to schedule a job that executes on 3 second
intervals.
"""
from timing import Timing
if __name__ == '__main__':
task = Timing()
#print task
task.start()
import pygame
from pygame.locals import *
from kernels import *
from vector import Vec
#from timing import print_timing
from timing import Timing
timings = Timing()
#@print_timing
@timings
def density_update(sphp, particles):
#brute force
for pi in particles:
pi.dens = 0.
for pj in particles:
r = pi.pos - pj.pos
#print r
if mag(r) > pi.h: continue
#pi.dens += pj.mass*Wpoly6(pi.h, r)
pi.dens += pj.mass * sphp.kernels.poly6(r)
#@print_timing
@timings
def force_update(sphp, particles):
#brute force
rho0 = sphp.rho0
K = sphp.K
# -*- coding: utf-8 -*-
import pytz
from datetime import datetime
import redis
from timing import Timing
from .models import TimingTask
from . import models
time_task = Timing()
# 计算优先级
class TimingPriority():
def calculate(self, name, type, priority, setime, timing_number,
timing_type, url, start_minutes, end_minutes):
# 计算优先级
level = 0
# 为电商类网站
if type == "jd_products" or type == "tb_products":
level += 2
else:
level += 0
# 计算本身的优先级
level = level + int(priority)
#计算时间
tz = pytz.timezone('Asia/Shanghai')
now = datetime.now(tz)
now_time = now.strftime("%m/%d/%Y")
def app(unused_argv):
tf.logging.debug("Starting app")
# Start action server
action_server = ActionServer()
action_server.start()
# Init midi ports, keep direct references to output_ports for
# direct sending without the hub player
if platform.system() == "Windows":
input_ports = [
port for port in midi_hub.get_available_input_ports()
if MIDI_INPUT_PORT in port
]
output_ports = [
port for port in midi_hub.get_available_output_ports()
if MIDI_OUTPUT_PORT in port
]
if len(input_ports) is not 1 or len(output_ports) is not 1:
raise Exception(f"Need exactly 1 midi input ({input_ports}) "
f"matching {MIDI_INPUT_PORT}"
f"and 1 midi output port ({output_ports}) "
f"matching {MIDI_OUTPUT_PORT},"
f"you can use LoopMIDI for that")
else:
input_ports = [MIDI_INPUT_PORT]
output_ports = [MIDI_OUTPUT_PORT]
hub = midi_hub.MidiHub(input_ports, output_ports, None)
output_port = hub._outport.ports[0]
# Panic to stop all current messages (note off everywhere)
[output_port.send(message) for message in mido.ports.panic_messages()]
# Synchronise event for all the loopers, controlled by the metronome
bar_start_event = threading.Event()
# Common stuff
qpm = 80
timing = Timing(qpm)
loopers = []
try:
# Init and start the loopers, they block on the event
drum_looper = SequenceLooper("drums",
bar_start_event,
action_server,
hub,
"drum_kit_rnn",
"drum_kit",
timing,
midi_channel=9,
bar_per_loop=2)
melody_looper = SequenceLooper("melody",
bar_start_event,
action_server,
hub,
"attention_rnn",
"attention_rnn",
timing,
midi_channel=0,
bar_per_loop=4)
loopers.append(drum_looper)
loopers.append(melody_looper)
[looper.start() for looper in loopers]
tf.logging.debug("Loopers started " +
str([("drum_looper", drum_looper),
("melody_looper", melody_looper)]))
# Start metronome (wait to make sure everything is started)
time.sleep(1)
metronome = Metronome(bar_start_event, timing)
loopers.append(metronome)
metronome.start()
tf.logging.debug("Metronome started " +
str([("metronome", metronome)]))
# Wait for the loopers
[looper.join() for looper in loopers]
except KeyboardInterrupt:
print("SIGINT received, stopping action server, loopers and stuff")
action_server.stop()
[looper.stop() for looper in loopers]
return 1
return 0
