class Nginx(Plugin):
configuration_schema: Schema = Schema({
Required('www_directory_path', default=None):
Maybe(str),
Required('https', default=None):
Maybe(bool),
})
def __init__(self,
site: Site,
www_directory_path: Optional[str] = None,
https: Optional[bool] = None):
self._https = https
self._www_directory_path = www_directory_path
self._site = site
@classmethod
def for_site(cls, site: Site, configuration: Dict):
return cls(site, configuration['www_directory_path'],
configuration['https'])
def subscribes_to(self) -> List[Tuple[Type[Event], Callable]]:
return [
(PostGenerateEvent, self._generate_config),
]
@property
def assets_directory_path(self) -> Optional[str]:
return '%s/assets' % os.path.dirname(__file__)
@property
def https(self) -> bool:
if self._https is None:
return self._site.configuration.base_url.startswith('https')
return self._https
@property
def www_directory_path(self) -> str:
if self._www_directory_path is None:
return self._site.configuration.www_directory_path
return self._www_directory_path
async def _generate_config(self, event: PostGenerateEvent) -> None:
output_directory_path = os.path.join(
self._site.configuration.output_directory_path, 'nginx')
makedirs(output_directory_path)
# Render the ngnix configuration.
file_name = 'nginx.conf.j2'
destination_file_path = os.path.join(output_directory_path, file_name)
await self._site.assets.copy2(file_name, destination_file_path)
await self._site.renderer.render_file(destination_file_path)
# Render the Dockerfile.
copyfile(os.path.join(DOCKER_PATH, 'Dockerfile'),
os.path.join(output_directory_path, 'Dockerfile'))
def test_maybe():
s = Schema(Maybe(int))
assert s(1) == 1
assert s(None) is None
assert_raises(Invalid, s, 'foo')
s = Schema(Maybe({str: Coerce(int)}))
assert s({'foo': '100'}) == {'foo': 100}
assert s(None) is None
assert_raises(Invalid, s, {'foo': 'bar'})
class Output(JSONSerialisableClass):
"""
Represents a model output in the pyESG configuration.
Attributes:
id (str): The id (or name) for the output.
type (str): The type of the output.
initial_value (float): The initial value for the output.
parameters (List[Parameter]): A list of the parameters associated with the output.
"""
_serialisable_attrs = {
'parameters': Parameters,
}
_validation_schema = Schema({
Required('id'):
str,
Required('type'):
str,
Required('initial_value'):
Maybe(Coerce(float)),
Required('parameters'):
Parameters._validation_schema,
})
def __init__(self, **kwargs):
self.id = None # type: str
self.type = None # type: str
self.initial_value = None # type: float
self.parameters = Parameters() # type: Parameters
super().__init__(**kwargs)
def test_maybe():
assert_raises(TypeError, Maybe, lambda x: x)
s = Schema(Maybe(int))
assert s(1) == 1
assert s(None) is None
assert_raises(Invalid, s, 'foo')
def test_maybe_returns_custom_subvalidator_error():
schema = Schema(Maybe(validator_value_not_3))
# The following should be valid
schema(None)
schema(1)
with raises(MultipleInvalid, "Should not be 3"):
assert schema(3)
def test_maybe_returns_subvalidator_error():
schema = Schema(Maybe(Range(1, 2)))
# The following should be valid
schema(None)
schema(1)
schema(2)
with raises(MultipleInvalid, "value must be at most 2"):
assert schema(3)
def test_maybe_returns_subvalidator_error():
schema = Schema(Maybe(Range(1, 2)))
# The following should be valid
schema(None)
schema(1)
schema(2)
try:
# Should trigger a MultipleInvalid exception
schema(3)
except MultipleInvalid as e:
assert_equal(str(e), "value must be at most 2")
else:
assert False, "Did not raise correct Invalid"
def test_repr():
"""Verify that __repr__ returns valid Python expressions"""
match = Match('a pattern', msg='message')
replace = Replace('you', 'I', msg='you and I')
range_ = Range(min=0, max=42, min_included=False,
max_included=False, msg='number not in range')
coerce_ = Coerce(int, msg="moo")
all_ = All('10', Coerce(int), msg='all msg')
maybe_int = Maybe(int)
assert_equal(repr(match), "Match('a pattern', msg='message')")
assert_equal(repr(replace), "Replace('you', 'I', msg='you and I')")
assert_equal(
repr(range_),
"Range(min=0, max=42, min_included=False, max_included=False, msg='number not in range')"
)
assert_equal(repr(coerce_), "Coerce(int, msg='moo')")
assert_equal(repr(all_), "All('10', Coerce(int, msg=None), msg='all msg')")
assert_equal(repr(maybe_int), "Any(%s, None, msg=None)" % str(int))
def test_maybe_accepts_msg():
s = Schema(Maybe(int, msg='int or None expected'))
with raises(MultipleInvalid, 'int or None expected'):
assert s([])
"pci" : Use any PCIe Edge TPU
"pci:<N>" : Use N-th PCIe Edge TPU
"cpu" : Run on the CPU
"""
for regex in DEVICE_REGEXES:
if regex.match(device):
return device
raise Invalid(
f"EdgeTPU device {device} is invalid. Please check your configuration")
SCHEMA = AbstractDetectorConfig.schema.extend({
Required("model_path", default=MODEL_PATH):
str,
Optional("model_width", default=MODEL_WIDTH):
Maybe(int),
Optional("model_height", default=MODEL_HEIGHT):
Maybe(int),
Required("label_path", default=LABEL_PATH):
str,
Optional("device", default=DEVICE):
All(str, edgetpu_device_validator),
})
class ObjectDetection(AbstractObjectDetection):
"""Performs object detection."""
def __init__(self, config):
self.labels = self.read_labels(config.label_path)
LOGGER.debug(f"Available devices: {list_edge_tpus()}")
LOGGER.debug(f"Loading interpreter with device {config.device}")
from voluptuous import (All, Any, Coerce, Length, Match, Maybe,
MultipleInvalid, Required, Schema)
# JSON Validation Schemas
ID_VALIDATOR = All(
Coerce(str, msg='Invalid variable type, expected str'),
Length(min=8, max=30, msg='Invalid Length, expected 8-30 char'),
Match(r'^[A-Za-z_][A-Za-z0-9_]{7,29}$'))
DEVICE_SCHEMA = Schema({
Required('id'):
ID_VALIDATOR,
Required('type', default=None):
Coerce(str),
Required('cluster', default=None):
Any(Maybe(str), ID_VALIDATOR),
Required('gateway'):
All(Coerce(str), Match(r'^0x[0-9A-F]{8}$'))
})
CLUSTER_SCHEMA = Schema({
Required('id'):
ID_VALIDATOR,
Required('type', default=None):
Maybe(str, msg='Invalid "type" variable, expected str or None'),
Required('devices', default=list):
list,
Required('gateways', default=list):
list,
})
DNN_TARGET_CPU,
DNN_TARGET_CUDA,
DNN_TARGET_OPENCL,
)
from voluptuous import All, Any, Coerce, Maybe, Optional, Range
from viseron.const import ENV_CUDA_SUPPORTED, ENV_OPENCL_SUPPORTED
from viseron.detector import AbstractDetectorConfig
from .defaults import LABEL_PATH, MODEL_CONFIG, MODEL_PATH
SCHEMA = AbstractDetectorConfig.SCHEMA.extend(
{
Optional("model_path", default=MODEL_PATH): str,
Optional("model_config", default=MODEL_CONFIG): str,
Optional("model_width", default=None): Maybe(int),
Optional("model_height", default=None): Maybe(int),
Optional("label_path", default=LABEL_PATH): str,
Optional("suppression", default=0.4): All(
Any(0, 1, All(float, Range(min=0.0, max=1.0))), Coerce(float)
),
}
)
class Config(AbstractDetectorConfig):
"""Darknet object detection config."""
def __init__(self, detector_config):
super().__init__(detector_config)
self._model_path = detector_config["model_path"]
class Nginx(Plugin, PostGenerator, ServerProvider):
configuration_schema: Schema = Schema({
Required('www_directory_path', default=None):
Maybe(str),
Required('https', default=None):
Maybe(bool),
})
def __init__(self,
site: Site,
www_directory_path: Optional[str] = None,
https: Optional[bool] = None):
self._https = https
self._www_directory_path = www_directory_path
self._site = site
@classmethod
def for_site(cls, site: Site, configuration: Any = NO_CONFIGURATION):
return cls(site, configuration['www_directory_path'],
configuration['https'])
@property
def servers(self) -> Iterable[Server]:
from betty.plugin.nginx.serve import DockerizedNginxServer
if DockerizedNginxServer.is_available():
return [DockerizedNginxServer(self._site)]
return []
async def post_generate(self) -> None:
await self.generate_configuration_file()
await self._generate_dockerfile_file()
@property
def assets_directory_path(self) -> Optional[str]:
return '%s/assets' % path.dirname(__file__)
@property
def https(self) -> bool:
if self._https is None:
return self._site.configuration.base_url.startswith('https')
return self._https
@property
def www_directory_path(self) -> str:
if self._www_directory_path is None:
return self._site.configuration.www_directory_path
return self._www_directory_path
async def generate_configuration_file(
self,
destination_file_path: Optional[str] = None,
**kwargs) -> None:
kwargs = dict(
{
'content_negotiation':
self._site.configuration.content_negotiation,
'https': self._site.plugins[Nginx].https,
'locale': self._site.locale,
'locales': self._site.configuration.locales,
'multilingual': self._site.configuration.multilingual,
'server_name': urlparse(
self._site.configuration.base_url).netloc,
'www_directory_path':
self._site.configuration.www_directory_path,
}, **kwargs)
if destination_file_path is None:
destination_file_path = path.join(
self._site.configuration.output_directory_path, 'nginx',
'nginx.conf')
await generate_configuration_file(destination_file_path,
self._site.jinja2_environment,
**kwargs)
async def _generate_dockerfile_file(self) -> None:
await generate_dockerfile_file(
path.join(self._site.configuration.output_directory_path, 'nginx',
'docker', 'Dockerfile'))
def test_voluptuous_maybe_checks_none_first():
schema = Maybe(validator_that_raises_typeerror)
assert schema(None) is None
Coerce(str),
Match(
r'^(22[4-9]|230)(\.([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])){3}:\d{3,4}$'
)),
Optional('max_log_size', default='2'):
All(Coerce(str), Match(r'^\d{1,2}$')),
Optional('max_log_count', default='5'):
All(Coerce(str), Match(r'^\d{1,2}$')),
})
END_DEVICE_CONF_VALIDATOR = Schema({
Required('code'):
Coerce(str),
Required('id'):
All(Coerce(str, msg='Invalid variable type, expected str'),
Length(min=8, max=30, msg='Invalid Length, expected 8-30 char'),
Match(r'^[A-Za-z_][A-Za-z0-9_]{7,29}$')),
Required('cluster'):
Any(
Maybe(str),
All(Coerce(str, msg='Invalid variable type, expected str'),
Length(min=8, max=30, msg='Invalid Length, expected 8-30 char'),
Match(r'^[A-Za-z_][A-Za-z0-9_]{7,29}$'))),
Required('type'):
str
})
SERVER_RESPONSE_VALIDATOR = Schema({
Required('status'): Coerce(str),
Required('message'): Coerce(str)
})
# Dont enable VA-API if CUDA is available
if (os.getenv(ENV_VAAPI_SUPPORTED) == "true"
and os.getenv(ENV_CUDA_SUPPORTED) != "true"):
return HWACCEL_VAAPI
return hwaccel_args
STREAM_SCEHMA = Schema({
Required("stream_format", default="rtsp"):
Any("rtsp", "rtmp", "mjpeg"),
Required("path"):
All(str, Length(min=1)),
Required("port"):
All(int, Range(min=1)),
Optional("width", default=None):
Maybe(int),
Optional("height", default=None):
Maybe(int),
Optional("fps", default=None):
Maybe(All(int, Range(min=1))),
Optional("input_args", default=None):
Maybe(list),
Optional("hwaccel_args", default=CAMERA_HWACCEL_ARGS):
check_for_hwaccels,
Optional("codec", default=""):
str,
Optional("audio_codec", default="unset"):
Maybe(str),
Optional("rtsp_transport", default="tcp"):
Any("tcp", "udp", "udp_multicast", "http"),
Optional("filter_args", default=[]):
