class Service(object):
name = related.StringField()
image = related.StringField(required=False)
build = related.StringField(required=False)
ports = related.SequenceField(Port, required=False)
volumes = related.SequenceField(str, required=False)
command = related.StringField(required=False)
class SuiteResult(object):
suite = related.ChildField(Suite)
passed = related.SequenceField(CaseResult, default=[])
failed = related.SequenceField(CaseResult, default=[])
@property
def success(self):
return bool(self.passed and not self.failed)
@classmethod
def create(cls, suite, scenario_results):
cache = {}
for result in scenario_results:
case_result = cache.setdefault(
result.case.uuid, CaseResult(suite=suite, case=result.case))
sink = case_result.passed if result.success else case_result.failed
sink.append(result)
passed, failed = [], []
for case_result in cache.values():
sink = passed if case_result.success else failed
sink.append(case_result)
return cls(suite=suite, passed=passed, failed=failed)
class URL(object):
"""URL class contains the postman representation of an API url"""
raw = related.URLField()
protocol = related.StringField()
host = related.SequenceField(str)
path = related.SequenceField(str)
class Feature(object):
uri = related.StringField()
keyword = related.StringField()
id = related.StringField()
name = related.StringField()
line = related.IntegerField()
elements = related.SequenceField(Element, default=[])
description = related.StringField(required=False, default=None)
tags = related.SequenceField(Tag, required=False, default=None)
@classmethod
def create(cls, case_result):
case = case_result.case
uuid = "%s;%s" % (urllib.parse.quote_plus(case.name), case.uuid)
return cls(
uri=case.file_path,
keyword="Feature",
id=uuid,
name=case.name,
line=1,
elements=[
Element.create(scenario_result) for scenario_result in chain(
case_result.passed, case_result.failed)
],
tags=[Tag(name=tag) for tag in case.tags],
)
class Profile(object):
name = related.StringField(default="__root__")
host = related.StringField(required=False)
schemas = related.ChildField(Namespace, required=False)
globals = related.ChildField(Namespace, required=False)
headers = related.ChildField(Namespace, required=False)
prefixes = related.SequenceField(str, default=None)
extensions = related.SequenceField(str, default=["rigor"])
includes = related.SequenceField(str, default=None)
excludes = related.SequenceField(str, default=None)
concurrency = related.IntegerField(default=5)
retries = related.IntegerField(default=0)
sleep = related.IntegerField(default=60)
retry_failed = related.BooleanField(default=False, required=False)
def __attrs_post_init__(self):
# circumvent frozen error due to immutable
extensions = [
ext[1:] if ext.startswith(".") else ext
for ext in self.extensions or []
]
object.__setattr__(self, "extensions", extensions)
def as_dict(self):
kwargs = related.to_dict(self)
kwargs.pop("profiles", None)
kwargs.pop("file_path", None)
return kwargs
class Definition(object):
key = related.StringField(required=True)
type = related.ChildField(DataType, required=False)
required = related.SequenceField(str, required=False)
allOf = related.SequenceField(object, required=False)
anyOf = related.SequenceField(object, required=False)
is_not = related.SequenceField(object, required=False, key="not")
properties = related.ChildField(object, required=False)
class CaseResult(object):
suite = related.ChildField(Suite)
case = related.ChildField(Case)
passed = related.SequenceField(ScenarioResult, default=[])
failed = related.SequenceField(ScenarioResult, default=[])
@property
def success(self):
return bool(self.passed and not self.failed)
class QueryDefinition:
id = related.StringField()
advanced_fields = related.SequenceField(AdvancedFieldDefinition, [],
key='advancedFields')
advanced_filters = related.SequenceField(dict, [], key='advancedFilters')
advanced_groups = related.SequenceField(dict, [], key='advancedGroups')
name = related.StringField(required=False)
magic_filter_ids = related.SequenceField(str, [], key='magicFilters')
date_range_id = related.StringField('', key='dateRangeId')
group_by = related.StringField('', key='groupBy')
class Operation(object):
responses = related.MappingField(Response, "code", required=True)
tags = related.SequenceField(str, required=False)
summary = related.StringField(required=False)
description = related.StringField(required=False)
operationId = related.StringField(required=False)
parameters = related.SequenceField(Parameter, required=False)
consumes = related.SequenceField(MIMEType, required=False)
produces = related.SequenceField(MIMEType, required=False)
externalDocs = related.ChildField(dict, required=False)
schemes = related.SequenceField(Scheme, required=False)
deprecated = related.BooleanField(required=False)
security = related.ChildField(dict, required=False)
class FilterPanelSettings:
aggregation_levels = related.SequenceField(str, [],
key='aggregationLevels')
auto_update_granularity = related.BooleanField(False,
key='autoUpdateGranularity')
date_picker_type = related.StringField('CUSTOM', key='datePickerType')
filter_panel_components = related.SequenceField(
str, [], key='filterPanelComponents')
enabled_filters = related.SequenceField(str, [], key='enabledFilters')
initial_selected_components = related.SequenceField(
str, [], key='initialSelectedComponents')
show_dashboard_filterButton = related.BooleanField(
False, key='showDashboardFilterButton')
class ModelInfo(Info):
"""Additional information for the model - not applicable to the dataloader
"""
contributors = related.SequenceField(Author, default=[], repr=True, required=False)
cite_as = related.StringField(required=False) # a link or a description how to cite the paper (say a doi link)
trained_on = related.StringField(required=False) # a link or a description of the training dataset
training_procedure = related.StringField(required=False) # brief description about the training procedure for the trained_on dataset.
class Suite(Profile):
paths = related.SequenceField(str, default=None)
queued = related.MappingField(Case, "file_path", default={})
skipped = related.MappingField(Case, "file_path", default={})
semaphores = related.MappingField(Semaphore, "semaphore", default={})
app = related.ChildField(object, default=None)
def __attrs_post_init__(self):
from . import collect
collect(self)
get_logger().debug(
"suite constructed",
host=self.host,
paths=self.paths,
prefixes=self.prefixes,
extensions=self.extensions,
includes=self.includes,
excludes=self.excludes,
concurrency=self.concurrency,
retry_failed=self.retry_failed,
)
def get_case(self, path, filename=None):
file_path = os.path.join(path, filename) if filename else path
return self.queued.get(file_path) or self.skipped.get(file_path)
def add_case(self, case):
if case.is_active(self.includes, self.excludes):
self.queued.add(case)
if (case.semaphore is not None
and case.semaphore not in self.semaphores.keys()):
self.semaphores[case.semaphore] = Semaphore()
get_logger().debug("case queued", case=case.file_path)
class CommandConfig(object):
target_device_list = related.SequenceField(TargetDevice)
database = related.ChildField(Database, required=False)
influxdb = related.ChildField(Influxdb, required=False)
set_measurement_interval = related.IntegerField(required=False)
dry_run = related.BooleanField(default=False, required=False)
no_scan = related.BooleanField(default=False, required=False)
class MapSettings:
base_layer = related.ChildField(BaseMapLayer, BaseMapLayer.STREETS, key='baseLayer')
current_display = related.StringField('dots', key='currentDisplay')
map_center = related.ChildField(Coordinates, [0.0, 0.0], key='mapCenter')
overlay_layers = related.SequenceField(
str, DEFAULT_OVERLAY_LAYERS, key='overlayLayers'
)
selected_field = related.StringField('', key='selectedField')
selected_geo_tiles = related.StringField('', key='selectedGeoTiles')
zoom_level = related.FloatField(1.0, key='zoomLevel')
show_administrative_boundaries = related.BooleanField(
True, key='showAdminBoundaries'
)
show_labels = related.BooleanField(False, key='showLabels')
fill_opacity = related.FloatField(0.8, key='fillOpacity')
tooltip_font_color = related.StringField(FONT_COLOR_DEFAULT, key='tooltipFontColor')
tooltip_font_family = related.StringField(
FONT_FAMILY_DEFAULT, key='tooltipFontFamily'
)
tooltip_font_size = related.StringField(FONT_12, key='tooltipFontSize')
tooltip_bold = related.BooleanField(False, key='tooltipBold')
# HACK(stephen, moriah): This setting is really poorly designed. It encodes
# a color value + alpha as a dict instead of rgba or hex + alpha which can
# be represented as a string. FIX THIS OR REMOVE IT.
tooltip_background_color = related.ChildField(
dict, DEFAULT_MAP_TOOLTIP_BACKGROUND, key='tooltipBackgroundColor'
)
class TableSettings:
inverted_fields = related.SequenceField(str, [], key='invertedFields')
table_format = related.ChildField(TableFormat, TableFormat.TABLE, key='tableFormat')
enable_pagination = related.BooleanField(True, key='enablePagination')
row_height = related.FloatField(30, key='rowHeight')
add_total_row = related.BooleanField(False, key='addTotalRow')
header_font_family = related.StringField(
FONT_FAMILY_DEFAULT, key='headerFontFamily'
)
header_color = related.StringField(FONT_COLOR_DEFAULT, key='headerColor')
header_font_size = related.StringField(FONT_12, key='headerFontSize')
header_background = related.StringField('#fff', key='headerBackground')
header_border_color = related.StringField('#d9d9d9', key='headerBorderColor')
row_font_family = related.StringField(FONT_FAMILY_DEFAULT, key='rowFontFamily')
row_color = related.StringField(FONT_COLOR_DEFAULT, key='rowColor')
row_font_size = related.StringField(FONT_12, key='rowFontSize')
row_background = related.StringField('#fff', key='rowBackground')
row_alternate_background = related.StringField(
'#f0f0f0', key='rowAlternateBackground'
)
row_border_color = related.StringField('#d9d9d9', key='rowBorderColor')
footer_font_family = related.StringField(
FONT_FAMILY_DEFAULT, key='footerFontFamily'
)
footer_color = related.StringField(FONT_COLOR_DEFAULT, key='footerColor')
footer_font_size = related.StringField(FONT_12, key='footerFontSize')
footer_background = related.StringField('#fff', key='footerBackground')
footer_border_color = related.StringField('#fff', key='footerBorderColor')
class Suite(Profile):
paths = related.SequenceField(str, default=None)
queued = related.MappingField(Case, "file_path", default={})
skipped = related.MappingField(Case, "file_path", default={})
def __attrs_post_init__(self):
from . import collect
collect(self)
get_logger().debug("suite constructed",
host=self.host,
paths=self.paths,
prefixes=self.prefixes,
extensions=self.extensions,
includes=self.includes,
excludes=self.excludes,
concurrency=self.concurrency)
def get_case(self, path, filename=None):
file_path = os.path.join(path, filename) if filename else path
return self.queued.get(file_path) or self.skipped.get(file_path)
def add_case(self, case):
if case.is_active(self.includes, self.excludes):
self.queued.add(case)
get_logger().debug("case queued", case=case.file_path)
else:
class ExamQuestion:
id = related.StringField(None)
text = related.StringField('')
is_multiple_choice = related.BooleanField(False)
answers = related.SequenceField(ExamQuestionAnswer, None)
points = related.IntegerField(0)
@staticmethod
def from_meta(id: str, meta: ExamQuestionMeta):
meta.validate()
multiple_choice = meta.is_multiple_choice
answers_meta = meta.prepare_answers()
answers = [ExamQuestionAnswer.from_meta(ans) for ans in answers_meta]
return ExamQuestion(id=id,
text=meta.text,
is_multiple_choice=multiple_choice,
answers=answers,
points=meta.points)
def grade(self, meta: ExamQuestionMeta) -> int:
"""
Returns the score for this ExamQuestion instance
"""
grader = get_grader(meta.grader)
if grader:
return grader(meta, self)
return 0
class SearchResults:
beatmaps: List[Beatmap] = related.SequenceField(Beatmap)
result_count: int = related.IntegerField()
@classmethod
def from_json(cls, stream: any):
return related.from_json(stream, cls)
class StoreData(object):
name = related.StringField()
id = related.IntegerField()
created_on = related.DateTimeField("%m/%d/%Y %H:%M:%S")
data_from = related.DateTimeField()
data_to = related.DateTimeField()
days = related.SequenceField(DayData)
class ScenarioResult(object):
uuid = related.UUIDField()
case = related.ChildField(Case, required=None)
scenario = related.ChildField(Namespace, required=None)
success = related.BooleanField(default=True)
step_results = related.SequenceField(StepResult, default=[])
suite = related.ChildField(Suite, required=False)
class Element(object):
keyword = related.StringField()
id = related.StringField()
name = related.StringField()
line = related.IntegerField()
description = related.StringField()
type = related.StringField()
steps = related.SequenceField(Step, default=[])
@classmethod
def create(cls, scenario_result):
uuid = "%s;%s" % (urllib.parse.quote_plus(
scenario_result.case.name), scenario_result.uuid)
# scenario step + steps
steps = [Step.create(None, scenario_result)] + \
[Step.create(step_result, scenario_result)
for step_result in scenario_result.step_results]
return cls(
keyword="Scenario",
name=scenario_result.scenario.__name__,
id=uuid,
line=2,
description="",
type="scenario",
steps=steps,
)
class MyModel(object):
is_for = related.StringField(key="for")
criss = related.StringField(key="cross")
cross = related.StringField(key="criss")
is_not = related.BooleanField(key="not")
is_list = related.SequenceField(str, key="list")
is_type = related.ChildField(DataType, key="type")
is_dict = related.MappingField(MyChild, "int", key="dict", required=False)
class Requestor(object):
path = related.StringField()
method = related.ChildField(Method, default=Method.GET)
host = related.StringField(required=False)
headers = related.ChildField(Namespace, required=False)
params = related.ChildField(Namespace, required=False)
data = related.ChildField(object, required=False)
form = related.ChildField(Namespace, required=False)
files = related.ChildField(Namespace, required=False)
status = related.SequenceField(int, required=False)
def get_params(self, namespace):
dd = self.params.evaluate(namespace) if self.params else {}
params = []
for key, value in dd.items():
if isinstance(value, (tuple, list, set)):
for item in value:
params.append((key, str(item)))
else:
params.append((key, str(value)))
return params
def get_form(self, namespace):
return self.form.evaluate(namespace) if self.form else {}
def get_files(self, dir_path, namespace):
files = self.files.evaluate(namespace) if self.files else {}
files = {
k: open(os.path.join(dir_path, v), "rb")
for k, v in files.items()
}
return files
def get_body(self, namespace):
get_logger().debug("enter get_body",
data_type=type(self.data),
data=self.data)
body = None
if isinstance(self.data, str):
body = Namespace.render(self.data, namespace)
if isinstance(body, Namespace):
body = body.evaluate(namespace)
elif isinstance(self.data, dict):
body = Namespace(self.data).evaluate(namespace)
get_logger().debug("render get_body", body_type=type(body), body=body)
return body
def get_data(self, namespace):
""" Returns body or form and a flag indicating if a form or not."""
body = self.get_body(namespace) if self.data else None
form = self.get_form(namespace) if self.form else None
return (body, False) if body else (form, True)
class AlertDefinition(AlertDefinitionMeta):
'''Object representation of a alert definition.
'''
# TODO(toshi): Perhaps this should have the basic _uri be part of this.
checks = related.SequenceField(AlertCheck)
time_granularity = related.StringField(key='timeGranularity')
field_id = related.StringField(key='fieldId')
dimension_name = related.StringField(key='dimensionName')
class Step(object):
description = related.StringField()
request = related.ChildField(Requestor)
extract = related.ChildField(Namespace, default=Namespace())
iterate = related.ChildField(Iterator, default=Iterator())
validate = related.SequenceField(Validator, required=False)
condition = related.BooleanField(required=False, default=None)
transform = related.StringField(required=False, default=None)
name = related.StringField(required=False, default=None)
sleep = related.FloatField(required=False, default=0.01)
class AnimatedMapSettings:
base_layer = related.ChildField(BaseMapLayer, BaseMapLayer.STREETS, key='baseLayer')
current_display = related.StringField('dots', key='currentDisplay')
map_center = related.ChildField(Coordinates, [0.0, 0.0], key='mapCenter')
overlay_layers = related.SequenceField(
str, DEFAULT_OVERLAY_LAYERS, key='overlayLayers'
)
selected_field = related.StringField('', key='selectedField')
selected_geo_tiles = related.StringField('', key='selectedGeoTiles')
zoom_level = related.FloatField(1.0, key='zoomLevel')
def MultiTypeSequenceField(base_classes):
'''This field type allows multiple class types to be stored in the same
sequence of a related model.
NOTE(stephen): Because Potion is deserializing the raw request into full
Dimension and Granularity models, this field doesn't actually do any
deserialization. It most likely wouldn't work if it needed to.
'''
attrib = related.SequenceField(base_classes[0])
attrib.converter = MultiTypeSequenceConverter(base_classes)
return attrib
class AdvancedFieldDefinition:
id = related.StringField()
calculation = related.ChildField(dict)
canonical_name = related.StringField(key='canonicalName')
category = related.ChildField(dict)
customizable_filter_items = related.SequenceField(
dict, key='customizableFilterItems')
description = related.StringField()
label = related.StringField()
short_name = related.StringField(key='shortName')
source = related.ChildField(dict)
class DetectorMapping:
detector = related.ChildField(DetectorUUID)
expression = related.ChildField(DetectorMappingExpression)
user = related.ChildField(DetectorMappingUser)
fields = related.SequenceField(str, required=False)
id = related.StringField(required=False)
last_modified_time_in_millis = related.IntegerField(
required=False, key="lastModifiedTimeInMillis")
created_time_in_millis = related.IntegerField(required=False,
key="createdTimeInMillis")
enabled = related.BooleanField(required=False)
class HeatTileSettings:
divergent_coloration = related.BooleanField(True, key='divergentColoration')
first_y_axis_selections = related.SequenceField(str, [], key='firstYaxisSelections')
invert_coloration = related.BooleanField(False, key='invertColoration')
log_scaling = related.BooleanField(True, key='logScaling')
result_limit = related.IntegerField(100, key='resultLimit')
selected_field = related.StringField('', key='selectedField')
show_time_on_y_axis = related.BooleanField(True, key='showTimeOnYAxis')
sort_order = related.ChildField(SortOrder, SortOrder.DESCENDING, key='sortOrder')
sort_on = related.StringField('', key='sortOn')
use_ethiopian_dates = related.BooleanField(False, key='useEthiopianDates')
