def dict_attribute_loader():
class DictAttributeLoader(yatiml.Loader):
pass
yatiml.add_to_loader(DictAttributeLoader, DictAttribute)
yatiml.set_document_type(DictAttributeLoader, DictAttribute)
return DictAttributeLoader
def super_loader():
class SuperLoader(yatiml.Loader):
pass
yatiml.add_to_loader(SuperLoader, [Super, SubA, SubB])
yatiml.set_document_type(SuperLoader, Super)
return SuperLoader
def enum_list_loader():
class EnumListLoader(yatiml.Loader):
pass
yatiml.add_to_loader(EnumListLoader, Color2)
yatiml.set_document_type(EnumListLoader, List[Color2])
return EnumListLoader
def vector_loader():
class VectorLoader(yatiml.Loader):
pass
yatiml.add_to_loader(VectorLoader, Vector2D)
yatiml.set_document_type(VectorLoader, Vector2D)
return VectorLoader
def document1_loader():
class Document1Loader(yatiml.Loader):
pass
yatiml.add_to_loader(Document1Loader, Document1)
yatiml.set_document_type(Document1Loader, Document1)
return Document1Loader
def enum_dict_loader():
class EnumDictLoader(yatiml.Loader):
pass
yatiml.add_to_loader(EnumDictLoader, Color2)
yatiml.set_document_type(EnumDictLoader, Dict[str, Color2])
return EnumDictLoader
def super2_loader():
class Super2Loader(yatiml.Loader):
pass
yatiml.add_to_loader(Super2Loader, [Super2, SubA2, SubB2])
yatiml.set_document_type(Super2Loader, Super2)
return Super2Loader
def dashed_attribute_loader():
class DashedAttributeLoader(yatiml.Loader):
pass
yatiml.add_to_loader(DashedAttributeLoader, DashedAttribute)
yatiml.set_document_type(DashedAttributeLoader, DashedAttribute)
return DashedAttributeLoader
def bool_fix_tester_loader():
class BoolFixTesterLoader(yatiml.Loader):
pass
yatiml.set_document_type(BoolFixTesterLoader, BoolFixTester)
yatiml.add_to_loader(BoolFixTesterLoader, BoolFixTester)
return BoolFixTesterLoader
def union_attribute_loader():
class UnionAttributeLoader(yatiml.Loader):
pass
yatiml.add_to_loader(UnionAttributeLoader, UnionAttribute)
yatiml.set_document_type(UnionAttributeLoader, UnionAttribute)
return UnionAttributeLoader
def parsed_class_loader():
class ParsedClassLoader(yatiml.Loader):
pass
yatiml.add_to_loader(ParsedClassLoader, Postcode)
yatiml.set_document_type(ParsedClassLoader, Postcode)
return ParsedClassLoader
def universal_loader():
class UniversalLoader(yatiml.Loader):
pass
yatiml.add_to_loader(UniversalLoader, Universal)
yatiml.set_document_type(UniversalLoader, Universal)
return UniversalLoader
def extensible_loader():
class ExtensibleLoader(yatiml.Loader):
pass
yatiml.add_to_loader(ExtensibleLoader, Extensible)
yatiml.set_document_type(ExtensibleLoader, Extensible)
return ExtensibleLoader
def user_string_loader():
class UserStringLoader(yatiml.Loader):
pass
yatiml.add_to_loader(UserStringLoader, ConstrainedString)
yatiml.set_document_type(UserStringLoader, ConstrainedString)
return UserStringLoader
def enum_loader2():
class EnumLoader2(yatiml.Loader):
pass
yatiml.add_to_loader(EnumLoader2, Color2)
yatiml.set_document_type(EnumLoader2, Color2)
return EnumLoader2
def missing_circle_loader():
class MissingCircleLoader(yatiml.Loader):
pass
yatiml.add_to_loader(MissingCircleLoader,
[Shape, Rectangle, Ellipse, Vector2D])
yatiml.set_document_type(MissingCircleLoader, Shape)
return MissingCircleLoader
def shape_loader():
class ShapeLoader(yatiml.Loader):
pass
yatiml.add_to_loader(ShapeLoader,
[Shape, Rectangle, Circle, Ellipse, Vector2D])
yatiml.set_document_type(ShapeLoader, Shape)
return ShapeLoader
def document2_loader():
class Document2Loader(yatiml.Loader):
pass
yatiml.add_to_loader(
Document2Loader,
[Color2, Document2, Shape, Rectangle, Circle, Vector2D])
yatiml.set_document_type(Document2Loader, Document2)
return Document2Loader
def __init__(self, seq: Any) -> None:
super().__init__(seq)
if not self.data.istitle():
raise ValueError('Invalid TitleCaseString \'{}\': Each word must'
' start with a capital letter'.format(self.data))
class Submission:
def __init__(self, name: str, age: Union[int, str],
town: TitleCaseString) -> None:
self.name = name
self.age = age
self.town = town
# Create loader
class MyLoader(yatiml.Loader):
pass
yatiml.add_to_loader(MyLoader, [TitleCaseString, Submission])
yatiml.set_document_type(MyLoader, Submission)
# Load YAML
yaml_text = ('name: Janice\n' 'age: 6\n' 'town: Piedmont')
doc = yaml.load(yaml_text, Loader=MyLoader)
print(type(doc))
print(doc.name)
print(doc.town)
def __init__(
self,
name: str,
age: Union[int, str],
drawing: List[Shape]
) -> None:
self.name = name
self.age = age
self.drawing = drawing
# Create loader
class MyLoader(yatiml.Loader):
pass
yatiml.add_to_loader(MyLoader, [Color, Shape, Circle, Square, Submission])
yatiml.set_document_type(MyLoader, Submission)
# Load YAML
yaml_text = ('name: Janice\n'
'age: 6\n'
'drawing:\n'
' - center: [1.0, 1.0]\n'
' color: red\n'
' radius: 2.0\n'
' - center: [5.0, 5.0]\n'
' color: blue\n'
' width: 1.0\n'
' height: 1.0\n')
doc = yaml.load(yaml_text, Loader=MyLoader)
@classmethod
def yatiml_sweeten(self, node: yatiml.Node) -> None:
namespace_nodes = node.get_attribute('namespaces').seq_items()
namespaces = list(map(yatiml.Node.get_value, namespace_nodes))
namespace_str = '.'.join(namespaces)
name = node.get_attribute('name').get_value()
node.set_value('{}.{}'.format(namespace_str, name))
class MyLoader(yatiml.Loader):
pass
yatiml.add_to_loader(MyLoader, Identifier)
yatiml.set_document_type(MyLoader, Identifier)
class MyDumper(yatiml.Dumper):
pass
yatiml.add_to_dumper(MyDumper, Identifier)
yaml_text = ('yatiml.logger.setLevel\n')
doc = yaml.load(yaml_text, Loader=MyLoader)
print(type(doc))
print(doc.namespaces)
print(doc.name)
self.echo_run = echo_run
self.enable_callers = enable_callers
self.mode = mode
self.genome = genome
self.exclusion_list = exclusion_list
self.exclude_regions = exclude_regions
self.file_exts = file_exts
self.samples = samples
self.callers = callers
self.postproc = postproc
# Create loader
class MyLoader(yatiml.Loader):
"""
MyLoader class.
"""
pass
def load_configfile(yaml_file: str) -> Dict:
with open(yaml_file, 'r') as conf:
return yaml.load(conf, MyLoader)
yatiml.logger.setLevel(logging.DEBUG)
yatiml.add_to_loader(MyLoader, [Mode, FileExtension, Resource, Manta, Delly,
Lumpy, Gridss, Caller, SurvivorFilter, SurvivorMerge,
Survivor, PostProcess, Analysis])
yatiml.set_document_type(MyLoader, Analysis)
@classmethod
def _yatiml_savorize(cls, node: yatiml.Node) -> None:
str_to_int = {
'five': 5,
'six': 6,
'seven': 7,
}
if node.has_attribute_type('age', str):
str_val = node.get_attribute('age').get_value()
if str_val in str_to_int:
node.set_attribute('age', str_to_int[str_val])
else:
raise yatiml.SeasoningError('Invalid age string')
# Create loader
class MyLoader(yatiml.Loader):
pass
yatiml.add_to_loader(MyLoader, Submission)
yatiml.set_document_type(MyLoader, Submission)
# Load YAML
yaml_text = ('name: Janice\n' 'age: six\n')
doc = yaml.load(yaml_text, Loader=MyLoader)
print(doc.name)
print(doc.age)
print(doc.tool)
@classmethod
def _yatiml_savorize(cls, node: yatiml.Node) -> None:
node.dashes_to_unders_in_keys()
@classmethod
def _yatiml_sweeten(cls, node: yatiml.Node) -> None:
node.unders_to_dashes_in_keys()
# Create loader
class MyLoader(yatiml.Loader):
pass
yatiml.add_to_loader(MyLoader, Dashed)
yatiml.set_document_type(MyLoader, Dashed)
# Create dumper
class MyDumper(yatiml.Dumper):
pass
yatiml.add_to_dumper(MyDumper, Dashed)
# Load YAML
yaml_text = ('an-attribute: 42\n' 'another-attribute: with-dashes\n')
doc = yaml.load(yaml_text, Loader=MyLoader)
print(type(doc))
