def load_traffic_types(data: List[Dict[str, str]], unknown_handler: str = 'RAISE') -> Optional[List[TrafficType]]:
"""
TrafficType dict data loader
:param data: TrafficType data
:param unknown_handler: Include or Exclude unknown fields
:return: TrafficType object
"""
loaded_traffic_types = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_traffic_types = traffic_type_schema.TrafficTypeSchema(many=True).load(data)
elif handler == "exclude":
loaded_traffic_types = traffic_type_schema_exclude.TrafficTypeSchemaExclude(many=True).load(data)
return loaded_traffic_types
def load_segment_keys(data: dict, unknown_handler: str = 'RAISE') -> Optional[SegmentKeys]:
"""
Segment Keys dict data loader
:param data: Segment Keys data
:param unknown_handler: Include or Exclude unknown fields
:return: Segment Keys object
"""
loaded_segment_keys = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_segment_keys = segment_keys_schema.SegmentKeysSchema().load(data)
elif handler == "exclude":
loaded_segment_keys = segment_keys_schema_exclude.SegmentKeysSchemaExclude().load(data)
return loaded_segment_keys
def load_split(data: dict, unknown_handler: str = 'RAISE') -> Optional[Split]:
"""
Split dict data loader
:param data: Split data
:param unknown_handler: Include or Exclude unknown fields
:return: Split object
"""
loaded_split = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_split = SplitSchema().load(data)
elif handler == "exclude":
loaded_split = SplitSchemaExclude().load(data)
return loaded_split
def load_workspaces(data: dict,
unknown_handler: str = 'RAISE') -> Optional[Workspaces]:
"""
Workspaces dict data loader
:param data: Workspaces data
:param unknown_handler: Include or Exclude unknown fields
:return: Workspaces object
"""
loaded_workspaces = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_workspaces = WorkspacesSchema().load(data)
elif handler == "exclude":
loaded_workspaces = WorkspacesSchemaExclude().load(data)
return loaded_workspaces
def load_tags(data: List[Dict[str, str]],
unknown_handler: str = 'RAISE') -> Optional[List[Tags]]:
"""
Tags dict data loader
:param data: Tags data
:param unknown_handler: Include or Exclude unknown fields
:return: Tags object
"""
loaded_tags = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_tags = tags_schema.TagsSchema().load(data)
elif handler == "exclude":
loaded_tags = tags_schema_exclude.TagsSchemaExclude().load(data)
return loaded_tags
def load_environment(data: dict,
unknown_handler: str = 'RAISE') -> Optional[Environment]:
"""
Environment dict data loader
:param data: Environment data
:param unknown_handler: Include or Exclude unknown fields
:return: Environment object
"""
loaded_environment = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_environment = environment_schema.EnvironmentSchema().load(data)
elif handler == "exclude":
loaded_environment = environment_schema_exclude.EnvironmentSchemaExclude(
).load(data)
return loaded_environment
def load_environments(
data: List[Dict[str, Union[str, bool]]],
unknown_handler: str = 'RAISE') -> Optional[List[Environment]]:
"""
Environments dict data loader
:param data: Environments data
:param unknown_handler: Include or Exclude unknown fields
:return: Environments object
"""
loaded_environments = None
handler = Utils.get_unknown_field_handler(unknown_handler)
if handler == "raise":
loaded_environments = environment_schema.EnvironmentSchema(
many=True).load(data)
elif handler == "exclude":
loaded_environments = environment_schema_exclude.EnvironmentSchemaExclude(
many=True).load(data)
return loaded_environments