from jupyter_server.utils import url_path_join
# List of dependencies needed for this plugin.
pytest_plugins = [
"pytest_tornasync",
# Once the chunk below moves to Jupyter Core, we'll uncomment
# This plugin and use the fixtures directly from Jupyter Core.
# "jupyter_core.pytest_plugin"
]
import asyncio
if os.name == "nt" and sys.version_info >= (3, 7):
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy() # type:ignore[attr-defined]
)
# ============ Move to Jupyter Core =============
def mkdir(tmp_path, *parts):
path = tmp_path.joinpath(*parts)
if not path.exists():
path.mkdir(parents=True)
return path
@pytest.fixture
def jp_home_dir(tmp_path):
def main():
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
tornado.options.parse_command_line()
app = Application()
app.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
import os
from aiohttp import web
from aiohttp.test_utils import AioHTTPTestCase, unittest_run_loop
from meross_iot.controller.mixins.light import LightMixin
from meross_iot.controller.mixins.system import SystemAllMixin
from meross_iot.controller.mixins.toggle import ToggleXMixin
from meross_iot.manager import MerossManager
from meross_iot.model.enums import OnlineStatus
from tests import async_get_client
if os.name == 'nt':
import asyncio
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
else:
import asyncio
class TestUpdate(AioHTTPTestCase):
async def get_application(self):
return web.Application()
async def setUpAsync(self):
# Wait some time before next test-burst
await asyncio.sleep(10)
self.meross_client, self.requires_logout = await async_get_client()
# Look for a device to be used for this test
self.meross_manager = MerossManager(http_client=self.meross_client)
def configure_windows_event_loop() -> None:
if sys.version_info >= (3, 8) and platform.system() == "Windows":
import asyncio
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()
) # type: ignore[attr-defined]
def main():
try:
settings = toml.load(open('../settings.toml', 'r'))
except ValueError:
print('Failed to parse settings.toml')
settings = {'auto_update': True}
if settings['auto_update']:
check_for_update()
if sys.version_info[0] == 3 and sys.version_info[
1] >= 8 and sys.platform.startswith('win'):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
if len(sys.argv) > 1:
parser = argparse.ArgumentParser()
parser.add_argument(
'-d',
'--date',
type=str,
metavar='',
help=
'Date or date range in format YYYY/MM/DD e.g 2020/01/19-2020/05/01'
)
parser.add_argument('-c',
'--course',
type=str,
metavar='',
help='Numeric course code e.g 20')
parser.add_argument('-r',
'--region',
type=str,
metavar='',
help='Region code e.g ire')
parser.add_argument(
'-y',
'--year',
type=str,
metavar='',
help='Year or year range in format YYYY e.g 2018-2020')
parser.add_argument('-t',
'--type',
type=str,
metavar='',
help='Race type [flat/jumps]')
args = parser.parse_args()
if args.date and any([args.course, args.year, args.type]):
print(
'Arguments not compatible with -d flag.\n\nFormat:\n\t\t-d YYYY/MM/DD -r [REGION CODE]\n\nExamples:\n\t\t-d 2020/01/19 -r gb\n'
)
print(
'When scraping by date, if no region code is specified, all available races will be scraped by default.'
)
sys.exit()
if args.date:
if not check_date(args.date):
sys.exit(
print(
'Invalid date.\n\nFormat:\n\t\tYYYY/MM/DD\n\t\tYYYY/MM/DD-YYYY/MM/DD\n\nExamples:\n\t\t2015/03/27\n\t\t2020/01/19-2020/05/01'
))
if args.region:
if not valid_region(args.region):
sys.exit(
print(
'Invalid region code.\n\nExamples:\n\t\t-r gb\n\t\t-r ire'
))
region = args.region
else:
region = 'all'
dates = get_dates(args.date)
races = get_race_urls_date(dates, region)
scrape_races(races, region, args.date.replace('/', '_'), '')
sys.exit()
if args.course:
if not valid_course(args.course):
sys.exit(
print(
'Invalid course code.\n\nExamples:\n\t\t-c 20\n\t\t-c 1083'
))
if args.region:
if not valid_region(args.region):
sys.exit(
print(
'Invalid region code.\n\nExamples:\n\t\t-r gb\n\t\t-r ire'
))
years = parse_years(args.year) if args.year else []
if not years or not valid_years(years):
sys.exit(
print(
'Invalid year.\n\nFormat:\n\t\tYYYY\n\nExamples:\n\t\t-y 2015\n\t\t-y 2012-2017'
))
if not args.type or args.type not in ['flat', 'jumps']:
sys.exit(
print(
'Invalid race type.\n\nMust be either flat or jumps.\n\nExamples:\n\t\t-t flat\n\t\t-t jumps'
))
if not args.course and not args.region:
sys.exit(print('Must supply a course or region code.'))
target = args.region if args.region else course_name(args.course)
if args.region:
tracks = [course for course in courses(args.region)]
else:
tracks = [(args.course, course_name(args.course))]
# races = get_race_urls(tracks, years, args.type, x_y())
races = get_race_urls_async(tracks, years, args.type, x_y())
scrape_races(races, target, args.year, args.type)
sys.exit()
try:
import readline
completions = Completer([
'courses', 'regions', 'options', 'help', 'quit', 'exit', 'clear',
'flat', 'jumps', 'date'
])
readline.set_completer(completions.complete)
readline.parse_and_bind('tab: complete')
except ModuleNotFoundError: # windows
pass
while True:
args = input('[rpscrape]> ').lower().strip()
parse_args([arg.strip() for arg in args.split()])
from mesa import Agent, Model
from mesa.time import BaseScheduler
from mesa.space import MultiGrid
import random
import time
import asyncio
from minimax import minimax
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy(
)) #remove this line if you are not running windows
d = 6 #set this to a multiple of 3 to create a d x d board
depth = 1
weight = 1
eval_weight = 1
def is_valid_position(pos):
'''
Makes sure we don't enter letters, an incorrect number of inputs, or an out of bounds position
'''
agents = []
coord = pos.split()
if not coord or len(coord) != 2:
return False
try:
x, y = int(coord[0]) - 1, int(coord[1]) - 1
except:
return False
def _configure_async_test_loop():
if sys.version_info[0] == 3 and sys.version_info[
1] >= 8 and sys.platform.startswith('win'):
# use WindowsSelectorEventLoopPolicy to avoid aiohttp connexion close warnings
# https://github.com/encode/httpx/issues/914#issuecomment-622586610
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
def write_to_files_with_ext_json(file_name, result_slice_up_to_ten):
"""
Функция создает json файлы и записывает в них переданный слайс из списка словарей компаний
:param file_name: путь к файлу
:param result_slice_up_to_ten: слайс из всего списка словарей, отсортированных по какому то значению ключа
"""
with open(file_name, "w") as f:
json.dump(result_slice_up_to_ten, f, indent=4)
if __name__ == "__main__":
start_time = time.time()
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy()
) # для винды нужно выбрать эту policy, иначе будет ошибка EventLoop is closed
res = asyncio.run(main())
top_ten_price = sorted(res, key=lambda k: k["price"], reverse=True)[:10]
write_to_files_with_ext_json(
"Task01/JSON`s for task01/Top_ten_companies_by_price.json",
top_ten_price)
low_top_PE = sorted(res, key=lambda k: k["P/E"])[:10]
write_to_files_with_ext_json(
"Task01/JSON`s for task01/Low_top_ten_companies_by_PE.json",
low_top_PE)
top_ten_growth = sorted(res, key=lambda k: k["growth"], reverse=True)[:10]
write_to_files_with_ext_json(
def ws_gateway():
# allow user to bypass the IP address auto-discovery. This is necessary if the component resides on a computer
# other than the computing running the backplane.
parser = argparse.ArgumentParser()
parser.add_argument("-b",
dest="back_plane_ip_address",
default="None",
help="None or IP address used by Back Plane")
# allow the user to specify a name for the component and have it shown on the console banner.
# modify the default process name to one you wish to see on the banner.
# change the default in the derived class to set the name
parser.add_argument("-m",
dest="subscription_list",
default="from_arduino_gateway, "
"from_esp8266_gateway, "
"from_rpi_gateway, "
"from_microbit_gateway"
"from_picoboard_gateway"
"from_cpx_gateway",
nargs='+',
help="A space delimited list of topics")
parser.add_argument("-i",
dest="server_ip_port",
default="9000",
help="Set the WebSocket Server IP Port number")
parser.add_argument("-l",
dest="log",
default="False",
help="Set to True to turn logging on.")
parser.add_argument("-n",
dest="process_name",
default="WebSocket Gateway",
help="Set process name in banner")
parser.add_argument("-p",
dest="publisher_port",
default='43124',
help="Publisher IP port")
parser.add_argument("-s",
dest="subscriber_port",
default='43125',
help="Subscriber IP port")
args = parser.parse_args()
subscription_list = args.subscription_list
if len(subscription_list) > 1:
subscription_list = args.subscription_list.split(',')
kw_options = {
'publisher_port': args.publisher_port,
'subscriber_port': args.subscriber_port,
'process_name': args.process_name,
'server_ip_port': args.server_ip_port,
}
log = args.log.lower()
if log == 'false':
log = False
else:
log = True
if args.back_plane_ip_address != 'None':
kw_options['back_plane_ip_address'] = args.back_plane_ip_address
# get the event loop
# this is for python 3.8
if sys.platform == 'win32':
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
loop = asyncio.get_event_loop()
try:
WsGateway(subscription_list, **kw_options, event_loop=loop)
except KeyboardInterrupt:
for task in asyncio.Task.all_tasks():
task.cancel()
loop.stop()
loop.close()
sys.exit(0)
def main():
# We need to install the asyncio reactor before we add any imports like
# `twisted.internet.*` which install the default reactor. We keep it here
# and not at package level to avoid installing the reactor more than once.
# Twisted throws an exception if you install the reactor more than once.
import asyncio
if sys.platform == 'win32' and sys.version_info >= (3, 7, 0):
# we (or twisted) do not support the ProactorEventLoop as it does not
# support adding file readers
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
from twisted.internet import asyncioreactor
asyncioreactor.install(asyncio.get_event_loop())
from piqueserver.config import (config, TOML_FORMAT, JSON_FORMAT,
SUPPORTED_PYTHONS)
if (sys.version_info.major, sys.version_info.minor) not in SUPPORTED_PYTHONS:
print('Warning: you are running on an unsupported Python version.\n'
'The server may not run correctly.\n'
'Please see https://piqueserver.readthedocs.io/en/v1.0.0/supported-python-environments.html for more information.')
description = '%s is an open-source Python server implementation ' \
'for the voxel-based game "Ace of Spades".' % PKG_NAME
arg_parser = argparse.ArgumentParser(
prog=PKG_NAME, description=description)
if not sys.warnoptions:
import warnings
warnings.filterwarnings("default", module="piqueserver[.*]")
arg_parser.add_argument(
'-c',
'--config-file',
default=None,
help='specify the config file - '
'default is "config.toml" in the config dir')
arg_parser.add_argument(
'-j',
'--json-parameters',
help='add extra settings in json format '
'(overrides the config present in the config file)')
arg_parser.add_argument(
'-d',
'--config-dir',
default=config.config_dir,
help='specify the directory which contains '
'maps, scripts, etc (in correctly named '
'subdirs) - default is %s' % config.config_dir)
arg_parser.add_argument(
'--copy-config',
action='store_true',
help='copies the default/example config dir to '
'its default location or as specified by "-d"')
arg_parser.add_argument(
'--update-geoip',
action='store_true',
help='download the latest geoip database')
arg_parser.add_argument(
'--version',
action='store_true',
help='show the version and exit')
args = arg_parser.parse_args()
# update the config_dir from cli args
config.config_dir = args.config_dir
# run the required tasks if args given
if args.copy_config or args.update_geoip:
if args.copy_config:
status = copy_config()
if status != 0:
sys.exit(status)
if args.update_geoip:
status = update_geoip(config.config_dir)
if status != 0:
sys.exit(status)
return # if we have done a task, don't run the server
if args.version:
import piqueserver
print("piqueserver", piqueserver.__version__)
return
# TODO: set config/map/script/log/etc. dirs from config file, thus removing
# the need for the --config-dir argument and the config file is then a
# single source of configuration
# find and load the config
# search order:
# - --config-file (must have toml or json file extension)
# - --config-dir/config.toml
# - --config-dir/config.json
# - ~/.config/piqueserver/config.toml
# - ~/.config/piqueserver/config.json
format_ = None
if args.config_file is None:
for format__, ext in ((TOML_FORMAT, 'toml'), (JSON_FORMAT, 'json')):
config_file = os.path.join(config.config_dir,
'config.{}'.format(ext))
format_ = format__
if os.path.exists(config_file):
break
else:
config_file = args.config_file
ext = os.path.splitext(config_file)[1]
if ext == '.json':
format_ = JSON_FORMAT
elif ext == '.toml':
format_ = TOML_FORMAT
else:
raise ValueError(
'Unsupported config file format! Must have json or toml extension.'
)
config.config_file = config_file
print('Loading config from {!r}'.format(config_file))
try:
with open(config_file) as fobj:
config.load_from_file(fobj, format_=format_)
except FileNotFoundError as e:
print("Could not open Config file")
print(e)
return e.errno
# update config with cli overrides
if args.json_parameters:
config.update_from_dict(json.loads(args.json_parameters))
from piqueserver import server
server.run()
def __init__(
self,
# NetGear_Async parameters
address=None,
port=None,
protocol="tcp",
pattern=0,
receive_mode=False,
timeout=0.0,
# Videogear parameters
enablePiCamera=False,
stabilize=False,
source=None,
camera_num=0,
stream_mode=False,
backend=0,
colorspace=None,
resolution=(640, 480),
framerate=25,
time_delay=0,
# common parameters
logging=False,
**options
):
"""
This constructor method initializes the object state and attributes of the NetGear_Async class.
Parameters:
address (str): sets the valid network address of the Server/Client.
port (str): sets the valid Network Port of the Server/Client.
protocol (str): sets the valid messaging protocol between Server/Client.
pattern (int): sets the supported messaging pattern(flow of communication) between Server/Client
receive_mode (bool): select the NetGear_Async's Mode of operation.
timeout (int/float): controls the maximum waiting time(in sec) after which Client throws `TimeoutError`.
enablePiCamera (bool): provide access to PiGear(if True) or CamGear(if False) APIs respectively.
stabilize (bool): enable access to Stabilizer Class for stabilizing frames.
camera_num (int): selects the camera module index which will be used as Rpi source.
resolution (tuple): sets the resolution (i.e. `(width,height)`) of the Rpi source.
framerate (int/float): sets the framerate of the Rpi source.
source (based on input): defines the source for the input stream.
stream_mode (bool): controls the exclusive YouTube Mode.
backend (int): selects the backend for OpenCV's VideoCapture class.
colorspace (str): selects the colorspace of the input stream.
logging (bool): enables/disables logging.
time_delay (int): time delay (in sec) before start reading the frames.
options (dict): provides ability to alter Tweak Parameters of NetGear_Async, CamGear, PiGear & Stabilizer.
"""
# raise error(s) for critical Class imports
import_dependency_safe("zmq" if zmq is None else "", min_version="4.0")
import_dependency_safe("msgpack" if msgpack is None else "")
import_dependency_safe("msgpack_numpy" if m is None else "")
# enable logging if specified
self.__logging = logging
# define valid messaging patterns => `0`: PAIR, `1`:(REQ, REP), `2`:(SUB, PUB), `3`:(PUSH, PULL)
valid_messaging_patterns = {
0: (zmq.PAIR, zmq.PAIR),
1: (zmq.REQ, zmq.REP),
2: (zmq.PUB, zmq.SUB),
3: (zmq.PUSH, zmq.PULL),
}
# check whether user-defined messaging pattern is valid
if isinstance(pattern, int) and pattern in valid_messaging_patterns:
# assign value
self.__msg_pattern = pattern
self.__pattern = valid_messaging_patterns[pattern]
else:
# otherwise default to 0:`zmq.PAIR`
self.__msg_pattern = 0
self.__pattern = valid_messaging_patterns[self.__msg_pattern]
if self.__logging:
logger.warning(
"Invalid pattern {pattern}. Defaulting to `zmq.PAIR`!".format(
pattern=pattern
)
)
# check whether user-defined messaging protocol is valid
if isinstance(protocol, str) and protocol in ["tcp", "ipc"]:
# assign value
self.__protocol = protocol
else:
# else default to `tcp` protocol
self.__protocol = "tcp"
if self.__logging:
logger.warning("Invalid protocol. Defaulting to `tcp`!")
# initialize Termination flag
self.__terminate = False
# initialize and assign `Receive Mode`
self.__receive_mode = receive_mode
# initialize stream handler
self.__stream = None
# initialize Messaging Socket
self.__msg_socket = None
# initialize NetGear_Async's configuration dictionary
self.config = {}
# asyncio queue handler
self.__queue = None
# define Bidirectional mode
self.__bi_mode = False # handles Bidirectional mode state
# assign timeout for Receiver end
if timeout and isinstance(timeout, (int, float)):
self.__timeout = float(timeout)
else:
self.__timeout = 15.0
# generate 8-digit random system id
self.__id = "".join(
secrets.choice(string.ascii_uppercase + string.digits) for i in range(8)
)
# Handle user-defined options dictionary values
# reformat dictionary
options = {str(k).strip(): v for k, v in options.items()}
# handle bidirectional mode
if "bidirectional_mode" in options:
value = options["bidirectional_mode"]
# also check if pattern and source is valid
if isinstance(value, bool) and pattern < 2 and source is None:
# activate Bidirectional mode if specified
self.__bi_mode = value
else:
# otherwise disable it
self.__bi_mode = False
logger.warning("Bidirectional data transmission is disabled!")
# handle errors and logging
if pattern >= 2:
# raise error
raise ValueError(
"[NetGear_Async:ERROR] :: `{}` pattern is not valid when Bidirectional Mode is enabled. Kindly refer Docs for more Information!".format(
pattern
)
)
elif not (source is None):
raise ValueError(
"[NetGear_Async:ERROR] :: Custom source must be used when Bidirectional Mode is enabled. Kindly refer Docs for more Information!".format(
pattern
)
)
elif isinstance(value, bool) and self.__logging:
# log Bidirectional mode activation
logger.debug(
"Bidirectional Data Transmission is {} for this connection!".format(
"enabled" if value else "disabled"
)
)
else:
logger.error("`bidirectional_mode` value is invalid!")
# clean
del options["bidirectional_mode"]
# define messaging asynchronous Context
self.__msg_context = zmq.asyncio.Context()
# check whether `Receive Mode` is enabled
if receive_mode:
# assign local IP address if None
if address is None:
self.__address = "*" # define address
else:
self.__address = address
# assign default port address if None
if port is None:
self.__port = "5555"
else:
self.__port = port
else:
# Handle video source
if source is None:
self.config = {"generator": None}
if self.__logging:
logger.warning("Given source is of NoneType!")
else:
# define stream with necessary params
self.__stream = VideoGear(
enablePiCamera=enablePiCamera,
stabilize=stabilize,
source=source,
camera_num=camera_num,
stream_mode=stream_mode,
backend=backend,
colorspace=colorspace,
resolution=resolution,
framerate=framerate,
logging=logging,
time_delay=time_delay,
**options
)
# define default frame generator in configuration
self.config = {"generator": self.__frame_generator()}
# assign local ip address if None
if address is None:
self.__address = "localhost"
else:
self.__address = address
# assign default port address if None
if port is None:
self.__port = "5555"
else:
self.__port = port
# add server task handler
self.task = None
# Setup and assign event loop policy
if platform.system() == "Windows":
# On Windows, VidGear requires the ``WindowsSelectorEventLoop``, and this is
# the default in Python 3.7 and older, but new Python 3.8, defaults to an
# event loop that is not compatible with it. Thereby, we had to set it manually.
if sys.version_info[:2] >= (3, 8):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
else:
if not (uvloop is None):
# Latest uvloop eventloop is only available for UNIX machines.
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
else:
# log if not present
import_dependency_safe("uvloop", error="log")
# Retrieve event loop and assign it
self.loop = asyncio.get_event_loop()
# create asyncio queue if bidirectional mode activated
self.__queue = asyncio.Queue() if self.__bi_mode else None
# log eventloop for debugging
if self.__logging:
# debugging
logger.info(
"Using `{}` event loop for this process.".format(
self.loop.__class__.__name__
)
)
import os
import asyncio
from .base import check_links, check_local, check_remotes
if os.name == "nt":
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy()) # type: ignore
def get_session(self, *arg, **kw):
if self.session is None:
if sys.platform.startswith('win'):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
self.session = aiohttp.ClientSession(*arg, **kw)
return self.session
def __init__(
self,
# NetGear_Async parameters
address=None,
port=None,
protocol="tcp",
pattern=0,
receive_mode=False,
timeout=0.0,
# Videogear parameters
enablePiCamera=False,
stabilize=False,
source=0,
camera_num=0,
stream_mode=False,
backend=0,
colorspace=None,
resolution=(640, 480),
framerate=25,
time_delay=0,
# common parameters
logging=False,
**options
):
"""
This constructor method initializes the object state and attributes of the NetGear_Async class.
Parameters:
address (str): sets the valid network address of the Server/Client.
port (str): sets the valid Network Port of the Server/Client.
protocol (str): sets the valid messaging protocol between Server/Client.
pattern (int): sets the supported messaging pattern(flow of communication) between Server/Client
receive_mode (bool): select the Netgear's Mode of operation.
timeout (int/float): controls the maximum waiting time(in sec) after which Client throws `TimeoutError`.
enablePiCamera (bool): provide access to PiGear(if True) or CamGear(if False) APIs respectively.
stabilize (bool): enable access to Stabilizer Class for stabilizing frames.
camera_num (int): selects the camera module index which will be used as Rpi source.
resolution (tuple): sets the resolution (i.e. `(width,height)`) of the Rpi source.
framerate (int/float): sets the framerate of the Rpi source.
source (based on input): defines the source for the input stream.
stream_mode (bool): controls the exclusive YouTube Mode.
backend (int): selects the backend for OpenCV's VideoCapture class.
colorspace (str): selects the colorspace of the input stream.
logging (bool): enables/disables logging.
time_delay (int): time delay (in sec) before start reading the frames.
options (dict): provides ability to alter Tweak Parameters of NetGear, CamGear, PiGear & Stabilizer.
"""
# enable logging if specified
self.__logging = logging
# define valid messaging patterns => `0`: PAIR, `1`:(REQ, REP), `2`:(SUB, PUB), `3`:(PUSH, PULL)
valid_messaging_patterns = {
0: (zmq.PAIR, zmq.PAIR),
1: (zmq.REQ, zmq.REP),
2: (zmq.PUB, zmq.SUB),
3: (zmq.PUSH, zmq.PULL),
}
# check whether user-defined messaging pattern is valid
if isinstance(pattern, int) and pattern in valid_messaging_patterns:
# assign value
self.__msg_pattern = pattern
self.__pattern = valid_messaging_patterns[pattern]
else:
# otherwise default to 0:`zmq.PAIR`
self.__msg_pattern = 0
self.__pattern = valid_messaging_patterns[self.__msg_pattern]
if self.__logging:
logger.warning(
"Invalid pattern {pattern}. Defaulting to `zmq.PAIR`!".format(
pattern=pattern
)
)
# check whether user-defined messaging protocol is valid
if isinstance(protocol, str) and protocol in ["tcp", "ipc"]:
# assign value
self.__protocol = protocol
else:
# else default to `tcp` protocol
self.__protocol = "tcp"
if self.__logging:
logger.warning("Invalid protocol. Defaulting to `tcp`!")
# initialize Termination flag
self.__terminate = False
# initialize and assign `Receive Mode`
self.__receive_mode = receive_mode
# initialize stream handler
self.__stream = None
# initialize Messaging Socket
self.__msg_socket = None
# initialize NetGear's configuration dictionary
self.config = {}
# assign timeout for Receiver end
if timeout > 0 and isinstance(timeout, (int, float)):
self.__timeout = float(timeout)
else:
self.__timeout = 15.0
# define messaging asynchronous Context
self.__msg_context = zmq.asyncio.Context()
# check whether `Receive Mode` is enabled
if receive_mode:
# assign local ip address if None
if address is None:
self.__address = "*" # define address
else:
self.__address = address
# assign default port address if None
if port is None:
self.__port = "5555"
else:
self.__port = port
else:
# Handle video source if not None
if source is None:
self.config = {"generator": None}
if self.__logging:
logger.warning("Given source is of NoneType!")
else:
# define stream with necessary params
self.__stream = VideoGear(
enablePiCamera=enablePiCamera,
stabilize=stabilize,
source=source,
camera_num=camera_num,
stream_mode=stream_mode,
backend=backend,
colorspace=colorspace,
resolution=resolution,
framerate=framerate,
logging=logging,
time_delay=time_delay,
**options
)
# define default frame generator in configuration
self.config = {"generator": self.__frame_generator()}
# assign local ip address if None
if address is None:
self.__address = "localhost"
else:
self.__address = address
# assign default port address if None
if port is None:
self.__port = "5555"
else:
self.__port = port
# add server task handler
self.task = None
# Setup and assign event loop policy
if platform.system() == "Windows":
# On Windows, VidGear requires the ``WindowsSelectorEventLoop``, and this is
# the default in Python 3.7 and older, but new Python 3.8, defaults to an
# event loop that is not compatible with it. Thereby, we had to set it manually.
if sys.version_info[:2] >= (3, 8):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
else:
# import library
import uvloop
# uvloop eventloop is only available for UNIX machines.
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
# Retrieve event loop and assign it
self.loop = asyncio.get_event_loop()
# debugging
logger.info(
"Using `{}` event loop for this process.".format(
self.loop.__class__.__name__
)
)
def init(server_config: ServerConfig,
authenticator,
authorizer,
execution_service: ExecutionService,
schedule_service: ScheduleService,
execution_logging_service: ExecutionLoggingService,
config_service: ConfigService,
alerts_service: AlertsService,
file_upload_feature: FileUploadFeature,
file_download_feature: FileDownloadFeature,
secret,
server_version,
conf_folder,
*,
start_server=True):
ssl_context = None
if server_config.is_ssl():
ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.load_cert_chain(server_config.get_ssl_cert_path(),
server_config.get_ssl_key_path())
auth = TornadoAuth(authenticator)
if auth.is_enabled():
identification = AuthBasedIdentification(auth)
else:
identification = IpBasedIdentification(server_config.ip_validator,
server_config.user_header_name)
downloads_folder = file_download_feature.get_result_files_folder()
handlers = [
(r'/conf', GetServerConf), (r'/scripts', GetScripts),
(r'/scripts/([^/]*)', ScriptConfigSocket),
(r'/scripts/([^/]*)/([^/]*)/list-files', ScriptParameterListFiles),
(r'/executions/start', ScriptExecute),
(r'/executions/stop/(.*)', ScriptStop),
(r'/executions/kill/(.*)', ScriptKill),
(r'/executions/io/(.*)', ScriptStreamSocket),
(r'/executions/active', GetActiveExecutionIds),
(r'/executions/config/(.*)', GetExecutingScriptConfig),
(r'/executions/cleanup/(.*)', CleanupExecutingScript),
(r'/executions/status/(.*)', GetExecutionStatus),
(r'/history/execution_log/short', GetShortHistoryEntriesHandler),
(r'/history/execution_log/long/(.*)', GetLongHistoryEntryHandler),
(r'/schedule', AddSchedule), (r'/auth/info', AuthInfoHandler),
(r'/result_files/(.*)', DownloadResultFile, {
'path': downloads_folder
}), (r'/admin/scripts', AdminUpdateScriptEndpoint),
(r'/admin/scripts/(.*)', AdminGetScriptEndpoint),
(r"/", ProxiedRedirectHandler, {
"url": "/index.html"
})
]
if auth.is_enabled():
handlers.append((r'/login', LoginHandler))
handlers.append((r'/auth/config', AuthConfigHandler))
handlers.append((r'/logout', LogoutHandler))
handlers.append((r'/theme/(.*)', ThemeStaticFileHandler, {
'path': os.path.join(conf_folder, 'theme')
}))
handlers.append((r"/(.*)", AuthorizedStaticFileHandler, {"path": "web"}))
settings = {
"cookie_secret": secret,
"login_url": "/login.html",
'websocket_ping_interval': 30,
'websocket_ping_timeout': 300,
'compress_response': True
}
application = tornado.web.Application(handlers, **settings)
application.auth = auth
application.server_config = server_config
application.server_version = server_version
application.authorizer = authorizer
application.downloads_folder = downloads_folder
application.file_download_feature = file_download_feature
application.file_upload_feature = file_upload_feature
application.execution_service = execution_service
application.schedule_service = schedule_service
application.execution_logging_service = execution_logging_service
application.config_service = config_service
application.alerts_service = alerts_service
application.identification = identification
application.max_request_size_mb = server_config.max_request_size_mb
if os_utils.is_win() and env_utils.is_min_version('3.8'):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
io_loop = tornado.ioloop.IOLoop.current()
global _http_server
_http_server = httpserver.HTTPServer(application,
ssl_options=ssl_context,
max_buffer_size=10 * BYTES_IN_MB)
_http_server.listen(server_config.port, address=server_config.address)
intercept_stop_when_running_scripts(io_loop, execution_service)
http_protocol = 'https' if server_config.ssl else 'http'
print('Server is running on: %s://%s:%s' %
(http_protocol, server_config.address, server_config.port))
if start_server:
io_loop.start()
def asyncio_setup() -> None: # pragma: no cover
if sys.version_info >= (3, 8) and sys.platform == "win32":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
def start_WebServerThread():
if sys.version_info.minor > 7:
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy())
asyncio.set_event_loop(asyncio.new_event_loop())
ws.run()
def initWindowsFix(self): #Required for async due to bug in Windows shitty proactor event loop that crashes asyncio
if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
async def main(lib_kwargs, **kwargs):
async def start(gwy) -> None:
protocol_factory = create_protocol_factory(LocalProtocol, gwy, None)
gwy.pkt_protocol, gwy.pkt_transport = create_pkt_stack(
gwy,
None,
packet_log=gwy._input_file,
protocol_factory=protocol_factory,
)
if gwy.pkt_transport.get_extra_info(POLLER_TASK):
gwy._tasks.append(gwy.pkt_transport.get_extra_info(POLLER_TASK))
def setup_database(db_file: str):
con = None
try:
con = sqlite3.connect(db_file)
except sqlite3.Error as err:
print(err)
try:
cur = con.cursor()
cur.execute(SQL_CREATE_TABLE)
except sqlite3.Error as err:
print(err)
return con
def process_packet(pkt) -> None:
global last_pkt
def insert_pkt(pkt):
global counter
data_fields = (
pkt.dtm, # dtm
pkt.packet[0:3], # rssi
pkt.packet[4:6], # verb
pkt.packet[7:10], # seqn
pkt.packet[11:20], # dev0
pkt.packet[21:30], # dev1
pkt.packet[31:40], # dev2
pkt.packet[41:45], # code
pkt.packet[46:49], # len
pkt.packet[50:], # payload
)
try:
# cur = con.cursor()
cur.execute(SQL_UPSERT_ROW, data_fields)
except sqlite3.Error as err:
print(err)
else:
counter += 1
if counter == 1000:
counter = 0
con.commit()
msg, hdr = f"{pkt.dtm} {pkt}", f"{Style.BRIGHT}{Fore.CYAN}"
print(f"{hdr}{msg[:CONSOLE_COLS]}")
return cur.lastrowid
if not pkt.is_valid:
# msg, hdr = f"{pkt.dtm} {pkt._pkt_str}", f"{Fore.MAGENTA}"
# print(f"{hdr}{msg[:CONSOLE_COLS]}")
return
if last_pkt:
if all((
pkt.packet[4:6] == "RP",
pkt.packet[11:20] == last_pkt.packet[21:30],
pkt.packet[21:30] == last_pkt.packet[11:20],
pkt.packet[41:45] == last_pkt.packet[41:45],
)):
insert_pkt(last_pkt)
last_pkt = None
elif pkt.packet[4:6] == "RQ" and pkt.packet[11:13] == "18":
last_pkt = pkt
return
else:
insert_pkt(pkt)
print("\r\nclient.py: Starting evohome_rf (utils)...")
if sys.platform == "win32":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
colorama_init(autoreset=True)
con = setup_database(kwargs[DATABASE])
cur = con.cursor()
gwy = Gateway(None, **lib_kwargs)
await start(gwy) # replaces asyncio.create_task(gwy.start())
while gwy.pkt_protocol is None:
await asyncio.sleep(0.05)
gwy.pkt_protocol.pkt_callback = process_packet
try: # main code here
await asyncio.gather(*gwy._tasks)
except asyncio.CancelledError:
msg = " - ended via: CancelledError (e.g. SIGINT)"
except GracefulExit:
msg = " - ended via: GracefulExit"
except (KeyboardInterrupt, SystemExit):
msg = " - ended via: KeyboardInterrupt"
except EvohomeError as err:
msg = f" - ended via: EvohomeError: {err}"
else: # if no Exceptions raised, e.g. EOF when parsing
msg = " - ended without error (e.g. EOF)"
con.commit()
print(f"\r\nclient.py: Finished evohome_rf (utils).\r\n{msg}\r\n")
def event_loop():
if platform.system() == "Windows":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
return asyncio.new_event_loop()
def run_notebook(nb_path, tmp_path, env=None, kernel=None, allow_errors=False):
"""Execute a Jupyter notebook via :mod:`nbclient` and collect output.
Parameters
----------
nb_path : path-like
The notebook file to execute.
tmp_path : path-like
A directory in which to create temporary output.
env : dict-like, optional
Execution environment for ``nbconvert``.
If not supplied, :obj:`os.environ` is used.
kernel : str, optional
Jupyter kernel to use. Default: 'python2' or 'python3', matching the
current Python version.
allow_errors : bool, optional
Whether to pass the ``--allow-errors`` option to ``nbconvert``. If
:obj:`True`, the execution always succeeds, and cell output contains
exception information.
Returns
-------
nb : :class:`nbformat.NotebookNode`
Parsed and executed notebook.
errors : list
Any execution errors.
"""
import nbformat
from nbclient import NotebookClient
# Workaround for https://github.com/jupyter/nbclient/issues/85
if (
sys.version_info[0] == 3
and sys.version_info[1] >= 8
and sys.platform.startswith("win")
):
import asyncio
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
# Read the notebook
nb = nbformat.read(nb_path, as_version=4)
# Create a client and use it to execute the notebook
client = NotebookClient(
nb,
timeout=10,
kernel_name=kernel or f"python{sys.version_info[0]}",
allow_errors=allow_errors,
resources=dict(metadata=dict(path=tmp_path)),
)
# Execute the notebook.
# `env` is passed from nbclient to jupyter_client.launcher.launch_kernel()
client.execute(env=env or os.environ.copy())
# Retrieve error information from cells
errors = [
output
for cell in nb.cells
if "outputs" in cell
for output in cell["outputs"]
if output.output_type == "error"
]
return nb, errors
def start(task, profile):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
asyncio.set_event_loop(asyncio.new_event_loop())
asyncio.get_event_loop().run_until_complete(configure(task, profile))
async def main(command, lib_kwargs, **kwargs):
def process_msg(msg, prev_msg=None) -> None:
dtm = (msg.dtm.isoformat(timespec="microseconds")
if kwargs["long_dates"] else f"{msg.dtm:%H:%M:%S.%f}"[:-3])
if msg.src and msg.src.type == "18":
print(
f"{Style.BRIGHT}{COLORS.get(msg.verb)}{dtm} {msg}"[:
CONSOLE_COLS]
)
# elif msg.code == "3B00": # TODO: temp
# print(f"{Style.BRIGHT}{COLORS.get(msg.verb)}{dtm} {msg}"[:CONSOLE_COLS])
else:
print(f"{COLORS.get(msg.verb)}{dtm} {msg}"[:CONSOLE_COLS])
print("\r\nclient.py: Starting ramses_rf...")
if sys.platform == "win32":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
serial_port, lib_kwargs = normalise_config_schema(lib_kwargs)
gwy = Gateway(serial_port, **lib_kwargs)
if kwargs[REDUCE_PROCESSING] < DONT_CREATE_MESSAGES:
# no MSGs will be sent to STDOUT, so send PKTs instead
colorama_init(autoreset=True) # TODO: remove strip=True
gwy.create_client(process_msg)
try: # main code here
if kwargs["restore_cache"]:
print("Restoring client schema/state cache...")
state = json.load(kwargs["restore_cache"])
await gwy._set_state(**state["data"]["restore_cache"])
gwy_task = asyncio.create_task(gwy.start())
if command == EXECUTE:
tasks = spawn_scripts(gwy, **kwargs)
await asyncio.gather(*tasks)
elif command in MONITOR:
tasks = spawn_scripts(gwy, **kwargs)
# await asyncio.sleep(5)
# gwy.device_by_id["17:145039"].temperature = 19
# gwy.device_by_id["34:145039"].temperature = 21.3
await gwy_task
else: # elif command in (LISTEN, PARSE):
await gwy_task
except asyncio.CancelledError:
msg = " - ended via: CancelledError (e.g. SIGINT)"
except GracefulExit:
msg = " - ended via: GracefulExit"
except KeyboardInterrupt:
msg = " - ended via: KeyboardInterrupt"
except EvohomeError as err:
msg = f" - ended via: EvohomeError: {err}"
else: # if no Exceptions raised, e.g. EOF when parsing
msg = " - ended without error (e.g. EOF)"
print("\r\nclient.py: Finished ramses_rf, results:\r\n")
if False: # or kwargs["show_state"]:
_print_state(gwy, **kwargs)
elif command == EXECUTE:
print_results(gwy, **kwargs)
print_summary(gwy, **kwargs)
# if kwargs["save_state"]:
# _save_state(gwy)
print(f"\r\nclient.py: Finished ramses_rf.\r\n{msg}\r\n")
def start():
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(local_run())
def configure_windows_event_loop():
if sys.version_info >= (3, 8) and platform.system() == "Windows":
import asyncio
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
def qcode_sign(enc):
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(qcode_run(enc))
QWord,
RandomData,
Static,
String,
Word,
)
from .repeater import CountRepeater, Repeater, TimeRepeater
from .sessions import open_test_run, Session, Target
# workaround to make Tornado work in Python 3.8
# https://github.com/tornadoweb/tornado/issues/2608
if sys.platform == "win32" and sys.version_info >= (3, 8):
import asyncio
# noinspection PyUnresolvedReferences
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) # pytype: disable=module-attr
__all__ = [
"BasePrimitive",
"BaseSocketConnection",
"BIG_ENDIAN",
"BitField",
"Block",
"blocks",
"Byte",
"Bytes",
"Checksum",
"CountRepeater",
"DEFAULT_PROCMON_PORT",
"Delim",
"DWord",
import asyncio
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy()) # python-3.8.0a4
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
from tornado.options import define, options
define("port", default=8888, help="run on the given port", type=int)
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("table 1 2 3 4 5 ; price $350 $250 $400 $500 $1500 ;")
def main():
tornado.options.parse_command_line()
application = tornado.web.Application([(r"/", MainHandler)])
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(options.port)
tornado.ioloop.IOLoop.current().start()
if __name__ == "__main__":
main()
# File "...\twisted\internet\asyncioreactor.py", line 69, in __init__
# super().__init__()
# File "...\twisted\internet\base.py", line 571, in __init__
# self.installWaker()
# File "...\twisted\internet\posixbase.py", line 286, in installWaker
# self.addReader(self.waker)
# File "...\twisted\internet\asyncioreactor.py", line 151, in addReader
# self._asyncioEventloop.add_reader(fd, callWithLogger, reader,
# File "C:\Python38\lib\asyncio\events.py", line 501, in add_reader
# raise NotImplementedError
# ```
# NOTE: Actually this is already done in the `event_loop` fixture in the
# `conftest.py` file, but this file imports earlier by the Pytest plugin
# `pytest_django`. So we do this here as well.
if sys.platform == "win32" and sys.version_info.minor >= 8:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy() # pylint: disable=no-member
)
BASE_DIR = pathlib.Path(__file__).absolute().parent.parent
SECRET_KEY = str(uuid.uuid4())
DEBUG = True
MIDDLEWARE = [
"django.contrib.sessions.middleware.SessionMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
]
TEMPLATES = [{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
manager = MerossManager(http_client=http_api_client)
await manager.async_init()
await manager.async_device_discovery()
plugs = manager.find_devices(device_type=device_type)
sleep(2)
if len(plugs) < 1:
print("No {device_type} plugs found...")
else:
plug_exsists = False
x = 0
for plug in plugs:
if plug.name == device_name:
plug_exsists = True
plug_number = x
x += 1
if plug_exsists:
dev = plugs[plug_number]
await dev.async_turn_on(channel=0)
else:
print("Plug does not exsist")
manager.close()
await http_api_client.async_logout()
if __name__ == '__main__':
# On Windows + Python 3.8, you should uncomment the following
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) # Comment out when used on Linux
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()
