def __init__(self,repo): DataBase.__init__(self,"freecad",repo) self.bases = [] self.base_classes = Links() self.collection_bases = Links() if not exists(self.backend_root): e = MalformedRepositoryError("freecad directory does not exist") e.set_repo_path(repo.path) raise e for coll in listdir(self.backend_root): basefilename = join(self.backend_root,coll,"%s.base" % coll) if not exists(basefilename): #skip directory that is no collection continue base_info = list(yaml.load_all(open(basefilename,"r","utf8"))) if len(base_info) != 1: raise MalformedCollectionError( "Not exactly one YAML document found in file %s" % basefilename) base_info = base_info[0] for basefile in base_info: if basefile["type"] == "function": basepath = join(self.backend_root,coll,basefile["filename"]) if not exists(basepath): raise MalformedBaseError("Python module %s does not exist" % basepath) for func in basefile["functions"]: try: function = BaseFunction(func,basefile,coll,self.backend_root) self.bases.append(function) self.collection_bases.add_link(repo.collections[coll],function) for id in func["classids"]: if not id in repo.classes: raise MalformedBaseError( "Unknown class %s" % id) if self.base_classes.contains_dst(repo.classes[id]): raise NonUniqueBaseError(id) self.base_classes.add_link(function,repo.classes[id]) except ParsingError as e: e.set_base(basefile["filename"]) e.set_collection(coll) raise e else: raise MalformedBaseError("Unknown base type %s" % basefile["type"])
def __init__(self, repo): DataBase.__init__(self, "openscad", repo) self.modules = [] self.scadfiles = [] self.connectors = [] self.module_classes = Links() self.scadfile_modules = Links() self.collection_modules = Links() self.collection_scadfiles = Links() self.module_connectors = BijectiveLinks() if not exists(join(self.backend_root)): e = MalformedRepositoryError("openscad directory does not exist") e.set_repo_path(repo.path) raise e for coll in listdir(self.backend_root): basefilename = join(self.backend_root, coll, "%s.base" % coll) if not exists(basefilename): #skip directory that is no collection continue base = list(yaml.load_all(open(basefilename, "r", "utf8"))) if len(base) != 1: raise MalformedCollectionError( "No YAML document found in file %s" % basefilename) base = base[0] for basefile in base: scadfile = SCADFile(basefile, coll) self.scadfiles.append(scadfile) self.collection_scadfiles.add_link(repo.collections[coll], scadfile) if basefile["type"] == "module": for mod in basefile["modules"]: try: module = SCADModule(mod, basefile, coll) self.modules.append(module) self.collection_modules.add_link( repo.collections[coll], module) self.scadfile_modules.add_link(scadfile, module) if "connectors" in mod: connectors = Connectors(mod["connectors"]) self.module_connectors.add_link( module, connectors) for id in module.classids: if not id in repo.classes: raise MalformedBaseError( "Unknown class %s" % id) if self.module_classes.contains_dst( repo.classes[id]): raise NonUniqueBaseError(id) self.module_classes.add_link( module, repo.classes[id]) except ParsingError as e: e.set_base(basefile["filename"]) raise e else: raise MalformedBaseError("Unknown base type %s" % basefile["type"])
def __init__(self, repo): DataBase.__init__(self, "drawings", repo) self.dimdrawings = [] self.condrawings = [] self.conlocations = [] self.dimdrawing_classes = Links() self.condrawings_classes = BipartiteLinks() self.conlocations_condrawings = BipartiteLinks() self.collection_dimdrawings = Links() self.collection_condrawings = Links() if not exists(join(self.backend_root)): e = MalformedRepositoryError("drawings directory does not exist") e.set_repo_path(path) raise e for coll in listdir(self.backend_root): basefilename = join(self.backend_root, coll, "%s.base" % coll) if not exists(basefilename): #skip directory that is no collection continue if coll not in repo.collections: raise MalformedRepositoryError( "Drawings for unknown collection found: %s " % coll) base_info = list(yaml.load_all(open(basefilename, "r", "utf8"))) if len(base_info) != 1: raise MalformedCollectionError( "Not exactly one YAML document found in file %s" % basefilename) base_info = base_info[0] for drawing_element in base_info: if drawing_element["type"] == "drawing-dimensions": draw = DrawingDimensions(drawing_element, coll, self.backend_root) if draw.get_svg() is None and draw.get_png() is None: raise MalformedRepositoryError( "No drawing files present for %s/%s" % (coll, draw.filename)) self.dimdrawings.append(draw) if drawing_element["classids"] == []: raise MalformedBaseError( "Drawing with no associated classes found") for id in drawing_element["classids"]: self.dimdrawing_classes.add_link( draw, self.repo.classes[id]) self.collection_dimdrawings.add_link( repo.collections[coll], draw) if drawing_element["type"] == "drawing-connector": draw = DrawingConnectors(drawing_element, coll, self.backend_root) if draw.get_svg() is None and draw.get_png() is None: raise MalformedRepositoryError( "No drawing files present for %s/%s" % (coll, draw.filename)) if not draw.location in self.conlocations: self.conlocations.append(draw.location) self.conlocations_condrawings.add_link(draw.location, draw) self.condrawings.append(draw) for id in drawing_element["classids"]: self.condrawings_classes.add_link( draw, self.repo.classes[id]) self.collection_condrawings.add_link( repo.collections[coll], draw)
def __init__(self, path): #check for conformity if not exists(path): e = MalformedRepositoryError("Repo directory does not exist") e.set_repo_path(path) raise e if not exists(join(path, "data")): e = MalformedRepositoryError("No data directory found") e.set_repo_path(path) raise e self.path = path #objects that have an id self.classes = {} self.collections = {} self.names = {} self.standards = {} self.multinames = {} self.multistandards = {} self.bodies = {} #relations self.class_names = Links() self.class_standards = Links() self.multiname_names = Links() self.multistandard_standards = Links() self.body_standards = Links() self.body_multistandards = Links() self.collection_classes = Links() self.collection_standards = Links() self.collection_multistandards = Links() self.collection_names = Links() self.collection_multinames = Links() self.standard_replaced = Links(1) #load collection data for filename in os.listdir(join(path, "data")): if splitext(filename)[1] != ".blt": continue raw_coll = list( yaml.load_all(open(join(path, "data", filename), "r", "utf8"))) if len(raw_coll) == 0: raise MalformedCollectionError( "No YAML document found in file %s" % filename) if len(raw_coll) > 1: raise MalformedCollectionError( "More than one YAML document found in file %s" % filename) #we only consider the first YAML document raw_coll = raw_coll[0] if not isinstance(raw_coll["classes"], list): raise MalformedCollectionError("No class in collection %s" % raw_coll["id"]) if raw_coll["id"] in self.collections: raise MalformedCollectionError("Duplicate collection id %s" % raw_coll["id"]) if raw_coll["id"] != splitext(filename)[0]: raise MalformedCollectionError( "Collection ID is not identical with file name: %s" % filename) for c in raw_coll["id"]: if not c in string.ascii_letters + string.digits + "_": raise MalformedCollectionError( "Collection ID contains invalid character: %s" % c) try: coll = Collection(raw_coll) self.collections[coll.id] = coll except ParsingError as e: e.set_repo_path(path) e.set_collection(filename) raise e for cl in raw_coll['classes']: if cl["id"] in self.classes: raise MalformedRepositoryError("Duplicate class id %s" % cl["id"]) try: cls = Class(cl) self.classes[cls.id] = cls except ParsingError as e: e.set_class(cl["id"]) e.set_repo_path(path) e.set_collection(filename) raise e self.collection_classes.add_link(coll, cls) names = [] standards = [] if 'names' in cl: if isinstance(cl['names'], list): names = cl['names'] else: names = [cl['names']] if 'standards' in cl: if isinstance(cl['standards'], list): standards = cl['standards'] else: standards = [cl['standards']] if len(names + standards) == 0: raise MalformedCollectionError( "Encountered class with no names: %s" % raw_coll["id"]) for cn in names: try: name = ClassName(cn) except ParsingError as e: e.set_class(cls.id) raise e if name.get_id() in self.names: raise MalformedRepositoryError("Duplicate name %s" % name.get_id()) self.names[name.get_id()] = name self.class_names.add_link(cls, name) multinameid = name.group.get_safe() if multinameid: if not multinameid in self.multinames: multiname = MultiName(name.group) self.multinames[multinameid] = multiname else: multiname = self.multinames[multinameid] self.collection_multinames.add_link(coll, multiname) self.multiname_names.add_link(multiname, name) else: self.collection_names.add_link(coll, name) for sn in standards: try: standard = ClassStandard(sn) except ParsingError as e: e.set_class(cls.id) raise e if standard.get_id() in self.standards: raise MalformedRepositoryError( "Duplicate standard %s" % standard.get_id()) self.standards[standard.get_id()] = standard self.class_standards.add_link(cls, standard) bodyid = standard.body if bodyid in self.bodies: body = self.bodies[bodyid] else: body = StandardBody(bodyid) self.bodies[bodyid] = body self.body_standards.add_link(body, standard) self.collection_standards.add_link(coll, standard) multistdid = standard.group.get_safe() if multistdid: if not multistdid in self.multistandards: multistd = MultiStandard(standard.group) self.multistandards[multistdid] = multistd self.body_multistandards.add_link(body, multistd) self.collection_multistandards.add_link( coll, multistd) else: multistd = self.multistandards[multistdid] self.multistandard_standards.add_link( multistd, standard) for standard in self.standards.values(): if not standard.replaces is None: if not standard.replaces in self.standards: raise MalformedRepositoryError( "Unknown replace field %s in standard %s" % (standard.replaces, standard.get_id())) self.standard_replaced.add_link( standard, self.standards[standard.replaces])