def __init__(self, cn): check_schema(cn, "classname", ["name", "labeling"], ["description", "group"]) Designation.__init__(self) try: if isinstance(cn['name'], str): self.name = Identifier({'nice': cn['name']}) else: self.name = Identifier(cn['name']) if isinstance(cn['labeling'], str): self.labeling = Substitution({'nice': cn['labeling']}) else: self.labeling = Substitution(cn['labeling']) except ParsingError as e: e.set_class(self.id) raise e self.description = cn.get('description', '') if 'group' in cn: if isinstance(cn['group'], str): self.group = Identifier({'nice': cn['group']}) else: self.group = Identifier(cn['group']) else: self.group = Identifier({'nice': ""})
def __init__(self, sn): check_schema(sn, 'classstandard', ['standard', 'labeling', 'body'], ['group', 'year', 'status', 'replaces', 'description']) Designation.__init__(self) if isinstance(sn['standard'], str): self.standard = Identifier({'nice': sn['standard']}) else: self.standard = Identifier(sn['standard']) if 'group' in sn: if isinstance(sn['group'], str): self.group = Identifier({'nice': sn['group']}) else: self.group = Identifier(sn['group']) else: self.group = Identifier({'nice': ""}) if isinstance(sn['labeling'], str): self.labeling = Substitution({'nice': sn['labeling']}) else: self.labeling = Substitution(sn['labeling']) self.body = sn['body'] self.year = sn.get('year', None) self.status = sn.get('status', 'active') self.replacedby = None self.replaces = sn.get('replaces', None) self.description = sn.get('description', '')
def __init__(self, coll): check_schema(coll, "collection", ["id", "author", "license", "blt-version", "classes"], ["name", "description"]) version = coll["blt-version"] if version != CURRENT_VERSION: raise VersionError(version) self.id = coll["id"] self.name = coll.get("name", "") self.description = coll.get("description", "") self.authors = coll["author"] if isinstance(self.authors, str): self.authors = [self.authors] self.author_names = [] self.author_mails = [] for author in self.authors: match = parse_angled(author) self.author_names.append(match[0]) self.author_mails.append(match[1]) self.license = coll["license"] match = parse_angled(self.license) self.license_name = match[0] self.license_url = match[1]
def test_wellformed(self): res = yaml.load(""" a: 100 b: Eimer c: 3.4 """) common.check_schema(res, "Tests", ["a", "b"], ["c", "d"])
def __init__(self, sn): check_schema( sn, "classstandard", ["standard", "labeling", "body"], ["group", "year", "status", "replaces", "description"], ) Designation.__init__(self) if isinstance(sn["standard"], str): self.standard = Identifier({"nice": sn["standard"]}) else: self.standard = Identifier(sn["standard"]) if "group" in sn: if isinstance(sn["group"], str): self.group = Identifier({"nice": sn["group"]}) else: self.group = Identifier(sn["group"]) else: self.group = Identifier({"nice": ""}) if isinstance(sn["labeling"], str): self.labeling = Substitution({"nice": sn["labeling"]}) else: self.labeling = Substitution(sn["labeling"]) self.body = sn["body"] self.year = sn.get("year", None) self.status = sn.get("status", "active") self.replacedby = None self.replaces = sn.get("replaces", None) self.description = sn.get("description", "")
def __init__(self, cn): check_schema(cn, "classname", ["name", "labeling"], ["description", "group"]) Designation.__init__(self) try: if isinstance(cn["name"], str): self.name = Identifier({"nice": cn["name"]}) else: self.name = Identifier(cn["name"]) if isinstance(cn["labeling"], str): self.labeling = Substitution({"nice": cn["labeling"]}) else: self.labeling = Substitution(cn["labeling"]) except ParsingError as e: e.set_class(self.id) raise e self.description = cn.get("description", "") if "group" in cn: if isinstance(cn["group"], str): self.group = Identifier({"nice": cn["group"]}) else: self.group = Identifier(cn["group"]) else: self.group = Identifier({"nice": ""})
def __init__(self, cs): check_schema(cs, "connectors", ["name", "arguments", "locations"], []) self.name = cs["name"] self.arguments = cs["arguments"] if not "location" in self.arguments: raise MissingLocationError(self.arguments) self.locations = cs["locations"]
def test_wellformed(self): res = yaml.load( """ a: 100 b: Eimer c: 3.4 """) common.check_schema(res,"Tests",["a","b"],["c","d"])
def __init__(self,basefile,collname,backend_root): check_schema(basefile,"drawing", ["filename","author","license","type","classids","location"], ["source"] ) Drawing.__init__(self,basefile,collname,backend_root) self.location = basefile["location"]
def __init__(self, basefile, collname, backend_root): check_schema( basefile, "drawing", ["filename", "author", "license", "type", "classids", "location"], ["source"]) Drawing.__init__(self, basefile, collname, backend_root) self.location = basefile["location"]
def __init__(self,coll): check_schema(coll,"collection", ["id","author","license","blt-version","classes"], ["name","description"] ) version = coll["blt-version"] if version != CURRENT_VERSION: raise VersionError(version) self.id = coll["id"] self.name = "" if "name" in coll: self.name = coll["name"] self.description = "" if "description" in coll: self.description = coll["description"] self.authors = coll["author"] if isinstance(self.authors,str): self.authors = [self.authors] self.author_names = [] self.author_mails = [] for author in self.authors: match = parse_angled(author) self.author_names.append(match[0]) self.author_mails.append(match[1]) self.license = coll["license"] match = parse_angled(self.license) self.license_name = match[0] self.license_url = match[1] #parse classes if not isinstance(coll["classes"],list): raise MalformedCollectionError("No class in collection %s"% self.id) self.classes = [] classids = [] for cl in coll["classes"]: names = cl["id"] if cl["id"] in classids: raise NonUniqueClassIdError(cl["id"]) classids.append(cl["id"]) if "standard" in cl: names = cl["standard"] if isinstance(names,str): names = [names] for name in names: try: self.classes.append(BOLTSClass(cl,name)) except ParsingError as e: e.set_class(name) raise
def __init__(self,cs): check_schema(cs,"connectors", ["name","arguments","locations"], []) self.name = cs["name"] self.arguments = cs["arguments"] if not "location" in self.arguments: raise MissingLocationError(self.arguments) self.locations = cs["locations"]
def __init__(self,cl): check_schema(cl,"basesolidworks", ["classid"], ["naming"] ) self.classid = cl["classid"] self.naming = Substitution(cl.get("naming",None))
def __init__(self,basefile,collname): check_schema(basefile,"basestl", ["filename","author","license","type","classids"], ["source"]) OpenSCADGeometry.__init__(self,basefile,collname) self.classids = basefile["classids"] if "parameters" in basefile: self.parameters = BOLTSParameters(basefile["parameters"]) else: self.parameters = BOLTSParameters({})
def __init__(self,cl): check_schema(cl,"basesolidworks", ["classid"], ["naming"] ) self.classid = cl["classid"] self.naming = None if "naming" in cl: self.naming = BOLTSNaming(cl["naming"])
def __init__(self, mod, basefile, collname): check_schema(mod, "basemodule", ["name", "arguments", "classids"], ["parameters", "connectors"]) check_schema(basefile, "basemodule", ["filename", "author", "license", "type", "modules"], ["source"]) BaseElement.__init__(self, basefile) self.name = mod["name"] self.arguments = mod["arguments"] self.classids = mod["classids"] self.parameters = Parameters(mod.get("parameters", {"types": {}}))
def __init__(self,function,basefile,collname,backend_root): check_schema(function,"basefunction", ["name","classids"], ["parameters"] ) check_schema(basefile,"basefunction", ["filename","author","license","type","functions"], ["source"] ) FreeCADGeometry.__init__(self,basefile,collname,backend_root) self.name = function["name"] self.classids = function["classids"] self.module_name = splitext(basename(self.filename))[0] self.parameters = Parameters(function.get("parameters",{"types" : {}}))
def __init__(self, cl): check_schema(cl, "class", ["source", "id"], ["names", "standards", "parameters", "url", "notes"]) self.id = cl["id"] try: self.parameters = Parameters(cl.get("parameters", {"types": {}})) except ParsingError as e: e.set_class(self.id) raise e self.url = cl.get("url", "") self.notes = cl.get("notes", "") self.source = cl["source"]
def __init__(self,mod,basefile,collname): check_schema(mod,"basemodule", ["name", "arguments","classids"], ["parameters","connectors"]) check_schema(basefile,"basemodule", ["filename","author","license","type","modules"], ["source"]) BaseElement.__init__(self,basefile) self.name = mod["name"] self.arguments = mod["arguments"] self.classids = mod["classids"] self.parameters = Parameters(mod.get("parameters",{"types" : {}}))
def __init__(self,basefile,collname,backend_root): BaseElement.__init__(self,basefile,collname) check_schema(basefile,"drawing", ["filename","author","license","type","classids"], ["source"] ) self.collection = collname self.filename = basefile["filename"] self.path = join(backend_root,collname,self.filename) self.classids = basefile["classids"] self.versions = {} for version in iglob(self.path + ".*"): ext = splitext(version)[1][1:] self.versions[ext] = version
def get_vehicle_schema(): """ Create the schema for the Agency GET /vehicles endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/agency/get_vehicle.json") definitions = common.load_definitions( "propulsion_types", "string", "timestamp", "vehicle_type", "uuid" ) schema["definitions"].update(definitions) # merge the state machine definitions and transition combinations rule state_machine_defs, transitions = common.vehicle_state_machine("state", "prev_events") schema["definitions"].update(state_machine_defs) schema["allOf"].append(transitions) # merge common vehicle information, with Agency tweaks vehicle = common.vehicle_definition(provider_name=False) schema["required"] = vehicle["required"] + schema["required"] schema["properties"] = { **vehicle["properties"], **schema["properties"] } # verify and return return common.check_schema(schema)
def vehicles_schema(): """ Create the schema for the /vehicles endpoint. """ definitions, properties = {}, {} prop, defn = common.property_definition("links") definitions.update(defn) properties.update(prop) prop, _ = common.property_definition("last_updated", ref=common.definition_id("timestamp")) properties.update(prop) prop, defn = common.property_definition("ttl") definitions.update(defn) properties.update(prop) state_defs, transitions = common.vehicle_state_machine( "last_vehicle_state", "last_event_types") definitions.update(state_defs) schema = endpoint_schema("vehicles", definitions) # update list of required and properties object schema["required"].extend(["last_updated", "ttl"]) schema["properties"].update(properties) # add state machine transition rules schema["properties"]["data"]["properties"]["vehicles"]["items"][ "allOf"].append(transitions) # verify and return return common.check_schema(schema)
def stops_schema(): """ Create the schema for the /stops endpoint. """ definitions, properties = {}, {} prop, _ = common.property_definition("last_updated", ref=common.definition_id("timestamp")) properties.update(prop) prop, defn = common.property_definition("ttl") definitions.update(defn) properties.update(prop) stop_defs = common.stop_definitions() definitions.update(stop_defs) schema = endpoint_schema("stops", definitions) # update list of required and properties object schema["required"].extend(["last_updated", "ttl"]) schema["properties"].update(properties) # verify and return return common.check_schema(schema)
def trips_schema(): """ Create the schema for the /trips endpoint. """ # generate the route definition mds_feature_collection_route = feature_collection_schema( id=common.definition_id("MDS_FeatureCollection_Route"), title="MDS GeoJSON FeatureCollection Route", # 1. Only allow MDS Feature Points # 2. There must be *at least* two Features in the FeatureCollection. features={ "items": { "$ref": common.definition_id("MDS_Feature_Point") }, "minItems": 2 }) trips_definitions = { "currency": common.load_definitions("currency"), "MDS_FeatureCollection_Route": mds_feature_collection_route } # create the trips schema schema = endpoint_schema("trips", trips_definitions) # verify and return return common.check_schema(schema)
def test_missing_field(self): res = yaml.load( """ a: 100 c: 3.4 """) self.assertRaises(MissingFieldError,lambda: common.check_schema(res,"Tests",["a","b"],["c","d"]))
def test_missing_field(self): res = yaml.load(""" a: 100 c: 3.4 """) self.assertRaises( MissingFieldError, lambda: common.check_schema(res, "Tests", ["a", "b"], ["c", "d"]))
def test_unknown_field(self): res = yaml.load(""" a: 100 b: Eimer c: 3.4 e: foo """) self.assertRaises(UnknownFieldError,lambda: common.check_schema(res,"Tests",["a","b"],["c","d"]))
def test_unknown_field(self): res = yaml.load( """ a: 100 b: Eimer c: 3.4 e: foo """) self.assertRaises(UnknownFieldError,lambda: common.check_schema(res,"Tests",["a","b"],["c","d"]))
def geographies_schema(): """ Create the schema for the Geographies endpoint. """ # load schema template and insert definitions from geography geography = geography_schema() schema = common.load_json("./templates/geography/geographies.json") schema["definitions"].update(geography["definitions"]) return common.check_schema(schema)
def post_stops_schema(): """ Create the schema for the Agency POST /stops endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/agency/post_stops.json") stops = common.stop_definitions() schema["definitions"].update(stops) # verify and return return common.check_schema(schema)
def __init__(self,obj,basefile, collname,backend_root): check_schema(basefile,"basefcstd", ["filename","author","license","type","objects"], ["source"]) check_schema(obj,"basefcstd", ["objectname","classids"], ["proptoparam","parameters"] ) FreeCADGeometry.__init__(self,basefile,collname,backend_root) self.objectname = obj["objectname"] self.proptoparam = {self.objectname : {"Label" : "name"}} if "proptoparam" in obj: self.proptoparam = obj["proptoparam"] if "parameters" in obj: self.parameters = BOLTSParameters(obj["parameters"]) else: self.parameters = BOLTSParameters({}) self.classids = obj["classids"]
def post_vehicle_telemetry_schema(): """ Create the schema for the Agency POST /vehicles/telemetry endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/agency/post_vehicle_telemetry.json") definitions = common.load_definitions("timestamp", "uuid") definitions["vehicle_telemetry"] = vehicle_telemetry() schema["definitions"].update(definitions) # verify and return return common.check_schema(schema)
def __init__(self, designtable, collname, backend_root): BaseElement.__init__(self, designtable, collname) check_schema(designtable, "basesolidworks", [ "filename", "author", "license", "type", "suffix", "params", "classes" ], ["source", "metadata"]) self.filename = designtable["filename"] self.path = join(backend_root, collname, self.filename) self.suffix = designtable["suffix"] self.outname = "%s-%s.xls" % (splitext(self.filename)[0], self.suffix) self.params = designtable["params"] self.metadata = designtable.get("metadata", {}) self.classes = [] for cl in designtable["classes"]: self.classes.append(DesignTableClass(cl))
def __init__(self,designtable,collname,backend_root): BaseElement.__init__(self,designtable,collname) check_schema(designtable,"basesolidworks", ["filename","author","license","type","suffix","params","classes"], ["source","metadata"] ) self.filename = designtable["filename"] self.path = join(backend_root,collname,self.filename) self.suffix = designtable["suffix"] self.outname = "%s-%s.xls" % (splitext(self.filename)[0],self.suffix) self.params = designtable["params"] self.metadata = designtable.get("metadata",{}) self.classes = [] for cl in designtable["classes"]: self.classes.append(DesignTableClass(cl))
def __init__(self,mod,basefile,collname): check_schema(mod,"basemodule", ["name", "arguments","classids"], ["parameters","connectors"]) check_schema(basefile,"basemodule", ["filename","author","license","type","modules"], ["source"]) OpenSCADGeometry.__init__(self,basefile,collname) self.name = mod["name"] self.arguments = mod["arguments"] self.classids = mod["classids"] if "parameters" in mod: self.parameters = BOLTSParameters(mod["parameters"]) else: self.parameters = BOLTSParameters({"types" : {}}) self.connectors = None if "connectors" in mod: self.connectors = Connectors(mod["connectors"])
def geography_schema(): """ Create the schema for the Geography endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/geography/geography.json") definitions = common.load_definitions("string", "timestamp", "uuid", "version") definitions.update( common.load_definitions("timestamp", "uuid_array", allow_null=True)) schema["definitions"].update(definitions) # verify and return return common.check_schema(schema)
def events_schema(): """ Create the schema for the /events endpoint. """ links_prop, links_def = common.property_definition("links") # events is the same as status_changes, but allows paging schema = status_changes_schema() schema["$id"] = schema["$id"].replace("status_changes", "events") schema["title"] = schema["title"].replace("status_changes", "events") schema["definitions"].update(links_def) schema["properties"].update(links_prop) # verify and return return common.check_schema(schema)
def post_vehicle_schema(): """ Create the schema for the Agency POST /vehicles endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/agency/post_vehicle.json") definitions = common.load_definitions("propulsion_types", "string", "vehicle_type", "uuid") schema["definitions"].update(definitions) # merge common vehicle information, with Agency tweaks vehicle = common.vehicle_definition(provider_name=False, provider_id=False) schema["required"] = vehicle["required"] + schema["required"] schema["properties"] = {**vehicle["properties"], **schema["properties"]} # verify and return return common.check_schema(schema)
def put_stops_schema(): """ Create the schema for the Agency POST /stops endpoint. """ # load schema template and insert definitions # the PUT body allows a small subset of fields schema = common.load_json("./templates/agency/put_stops.json") stops = common.stop_definitions() needed_defs = ["stop_status", "uuid", "vehicle_type_counts"] for key in [k for k in stops.keys() if k not in needed_defs]: del stops[key] schema["definitions"].update(stops) # verify and return return common.check_schema(schema)
def status_changes_schema(): """ Create the schema for the /status_changes endpoint. """ schema = endpoint_schema("status_changes") items = schema["properties"]["data"]["properties"]["status_changes"][ "items"] # merge the state machine definitions and transition combinations rule state_machine_defs, transitions = common.vehicle_state_machine( "vehicle_state", "event_types") schema["definitions"].update(state_machine_defs) items["allOf"].append(transitions) trip_id_ref = common.load_definitions("trip_id_reference") items["allOf"].append(trip_id_ref) # verify and return return common.check_schema(schema)
def post_vehicle_event_schema(): """ Create the schema for the Agency POST /vehicles/:id/event endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/agency/post_vehicle_event.json") definitions = common.load_definitions("timestamp", "uuid") definitions["vehicle_telemetry"] = vehicle_telemetry() schema["definitions"].update(definitions) # merge the state machine definitions and transition combinations rule state_machine_defs, transitions = common.vehicle_state_machine( "vehicle_state", "event_types") schema["definitions"].update(state_machine_defs) schema["allOf"].append(transitions) # add the conditionally-required trip_id rule trip_id_ref = common.load_definitions("trip_id_reference") schema["allOf"].append(trip_id_ref) # verify and return return common.check_schema(schema)
def policy_schema(): """ Create the schema for the Policy endpoint. """ # load schema template and insert definitions schema = common.load_json("./templates/policy/policy.json") definitions = common.load_definitions("currency", "day", "propulsion_type", "string", "timestamp", "uuid", "uuid_array", "vehicle_event", "vehicle_state", "vehicle_type", "version") definitions.update( common.load_definitions("days", "iso_time", "propulsion_types", "timestamp", "uuid_array", "vehicle_types", allow_null=True)) schema["definitions"].update(definitions) # verify and return return common.check_schema(schema)
def __init__(self, cl): check_schema(cl, "basesolidworks", ["classid"], ["naming"]) self.classid = cl["classid"] self.naming = Substitution(cl.get("naming", None))
def __init__(self,cl,name): check_schema(cl,"class", ["naming","source","id"], ["description","standard","status","replaces","parameters", "url","notes"] ) self.id = cl["id"] try: self.naming = BOLTSNaming(cl["naming"]) except ParsingError as e: e.set_class(self.id) raise e self.drawing = None if "drawing" in cl: self.drawing = cl["drawing"] self.description = "" if "description" in cl: self.description = cl["description"] self.standard_body = None self.standard = None self.body = None self.status = "active" self.replaces = None if "standard" in cl: self.standard = cl["standard"] if isinstance(self.standard,str): self.standard = [self.standard] if "status" in cl: self.status = cl["status"] if not self.status in ["active","withdrawn"]: raise ValueError if "replaces" in cl: self.replaces = cl["replaces"] #gets updated later by the repo self.replacedby = None try: if "parameters" in cl: self.parameters = BOLTSParameters(cl["parameters"]) else: self.parameters = BOLTSParameters({"types" : {}}) except ParsingError as e: e.set_class(self.id) raise e self.url = "" if "url" in cl: self.url = cl["url"] self.notes = "" if "notes" in cl: self.notes = cl["notes"] self.source = cl["source"] self.name = name self.openscadname = name.replace("-","_").replace(" ","_").replace(".","_")