def setUp(self):
self.updater = None
self.received_message = None
self.message_count = 0
self.lock = Lock()
)
)
def get_client():
return qbClient(host="localhost", port=8090)
trackers = check_output(["curl -Ns https://raw.githubusercontent.com/XIU2/TrackersListCollection/master/all.txt https://ngosang.github.io/trackerslist/trackers_all_http.txt https://newtrackon.com/api/all | awk '$0'"], shell=True).decode('utf-8')
trackerslist = set(trackers.split("\n"))
trackerslist.remove("")
trackerslist = "\n\n".join(trackerslist)
get_client().application.set_preferences({"add_trackers": f"{trackerslist}"})
DOWNLOAD_DIR = None
BOT_TOKEN = None
download_dict_lock = Lock()
status_reply_dict_lock = Lock()
# Key: update.effective_chat.id
# Value: telegram.Message
status_reply_dict = {}
# Key: update.message.message_id
# Value: An object of Status
download_dict = {}
# key: rss_title
# value: [rss_feed, last_link, last_title, filter]
rss_dict = {}
AUTHORIZED_CHATS = set()
SUDO_USERS = set()
AS_DOC_USERS = set()
AS_MEDIA_USERS = set()
LISTEN_HOST = "0.0.0.0"
LISTEN_PORT = 25555 #the port you will connect to on minecraft client
TARGET_HOST = "127.0.0.1"
TARGET_PORT = 25565 #the port specified on server.properties
DEBUG = False #if true more additional information is printed
#---------------------do not modify---------------------------#
players = 0
datacountbytes = 0
server_status = "offline"
timelefttillup = MINECRAFT_SERVER_STARTUPTIME
lock = Lock()
stopinstances = 0
def stop_empty_minecraft_server():
global server_status, STOP_MINECRAFT_SERVER, players, timelefttillup, stopinstances, lock
with lock:
stopinstances -= 1
if stopinstances > 0 or players > 0 or server_status == "offline":
return
server_status = "offline"
os.system(STOP_MINECRAFT_SERVER)
print('MINECRAFT SERVER IS SHUTTING DOWN!')
timelefttillup = MINECRAFT_SERVER_STARTUPTIME
def __init__(self):
self._lock = Lock()
self._data = dict()
def __init__(self):
self.lock = Lock()
self.elements = []
# Copyright (C) 2007-2018 The NOC Project
# See LICENSE for details
# ---------------------------------------------------------------------
# Python modules
from __future__ import absolute_import
from threading import Lock
# Third-party modules
import creole
# NOC modules
from ..macros.loader import loader as macro_loader
from .base import BaseParser
mw_lock = Lock()
class MacroWrapper(object):
pass
class CreoleParser(BaseParser):
name = "Creole"
macro_wrapper = None
@classmethod
def to_html(cls, kb_entry):
def custom_link_emit(node):
if node.children:
text = html_emitter.emit_children(node)
(select distinct 'LEVEL2' as LEVEL, name_2||','||name_1||','||name_0 as NAME from location_locationlevel l where name_2=UPPER(%s) limit 5)
union (select distinct 'LEVEL1' as LEVEL, name_1||','||name_0 as NAME from location_locationlevel l where name_1=UPPER(%s) limit 5)
union (select distinct 'LEVEL0' as LEVEL, name_0 as NAME from location_locationlevel l where name_0=UPPER(%s) limit 5) order by LEVEL;"""
cursor.execute(
sql,
[lowest_level, lowest_level, lowest_level, lowest_level, lowest_level])
rows = cursor.fetchall()
location_hierarchy = []
for level, location in rows:
location_hierarchy.append(location.split(','))
return location_hierarchy[0] if len(
location_hierarchy) > 0 else lowest_level.split(',')
_tree = None
_tree_lock = Lock()
def get_location_tree():
global _tree
with _tree_lock:
if _tree is None:
_tree = LocationTree()
return _tree
class LocationTree(object):
def get_location_hierarchy_for_geocode(self, lat, long):
row = self._get_location_level_row_for_geo_code(lat, long)
lowest_level = self._get_lowest_level(row)
location = []
return total
def frame_probe(source: Path):
"""Get frame count."""
cmd = [
"ffmpeg", "-hide_banner", "-i",
source.absolute(), "-map", "0:v:0", "-f", "null", "-"
]
r = subprocess.run(cmd, stdout=PIPE, stderr=PIPE)
matches = re.findall(r"frame=\s*([0-9]+)\s",
r.stderr.decode("utf-8") + r.stdout.decode("utf-8"))
return int(matches[-1])
doneFileLock = Lock()
def frame_check(source: Path, encoded: Path, temp, check):
"""Checking is source and encoded video frame count match."""
try:
status_file = Path(temp / 'done.json')
if check:
s1 = frame_probe(source)
doneFileLock.acquire()
with status_file.open() as f:
d = json.load(f)
d['done'][source.name] = s1
with status_file.open('w') as f:
json.dump(d, f)
copy_current_request_context
from flask_socketio import SocketIO, emit, join_room, leave_room, \
close_room, rooms, disconnect
import sqlite3
from flask import request, jsonify
# Set this variable to "threading", "eventlet" or "gevent" to test the
# different async modes, or leave it set to None for the application to choose
# the best option based on installed packages.
async_mode = None
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode=async_mode)
thread = None
thread_lock = Lock()
db_name = '/home/pi/flask/Flask-SocketIO/example/com4016.db'
def create_db():
# 连接
conn = sqlite3.connect(db_name)
c = conn.cursor()
# 创建表
c.execute('''DROP TABLE IF EXISTS TB4016''') # 删除旧表，如果存在（因为这是临时数据）
c.execute('''CREATE TABLE TB4016 (id INTEGER PRIMARY KEY AUTOINCREMENT, port text,insert_time text,device text, step int, valuec float, absval float)''')
# 关闭
conn.close()
def client(queue, port, server_address, args):
if args.client_cpu_affinity >= 0:
os.sched_setaffinity(0, [args.client_cpu_affinity])
import numpy as np
if args.object_type == "numpy":
import numpy as xp
elif args.object_type == "cupy":
import cupy as xp
xp.cuda.runtime.setDevice(args.client_dev)
else:
import cupy as xp
import rmm
rmm.reinitialize(
pool_allocator=True,
managed_memory=False,
initial_pool_size=args.rmm_init_pool_size,
devices=[args.client_dev],
)
xp.cuda.runtime.setDevice(args.client_dev)
xp.cuda.set_allocator(rmm.rmm_cupy_allocator)
ctx = ucx_api.UCXContext(
feature_flags=(
ucx_api.Feature.AM if args.enable_am is True else ucx_api.Feature.TAG,
)
)
worker = ucx_api.UCXWorker(ctx)
register_am_allocators(args, worker)
ep = ucx_api.UCXEndpoint.create(
worker,
server_address,
port,
endpoint_error_handling=True,
)
send_msg = xp.arange(args.n_bytes, dtype="u1")
if args.reuse_alloc:
recv_msg = xp.zeros(args.n_bytes, dtype="u1")
if args.enable_am:
blocking_am_send(worker, ep, send_msg)
blocking_am_recv(worker, ep)
else:
wireup_recv = bytearray(len(WireupMessage))
blocking_send(worker, ep, WireupMessage)
blocking_recv(worker, ep, wireup_recv)
op_lock = Lock()
finished = [0]
outstanding = [0]
def maybe_progress():
while outstanding[0] >= args.max_outstanding:
worker.progress()
def op_started():
with op_lock:
outstanding[0] += 1
def op_completed():
with op_lock:
outstanding[0] -= 1
finished[0] += 1
if args.cuda_profile:
xp.cuda.profiler.start()
times = []
for i in range(args.n_iter + args.n_warmup_iter):
start = clock()
if args.enable_am:
blocking_am_send(worker, ep, send_msg)
blocking_am_recv(worker, ep)
else:
if not args.reuse_alloc:
recv_msg = xp.zeros(args.n_bytes, dtype="u1")
if args.delay_progress:
maybe_progress()
non_blocking_send(worker, ep, send_msg, op_started, op_completed)
maybe_progress()
non_blocking_recv(worker, ep, recv_msg, op_started, op_completed)
else:
blocking_send(worker, ep, send_msg)
blocking_recv(worker, ep, recv_msg)
stop = clock()
if i >= args.n_warmup_iter:
times.append(stop - start)
if args.delay_progress:
while finished[0] != 2 * (args.n_iter + args.n_warmup_iter):
worker.progress()
if args.cuda_profile:
xp.cuda.profiler.stop()
assert len(times) == args.n_iter
bw_avg = format_bytes(2 * args.n_iter * args.n_bytes / sum(times))
bw_med = format_bytes(2 * args.n_bytes / np.median(times))
lat_avg = int(sum(times) * 1e9 / (2 * args.n_iter))
lat_med = int(np.median(times) * 1e9 / 2)
delay_progress_str = (
f"True ({args.max_outstanding})" if args.delay_progress is True else "False"
)
print("Roundtrip benchmark")
print_separator(separator="=")
print_key_value(key="Iterations", value=f"{args.n_iter}")
print_key_value(key="Bytes", value=f"{format_bytes(args.n_bytes)}")
print_key_value(key="Object type", value=f"{args.object_type}")
print_key_value(key="Reuse allocation", value=f"{args.reuse_alloc}")
print_key_value(key="Transfer API", value=f"{'AM' if args.enable_am else 'TAG'}")
print_key_value(key="Delay progress", value=f"{delay_progress_str}")
print_key_value(key="UCX_TLS", value=f"{ucp.get_config()['TLS']}")
print_key_value(key="UCX_NET_DEVICES", value=f"{ucp.get_config()['NET_DEVICES']}")
print_separator(separator="=")
if args.object_type == "numpy":
print_key_value(key="Device(s)", value="CPU-only")
s_aff = (
args.server_cpu_affinity
if args.server_cpu_affinity >= 0
else "affinity not set"
)
c_aff = (
args.client_cpu_affinity
if args.client_cpu_affinity >= 0
else "affinity not set"
)
print_key_value(key="Server CPU", value=f"{s_aff}")
print_key_value(key="Client CPU", value=f"{c_aff}")
else:
print_key_value(key="Device(s)", value=f"{args.server_dev}, {args.client_dev}")
print_separator(separator="=")
print_key_value("Bandwidth (average)", value=f"{bw_avg}/s")
print_key_value("Bandwidth (median)", value=f"{bw_med}/s")
print_key_value("Latency (average)", value=f"{lat_avg} ns")
print_key_value("Latency (median)", value=f"{lat_med} ns")
if not args.no_detailed_report:
print_separator(separator="=")
print_key_value(key="Iterations", value="Bandwidth, Latency")
print_separator(separator="-")
for i, t in enumerate(times):
ts = format_bytes(2 * args.n_bytes / t)
lat = int(t * 1e9 / 2)
print_key_value(key=i, value=f"{ts}/s, {lat}ns")
def server(queue, args):
if args.server_cpu_affinity >= 0:
os.sched_setaffinity(0, [args.server_cpu_affinity])
if args.object_type == "numpy":
import numpy as xp
elif args.object_type == "cupy":
import cupy as xp
xp.cuda.runtime.setDevice(args.server_dev)
else:
import cupy as xp
import rmm
rmm.reinitialize(
pool_allocator=True,
managed_memory=False,
initial_pool_size=args.rmm_init_pool_size,
devices=[args.server_dev],
)
xp.cuda.runtime.setDevice(args.server_dev)
xp.cuda.set_allocator(rmm.rmm_cupy_allocator)
ctx = ucx_api.UCXContext(
feature_flags=(
ucx_api.Feature.AM if args.enable_am is True else ucx_api.Feature.TAG,
)
)
worker = ucx_api.UCXWorker(ctx)
register_am_allocators(args, worker)
# A reference to listener's endpoint is stored to prevent it from going
# out of scope too early.
ep = None
op_lock = Lock()
finished = [0]
outstanding = [0]
def op_started():
with op_lock:
outstanding[0] += 1
def op_completed():
with op_lock:
outstanding[0] -= 1
finished[0] += 1
def _send_handle(request, exception, msg):
# Notice, we pass `msg` to the handler in order to make sure
# it doesn't go out of scope prematurely.
assert exception is None
op_completed()
def _tag_recv_handle(request, exception, ep, msg):
assert exception is None
req = ucx_api.tag_send_nb(
ep, msg, msg.nbytes, tag=0, cb_func=_send_handle, cb_args=(msg,)
)
if req is None:
op_completed()
def _am_recv_handle(recv_obj, exception, ep):
assert exception is None
msg = Array(recv_obj)
ucx_api.am_send_nbx(ep, msg, msg.nbytes, cb_func=_send_handle, cb_args=(msg,))
def _listener_handler(conn_request, msg):
global ep
ep = ucx_api.UCXEndpoint.create_from_conn_request(
worker,
conn_request,
endpoint_error_handling=True,
)
# Wireup before starting to transfer data
if args.enable_am is True:
ucx_api.am_recv_nb(ep, cb_func=_am_recv_handle, cb_args=(ep,))
else:
wireup = Array(bytearray(len(WireupMessage)))
op_started()
ucx_api.tag_recv_nb(
worker,
wireup,
wireup.nbytes,
tag=0,
cb_func=_tag_recv_handle,
cb_args=(ep, wireup),
)
for i in range(args.n_iter + args.n_warmup_iter):
if args.enable_am is True:
ucx_api.am_recv_nb(ep, cb_func=_am_recv_handle, cb_args=(ep,))
else:
if not args.reuse_alloc:
msg = Array(xp.zeros(args.n_bytes, dtype="u1"))
op_started()
ucx_api.tag_recv_nb(
worker,
msg,
msg.nbytes,
tag=0,
cb_func=_tag_recv_handle,
cb_args=(ep, msg),
)
if not args.enable_am and args.reuse_alloc:
msg = Array(xp.zeros(args.n_bytes, dtype="u1"))
else:
msg = None
listener = ucx_api.UCXListener(
worker=worker, port=args.port or 0, cb_func=_listener_handler, cb_args=(msg,)
)
queue.put(listener.port)
while outstanding[0] == 0:
worker.progress()
# +1 to account for wireup message
if args.delay_progress:
while finished[0] < args.n_iter + args.n_warmup_iter + 1 and (
outstanding[0] >= args.max_outstanding
or finished[0] + args.max_outstanding
>= args.n_iter + args.n_warmup_iter + 1
):
worker.progress()
else:
while finished[0] != args.n_iter + args.n_warmup_iter + 1:
worker.progress()
def __init__(self, filename, unsafe=False):
self.unsafe = unsafe
self.filename = filename
self._lock = Lock()
self.ts_refreshed = None
self.ts_refreshed_utc = None
class MapManager:
map_lock = Lock()
robot_pose_lock = Lock()
def __init__(self, robot_radius, robot_fov_radius, static_map_topic, robot_occ_grid_topic, push_poses_topic,
simulated_pose_topic, simulated_fov_pointcloud_topic):
# Get parameters
self.static_map_topic = static_map_topic
self.robot_occ_grid_topic = robot_occ_grid_topic
self.push_poses_topic = push_poses_topic
self.simulated_pose_topic = simulated_pose_topic
self.simulated_fov_pointcloud_topic = simulated_fov_pointcloud_topic
# Declare common parameters
self.static_map = None
self.init_map = None
self.multilayered_map = None
self.has_free_space_been_created = False
self.current_robot_pose = None
# Create subscribers
rospy.Subscriber(self.static_map_topic, OccupancyGrid, self._static_map_callback)
rospy.Subscriber(self.simulated_fov_pointcloud_topic, PointCloud, self._simulated_fov_pointcloud_callback)
rospy.Subscriber(self.simulated_pose_topic, PoseStamped, self._simulated_pose_callback)
# Create publishers
self.robot_occ_grid_pub = rospy.Publisher(self.robot_occ_grid_topic, OccupancyGrid, queue_size=1)
self.push_poses_pub = rospy.Publisher(self.push_poses_topic, PoseArray, queue_size=1)
# Initialize map
while self.static_map is None:
rospy.sleep(0.2)
self.robot_metadata = RobotMetaData(robot_radius, robot_fov_radius, self.static_map.info.resolution)
self.init_map = MultilayeredMap(self.static_map, self.robot_metadata)
self.multilayered_map = copy.deepcopy(self.init_map)
def _static_map_callback(self, new_map):
# For the moment, we don't want to manage new static maps for the
# node's life duration
if self.static_map is None:
self.static_map = new_map
def _simulated_pose_callback(self, pose):
MapManager.robot_pose_lock.acquire()
self.current_robot_pose = pose
MapManager.robot_pose_lock.release()
def _simulated_fov_pointcloud_callback(self, pointcloud):
MapManager.robot_pose_lock.acquire()
robot_pose_copy = copy.deepcopy(self.current_robot_pose)
MapManager.robot_pose_lock.release()
if self.multilayered_map is not None and robot_pose_copy is not None:
if (self.current_robot_pose.header.stamp.to_nsec() <= pointcloud.header.stamp.to_nsec()):
MapManager.map_lock.acquire()
self.multilayered_map.update_from_point_cloud(pointcloud, robot_pose_copy)
MapManager.map_lock.release()
self.publish_ros_merged_occ_grid()
def get_init_map(self):
self.publish_ros_static_inflated_grid()
return copy.deepcopy(self.init_map) # We make a copy to be sure its not changed
def get_map_copy(self):
MapManager.map_lock.acquire()
map_copy = copy.deepcopy(self.multilayered_map)
MapManager.map_lock.release()
return map_copy
# FIXME DEPRECATED
def manually_add_obstacle(self, obstacle):
self.multilayered_map.manually_add_obstacle(obstacle)
def publish_ros_merged_occ_grid(self):
ros_merged_occ_grid = Utils.convert_matrix_to_ros_occ_grid(self.multilayered_map.merged_occ_grid, self.static_map.header, self.static_map.info)
Utils.publish_once(self.robot_occ_grid_pub, ros_merged_occ_grid)
def publish_ros_static_inflated_grid(self):
ros_merged_occ_grid = Utils.convert_matrix_to_ros_occ_grid(self.multilayered_map.inflated_static_occ_grid, self.static_map.header, self.static_map.info)
Utils.publish_once(self.robot_occ_grid_pub, ros_merged_occ_grid)
def publish_all_push_poses(self):
all_push_poses = PoseArray()
all_push_poses.header = self.static_map.header
all_push_poses.header.stamp = rospy.Time.now()
for obstacle_id, obstacle in self.multilayered_map.obstacles.items():
for push_pose in obstacle.push_poses:
all_push_poses.poses = all_push_poses.poses + [push_pose.pose]
Utils.publish_once(self.push_poses_pub, all_push_poses)
def __init__(self):
self.__list = []
self.__lock = Lock()
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
private_key=None,
private_key_password=None,
user_sig_handler=None,
request_kwargs=None,
persistence=None,
defaults=None,
use_context=False,
dispatcher=None,
base_file_url=None):
if dispatcher is None:
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if (private_key is not None) and (bot is not None):
raise ValueError('`bot` and `private_key` are mutually exclusive')
else:
if bot is not None:
raise ValueError('`dispatcher` and `bot` are mutually exclusive')
if persistence is not None:
raise ValueError('`dispatcher` and `persistence` are mutually exclusive')
if workers is not None:
raise ValueError('`dispatcher` and `workers` are mutually exclusive')
if use_context != dispatcher.use_context:
raise ValueError('`dispatcher` and `use_context` are mutually exclusive')
self.logger = logging.getLogger(__name__)
if dispatcher is None:
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(token,
base_url,
base_file_url=base_file_url,
request=self._request,
private_key=private_key,
private_key_password=private_key_password,
defaults=defaults)
self.update_queue = Queue()
self.job_queue = JobQueue()
self.__exception_event = Event()
self.persistence = persistence
self.dispatcher = Dispatcher(self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event,
persistence=persistence,
use_context=use_context)
self.job_queue.set_dispatcher(self.dispatcher)
else:
con_pool_size = dispatcher.workers + 4
self.bot = dispatcher.bot
if self.bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
self.update_queue = dispatcher.update_queue
self.__exception_event = dispatcher.exception_event
self.persistence = dispatcher.persistence
self.job_queue = dispatcher.job_queue
self.dispatcher = dispatcher
self.user_sig_handler = user_sig_handler
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
# Just for passing to WebhookAppClass
self._default_quote = defaults.quote if defaults else None
import sys
import os
import re
import socket
import urllib2
import urlparse
import pickle
import random
from time import time, sleep
from threading import Thread, Lock, Semaphore
progs = {}
progsAnalizados = 0
totalProgramas = 0
lockCB = Lock()
lockProgs = Lock()
conexiones = Semaphore(10)
threads = []
def dl(url):
#print url
for i in range(2): #n intentos
conexiones.acquire()
try:
try:
f = urllib2.urlopen(url)
html = f.read()
return html
except IOError:
def __init__(self):
self._balance = 0
self._lock = Lock()
from redis.client import Script, StrictRedis
from redis.connection import ConnectionPool, Encoder
from redis.exceptions import ConnectionError, BusyLoadingError
from rediscluster import StrictRedisCluster
from sentry import options
from sentry.exceptions import InvalidConfiguration
from sentry.utils import warnings
from sentry.utils.warnings import DeprecatedSettingWarning
from sentry.utils.versioning import Version, check_versions
from sentry.utils.compat import map
logger = logging.getLogger(__name__)
_pool_cache = {}
_pool_lock = Lock()
def _shared_pool(**opts):
if "host" in opts:
key = "%s:%s/%s" % (opts["host"], opts["port"], opts["db"])
else:
key = "%s/%s" % (opts["path"], opts["db"])
pool = _pool_cache.get(key)
if pool is not None:
return pool
with _pool_lock:
pool = _pool_cache.get(key)
if pool is not None:
return pool
pool = ConnectionPool(**opts)
def __init__(self):
mpv_config = conffile.get(APP_NAME,"mpv.conf", True)
input_config = conffile.get(APP_NAME,"input.conf", True)
extra_options = {}
self._video = None
self._lock = RLock()
self._finished_lock = Lock()
self.last_update = Timer()
self.__part = 1
self.timeline_trigger = None
self.action_trigger = None
self.external_subtitles = {}
self.external_subtitles_rev = {}
self.url = None
self.evt_queue = Queue()
self.is_in_intro = False
self.intro_has_triggered = False
if is_using_ext_mpv:
extra_options = {
"start_mpv": settings.mpv_ext_start,
"ipc_socket": settings.mpv_ext_ipc,
"mpv_location": settings.mpv_ext_path,
"player-operation-mode": "cplayer"
}
# todo figure out how to put these in a file
extra_options = {
'script-opts': 'osc-layout=slimbox,osc-deadzonesize=.9,osc-valign=1.05',
}
self._player = mpv.MPV(input_default_bindings=True, input_vo_keyboard=True,
input_media_keys=True, include=mpv_config, input_conf=input_config,
log_handler=mpv_log_handler, loglevel=settings.mpv_log_level,
**extra_options)
self.menu = OSDMenu(self)
self.auto_insert = False
def on_new_sub(name, text):
if not self.auto_insert:
return
if not text or not text.strip():
return
pyperclip.copy(text.replace('\n', ' '))
self._player.observe_property('sub-text', on_new_sub)
if hasattr(self._player, 'osc'):
self._player.osc = settings.enable_osc
else:
log.warning("This mpv version doesn't support on-screen controller.")
# Wrapper for on_key_press that ignores None.
def keypress(key):
def wrapper(func):
if key is not None:
self._player.on_key_press(key)(func)
return func
return wrapper
@self._player.on_key_press('CLOSE_WIN')
@self._player.on_key_press('STOP')
@keypress(settings.kb_stop)
def handle_stop():
self.stop()
self.timeline_handle()
@keypress(settings.kb_prev)
def handle_prev():
self.put_task(self.play_prev)
@keypress(settings.kb_next)
def handle_next():
self.put_task(self.play_next)
@self._player.on_key_press('PREV')
@self._player.on_key_press('XF86_PREV')
def handle_media_prev():
if settings.media_key_seek:
self._player.command("seek", -15)
else:
self.put_task(self.play_prev)
@self._player.on_key_press('NEXT')
@self._player.on_key_press('XF86_NEXT')
def handle_media_next():
if settings.media_key_seek:
if self.is_in_intro:
self.skip_intro()
else:
self._player.command("seek", 30)
else:
self.put_task(self.play_next)
@keypress(settings.kb_watched)
def handle_watched():
self.put_task(self.watched_skip)
@keypress(settings.kb_unwatched)
def handle_unwatched():
self.put_task(self.unwatched_quit)
@keypress(settings.kb_menu)
def menu_open():
if not self.menu.is_menu_shown:
self.menu.show_menu()
else:
self.menu.hide_menu()
@keypress(settings.kb_menu_esc)
def menu_back():
if self.menu.is_menu_shown:
self.menu.menu_action('back')
else:
self._player.command('set', 'fullscreen', 'no')
@keypress(settings.kb_menu_ok)
def menu_ok():
self.menu.menu_action('ok')
@keypress(settings.kb_menu_left)
def menu_left():
if self.menu.is_menu_shown:
self.menu.menu_action('left')
else:
self._player.command("seek", settings.seek_left)
@keypress(settings.kb_menu_right)
def menu_right():
if self.menu.is_menu_shown:
self.menu.menu_action('right')
else:
if self.is_in_intro:
self.skip_intro()
else:
self._player.command("seek", settings.seek_right)
@keypress(settings.kb_menu_up)
def menu_up():
if self.menu.is_menu_shown:
self.menu.menu_action('up')
else:
if self.is_in_intro:
self.skip_intro()
else:
self._player.command("seek", settings.seek_up)
@keypress(settings.kb_menu_down)
def menu_down():
if self.menu.is_menu_shown:
self.menu.menu_action('down')
else:
self._player.command("seek", settings.seek_down)
@keypress(settings.kb_pause)
def handle_pause():
if self.menu.is_menu_shown:
self.menu.menu_action('ok')
else:
self.toggle_pause()
# This gives you an interactive python debugger prompt.
@keypress(settings.kb_debug)
def handle_debug():
import pdb
pdb.set_trace()
@self._player.on_key_press('ctrl+c')
def copy_current_sub():
try:
sub = self._player.sub_text
pyperclip.copy(sub)
except AttributeError:
pass # no subtitle available.
def copy_screenshot(subtitles=True):
includes = 'subtitles' if subtitles else 'video'
from io import BytesIO
import win32clipboard
image = self._player.screenshot_raw(includes=includes)
output = BytesIO()
image.convert("RGB").save(output, "BMP")
data = output.getvalue()[14:]
output.close()
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardData(win32clipboard.CF_DIB, data)
win32clipboard.CloseClipboard()
@self._player.on_key_press('ctrl+s')
def copy_current_image():
copy_screenshot(subtitles=True)
@self._player.on_key_press('ctrl+shift+s')
def copy_current_image():
copy_screenshot(subtitles=False)
@self._player.on_key_press('ctrl+v')
def output_audio():
import subprocess
import string
import unicodedata
sub_delay = round(self._player.sub_delay, 4) # round b/c of weird mpv precision
sub_start = self._player.sub_start + sub_delay
if sub_start:
print("Outputting current subtitle...")
valid_fn_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
fn_dirty = "%s - %s" % (self._player.media_title, str(int(sub_start * 1000)))
fn = unicodedata.normalize('NFKD', fn_dirty).encode('ASCII', 'ignore')
fn = ''.join(chr(c) for c in fn if chr(c) in valid_fn_chars)
aid = [x for x in self._player.track_list
if x.get("type") == "audio" and x.get("selected")][0].get("id")
subprocess.Popen([
'mpv',
self.url,
'-o',
'%s.mp3' % fn,
'--no-video',
'--start=%s' % sub_start,
'--end=%s' % (self._player.sub_end + sub_delay),
'--aid=%s' % aid,
])
self._player.screenshot_to_file("%s.png" % fn, includes='video')
with open('%s.txt' % fn, 'w+', encoding='utf-8') as f:
f.write(self._player.sub_text)
@self._player.on_key_press('ctrl+a')
def toggle_auto_insert():
self.auto_insert = not self.auto_insert
self._player.show_text('Auto insert %s' % ("on" if self.auto_insert else "off"))
# Fires between episodes.
@self._player.property_observer('eof-reached')
def handle_end(_name, reached_end):
if self._video and reached_end:
has_lock = self._finished_lock.acquire(False)
self.put_task(self.finished_callback, has_lock)
# Fires at the end.
@self._player.event_callback('idle')
def handle_end_idle(event):
if self._video:
has_lock = self._finished_lock.acquire(False)
self.put_task(self.finished_callback, has_lock)
default=9995,
help='Port for communicating with the client; used only by the servers'
)
parser.add_argument("--trainDataset",
default='profilerDataADF.csv',
help='Path to the pretraining dataset')
args = sys.argv[1:]
args = parser.parse_args(args)
df = loadTrainingDataset(args.trainDataset)
global_mod = train(df)
per_device_models = {}
mutex = Lock()
conn = openServerConn(port=args.clientPort)
while True:
with mutex:
stats = getMessage(conn)
#prediction or learn stats?
if (stats[1] == "0"):
batchSize = makePrediction(global_mod, stats)
print("new device prediction for " + stats[3] + " : ",
batchSize)
sendMessage(conn, [batchSize])
else:
df = storeStats(df, stats)
global_mod = train(df)
print("update from " + stats[3] + ", " + stats[12])
def __init__(self): self.__lock = Lock() self.__failList = dict() self.__maxRetry = 3 self.__maxTime = 600 self.__failTotal = 0
def __init__(self):
# ---------------------------------------------------------------------------------------------
# define the mutex to avoid concurency
# ---------------------------------------------------------------------------------------------
self.inputLock = threading.Lock()
self.outputLock = threading.Lock()
# ---------------------------------------------------------------------------------------------
# message sequences
# ---------------------------------------------------------------------------------------------
# catheter control commandes in speed mode
self.catheterMoveInstructionSequence = []
# guidewire control commandes in speed mode
self.guidewireProgressInstructionSequence = []
self.guidewireRotateInstructionSequence = []
# guidewire control commandes in position mode
self.guidewireMovingDistance = []
# to be verified...
self.contrastMediaPushInstructionSequence = []
self.injectionCommandSequence = []
self.retractInstructionSequence = []
# forcefeedback
self.forcefeedbackSequence = []
# push catheter and guidewire together
self.catheter_guidewire_push_sequence = []
# system control
self.closeSessionSequence = []
self.sensingParameterSequence = []
# ---------------------------------------------------------------------------------------------
# system status variable
# ---------------------------------------------------------------------------------------------
self.systemStatus = True
# ------------------------------------------------------------------------------------------------------------
# control variables:
#
# guidewireControlState
# where
# 0: uncontrolled,
# 1: valid,
# 2: nonvalid_prepare_for_push,
# 3: nonvalid_prepare_for_drawn,
# 4: exception
#
# catheterControlState
# where
# 0: uncontrolled,
# 1: valid
# 2: nonvalid_beyond_guidewire
# 3: exception
# contrastMediaControlState
# where
# 0: uncontrolled,
# 1: valid
# 2: exception
self.guidewireControlState = 0
self.catheterControlState = 0
self.contrastMediaControlState = 0
self.globalContrastMediaVolumn = 0
self.globalForceFeedback = 0.0
self.globalTorqueFeedback = 0.0
self.globalDistanceFromChuckToCatheter = 0.0
self.globalTelescopicRodLength = 0.0
self.globalDistanceFromCatheterToGuidewire = 0.0
self.globalGuidewireAngle = 0.0
self.globalTranslationVelocity = 0.0
self.globalRotationVelocity = 0.0
self.globalDecisionMade = 1
informationAnalysisTask = threading.Thread(
None, self.coreInformationAnalysis)
informationAnalysisTask.start()
decisionMaking_task = threading.Thread(None, self.decisionMaking)
decisionMaking_task.start()
self.storingDataLock = Lock()
storingDataTask = threading.Thread(None, self.storingData)
storingDataTask.start()
def __init__(self, tensorboard_dir):
self.tensorboard_writter = SummaryWriter(tensorboard_dir,
flush_secs=10,
max_queue=1)
self._mutex_add = Lock()
def __init__(self, cap=10): #cap for queue basic value of 10 can be change
self.queue = [] # create a list
self.qLock = Lock() # lock
self.full = Semaphore(0) #counting lock to see if its full starts at 0
self.empty = Semaphore(
cap) #counting lock to see if its empty starts at cap
def __init__(self, network,
settings_cache,
current_chain_head_func,
current_root_func,
endpoint=None,
peering_mode='static',
initial_seed_endpoints=None,
initial_peer_endpoints=None,
minimum_peer_connectivity=3,
maximum_peer_connectivity=10,
topology_check_frequency=1
):
"""Constructor for the Gossip object. Gossip defines the
overlay network above the lower level networking classes.
Args:
network (networking.Interconnect): Provides inbound and
outbound network connections.
settings_cache (state.SettingsCache): A cache for on chain
settings.
current_chain_head_func (function): returns the current chain head.
current_root_func (function): returns the current state root hash
for the current chain root.
endpoint (str): The publically accessible zmq-style uri
endpoint for this validator.
peering_mode (str): The type of peering approach. Either 'static'
or 'dynamic'. In 'static' mode, no attempted topology
buildout occurs -- the validator only attempts to initiate
peering connections with endpoints specified in the
peer_list. In 'dynamic' mode, the validator will first
attempt to initiate peering connections with endpoints
specified in the peer_list and then attempt to do a
topology buildout starting with peer lists obtained from
endpoints in the seeds_list. In either mode, the validator
will accept incoming peer requests up to max_peers.
initial_seed_endpoints ([str]): A list of initial endpoints
to attempt to connect and gather initial topology buildout
information from. These are specified as zmq-compatible
URIs (e.g. tcp://hostname:port).
initial_peer_endpoints ([str]): A list of initial peer endpoints
to attempt to connect and peer with. These are specified
as zmq-compatible URIs (e.g. tcp://hostname:port).
minimum_peer_connectivity (int): If the number of connected
peers is below this threshold, the topology builder will
continue to attempt to identify new candidate peers to
connect with.
maximum_peer_connectivity (int): The validator will reject
new peer requests if the number of connected peers
reaches this threshold.
topology_check_frequency (int): The time in seconds between
topology update checks.
"""
self._peering_mode = peering_mode
self._lock = Lock()
self._network = network
self._endpoint = endpoint
self._initial_seed_endpoints = initial_seed_endpoints \
if initial_seed_endpoints else []
self._initial_peer_endpoints = initial_peer_endpoints \
if initial_peer_endpoints else []
self._minimum_peer_connectivity = minimum_peer_connectivity
self._maximum_peer_connectivity = maximum_peer_connectivity
self._topology_check_frequency = topology_check_frequency
self._settings_cache = settings_cache
self._current_chain_head_func = current_chain_head_func
self._current_root_func = current_root_func
self._topology = None
self._peers = {}
f"Element has been put back into the queue after {delay} seconds",
extra={"area": "main"},
)
queue.put(items)
####################################
# Global variables
####################################
# This variables keeps a snapshot of the current state of all the things
# of the platform
locationsStatus = defaultdict(location_status.LocationStatus)
devices = defaultdict(Device)
values = defaultdict(Value)
deviceslock = Lock()
locationsStatuslock = Lock()
modules = {
"switch": switch_logic.Switch,
"thermostat": thermostat_logic.Thermostat,
"Toogle": toogle_logic.Toogle,
}
# Keep track of all the subscriptions. In case of reconnection they
# will be necessary to restore the subscriptions.
# I do not trust the clean_session=False because it does not
# guarantee that all the subscriptions will be restored, this wrong
# behaviour has been proved by stoping the broker and restart it again
subscriptionsList = []
def __init__(self):
self.lock = Lock()
self.data = {} # {'session_id': [{time, content, score}]}
self.last_update = {} # {'session_id': datetime}
from mindspore._checkparam import check_input_data, Validator
from mindspore.compression.export import quant_export
from mindspore.parallel._tensor import _load_tensor
from mindspore.parallel._utils import _infer_rank_list, _remove_repeated_slices
tensor_to_ms_type = {"Int8": mstype.int8, "Uint8": mstype.uint8, "Int16": mstype.int16, "Uint16": mstype.uint16,
"Int32": mstype.int32, "Uint32": mstype.uint32, "Int64": mstype.int64, "Uint64": mstype.uint64,
"Float16": mstype.float16, "Float32": mstype.float32, "Float64": mstype.float64,
"Bool": mstype.bool_}
tensor_to_np_type = {"Int8": np.int8, "Uint8": np.uint8, "Int16": np.int16, "Uint16": np.uint16,
"Int32": np.int32, "Uint32": np.uint32, "Int64": np.int64, "Uint64": np.uint64,
"Float16": np.float16, "Float32": np.float32, "Float64": np.float64, "Bool": np.bool_}
_ckpt_mutex = Lock()
SLICE_SIZE = 512 * 1024 * 1024
def _special_process_par(par, new_par):
"""
Processes the special condition.
Like (12,2048,1,1)->(12,2048), this case is caused by GE 4 dimensions tensor.
"""
par_shape_len = len(par.data.shape)
new_par_shape_len = len(new_par.data.shape)
delta_len = new_par_shape_len - par_shape_len
delta_i = 0
for delta_i in range(delta_len):
if new_par.data.shape[par_shape_len + delta_i] != 1:
def __init__(self):
self.lock = Lock()
self.tokens = set()
class ExecutingMountebankServer(MountebankServer):
"""A Mountebank mock server, running one or more imposters, one for each domain being mocked.
Test will look like::
def test_an_imposter(mock_server):
mb = ExecutingMountebankServer()
imposter = Imposter(Stub(Predicate(path='/test'),
Response(body='sausages')),
record_requests=True)
with mb(imposter) as s:
r = requests.get('{0}/test'.format(imposter.url))
assert_that(r, is_response().with_status_code(200).and_body("sausages"))
assert_that(s, had_request(path='/test', method="GET"))
mb.close()
The mountebank server will be started when this class is instantiated, and needs to be closed if it's not to be
left running. Consider using the :meth:`mock_server` pytest fixture, which will take care of this for you.
:param executable: Optional, alternate location for the Mountebank executable.
:param port: Server port.
:param timeout: How long to wait for the Mountebank server to start.
:param debug: Start the server in debug mode, which records all requests. This needs to be `True` for the
:py:func:`mbtest.matchers.had_request` matcher to work.
:param allow_injection: Allow JavaScript injection. If `True`, `local_only` should also be `True`,as per
`Mountebank security <http://www.mbtest.org/docs/security>`_.
:param local_only: Accept request only from localhost.
:param data_dir: Persist all operations to disk, in this directory.
"""
running = set() # type: Set[int]
start_lock = Lock()
def __init__(
self,
executable: Union[str, Path] = DEFAULT_MB_EXECUTABLE,
port: int = 2525,
timeout: int = 5,
debug: bool = True,
allow_injection: bool = True,
local_only: bool = True,
data_dir: Union[str, None] = ".mbdb",
) -> None:
super(ExecutingMountebankServer, self).__init__(port)
with self.start_lock:
if self.server_port in self.running:
raise MountebankPortInUseException(
"Already running on port {0}.".format(self.server_port))
try:
options = self._build_options(port, debug, allow_injection,
local_only, data_dir)
self.mb_process = subprocess.Popen([executable] +
options) # nosec
self._await_start(timeout)
self.running.add(port)
logger.info("Spawned mb process %s on port %s.",
self.mb_process.pid, self.server_port)
except OSError:
logger.error(
"Failed to spawn mb process with executable at %s. Have you installed Mountebank?",
executable,
)
raise
@staticmethod
def _build_options(port: int, debug: bool, allow_injection: bool,
local_only: bool, data_dir: Union[str, None]):
options = [
"start",
"--port",
str(port),
] # type: List[str]
if debug:
options.append("--debug")
if allow_injection:
options.append("--allowInjection")
if local_only:
options.append("--localOnly")
if data_dir:
options += [
"--datadir",
data_dir,
]
return options
def _await_start(self, timeout: int) -> None:
start_time = time.time()
while time.time() - start_time < timeout:
try:
requests.get(self.server_url, timeout=1).raise_for_status()
started = True
break
except RequestException:
started = False
time.sleep(0.1)
if not started:
raise MountebankTimeoutError(
"Mountebank failed to start within {0} seconds.".format(
timeout))
logger.debug("Server started at %s.", self.server_url)
def close(self) -> None:
self.mb_process.terminate()
self.mb_process.wait()
self.running.remove(self.server_port)
logger.info(
"Terminated mb process %s on port %s status %s.",
self.mb_process.pid,
self.server_port,
self.mb_process.returncode,
)
